kernel - Incidental MPLOCK removal (non-performance)
authorMatthew Dillon <dillon@apollo.backplane.com>
Mon, 9 Jan 2017 22:26:12 +0000 (14:26 -0800)
committerMatthew Dillon <dillon@apollo.backplane.com>
Mon, 9 Jan 2017 22:41:17 +0000 (14:41 -0800)
* proc filterops.

* kernel linkerops and kld code.

* Warn if a non-MPSAFE interrupt is installed.

* Use a private token in the disk messaging core (subr_disk) instead of
  the mp token.

* Use a private token for sysv shm adminstrative calls.

* Cleanup.

sys/kern/kern_event.c
sys/kern/kern_exec.c
sys/kern/kern_intr.c
sys/kern/kern_linker.c
sys/kern/kern_memio.c
sys/kern/kern_module.c
sys/kern/kern_nrandom.c
sys/kern/subr_disk.c
sys/kern/sysv_shm.c
sys/kern/vfs_aio.c

index 33e34c6..e6dcdc8 100644 (file)
@@ -137,7 +137,7 @@ static struct filterops file_filtops =
 static struct filterops kqread_filtops =
        { FILTEROP_ISFD | FILTEROP_MPSAFE, NULL, filt_kqdetach, filt_kqueue };
 static struct filterops proc_filtops =
-       { 0, filt_procattach, filt_procdetach, filt_proc };
+       { FILTEROP_MPSAFE, filt_procattach, filt_procdetach, filt_proc };
 static struct filterops timer_filtops =
        { FILTEROP_MPSAFE, filt_timerattach, filt_timerdetach, filt_timer };
 static struct filterops user_filtops =
index 454ee94..ca81edd 100644 (file)
@@ -72,7 +72,6 @@
 
 #include <sys/refcount.h>
 #include <sys/thread2.h>
-#include <sys/mplock2.h>
 #include <vm/vm_page2.h>
 
 MALLOC_DEFINE(M_PARGS, "proc-args", "Process arguments");
index bea3466..9ec2b7f 100644 (file)
@@ -239,7 +239,7 @@ register_swi_mp(int intr, inthand2_t *handler, void *arg, const char *name,
     if (cpuid < 0)
        cpuid = intr % ncpus;
     return(register_int(intr, handler, arg, name, serializer,
-        INTR_MPSAFE, cpuid));
+                       INTR_MPSAFE, cpuid));
 }
 
 void *
@@ -333,8 +333,10 @@ register_int(int intr, inthand2_t *handler, void *arg, const char *name,
      * Set i_mplock_required if any handler in the chain requires
      * the MP lock to operate.
      */
-    if ((intr_flags & INTR_MPSAFE) == 0)
+    if ((intr_flags & INTR_MPSAFE) == 0) {
        info->i_mplock_required = 1;
+       kprintf("interrupt uses mplock: %s\n", name);
+    }
     if (intr_flags & INTR_CLOCK)
        ++info->i_fast;
     else
index e66b43e..948bbb3 100644 (file)
@@ -48,8 +48,6 @@
 
 #include <vm/vm_zone.h>
 
-#include <sys/mplock2.h>
-
 #ifdef _KERNEL_VIRTUAL
 #include <dlfcn.h>
 #endif
@@ -65,7 +63,8 @@ MALLOC_DEFINE(M_LINKER, "kld", "kernel linker");
 linker_file_t linker_current_file;
 linker_file_t linker_kernel_file;
 
-static struct lock lock;       /* lock for the file list */
+static struct lock llf_lock;   /* lock for the file list */
+static struct lock kld_lock;
 static linker_class_list_t classes;
 static linker_file_list_t linker_files;
 static int next_file_id = 1;
@@ -99,7 +98,8 @@ linker_strdup(const char *str)
 static void
 linker_init(void* arg)
 {
-    lockinit(&lock, "klink", 0, 0);
+    lockinit(&llf_lock, "klink", 0, 0);
+    lockinit(&kld_lock, "kldlk", 0, 0);
     TAILQ_INIT(&classes);
     TAILQ_INIT(&linker_files);
 }
@@ -382,14 +382,14 @@ linker_find_file_by_name(const char* filename)
     koname = kmalloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
     ksprintf(koname, "%s.ko", filename);
 
-    lockmgr(&lock, LK_SHARED);
+    lockmgr(&llf_lock, LK_SHARED);
     TAILQ_FOREACH(lf, &linker_files, link) {
        if (!strcmp(lf->filename, koname))
            break;
        if (!strcmp(lf->filename, filename))
            break;
     }
-    lockmgr(&lock, LK_RELEASE);
+    lockmgr(&llf_lock, LK_RELEASE);
 
     if (koname)
        kfree(koname, M_LINKER);
@@ -401,11 +401,11 @@ linker_find_file_by_id(int fileid)
 {
     linker_file_t lf = NULL;
 
-    lockmgr(&lock, LK_SHARED);
+    lockmgr(&llf_lock, LK_SHARED);
     TAILQ_FOREACH(lf, &linker_files, link)
        if (lf->id == fileid)
            break;
-    lockmgr(&lock, LK_RELEASE);
+    lockmgr(&llf_lock, LK_RELEASE);
 
     return lf;
 }
@@ -416,13 +416,14 @@ linker_file_foreach(linker_predicate_t *predicate, void *context)
     linker_file_t lf;
     int retval = 0;
 
-    lockmgr(&lock, LK_SHARED);
+    lockmgr(&llf_lock, LK_SHARED);
     TAILQ_FOREACH(lf, &linker_files, link) {
        retval = predicate(lf, context);
        if (retval != 0)
            break;
     }
-    lockmgr(&lock, LK_RELEASE);
+    lockmgr(&llf_lock, LK_RELEASE);
+
     return (retval);
 }
 
@@ -439,7 +440,7 @@ linker_make_file(const char* pathname, void* priv, struct linker_file_ops* ops)
        filename = pathname;
 
     KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
-    lockmgr(&lock, LK_EXCLUSIVE);
+    lockmgr(&llf_lock, LK_EXCLUSIVE);
     lf = kmalloc(sizeof(struct linker_file), M_LINKER, M_WAITOK | M_ZERO);
     lf->refs = 1;
     lf->userrefs = 0;
@@ -455,7 +456,8 @@ linker_make_file(const char* pathname, void* priv, struct linker_file_ops* ops)
     lf->ops = ops;
     TAILQ_INSERT_TAIL(&linker_files, lf, link);
 
-    lockmgr(&lock, LK_RELEASE);
+    lockmgr(&llf_lock, LK_RELEASE);
+
     return lf;
 }
 
@@ -474,12 +476,12 @@ linker_file_unload(linker_file_t file)
 
     KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
 
-    lockmgr(&lock, LK_EXCLUSIVE);
+    lockmgr(&llf_lock, LK_EXCLUSIVE);
 
     /* Easy case of just dropping a reference. */
     if (file->refs > 1) {
            file->refs--;
-           lockmgr(&lock, LK_RELEASE);
+           lockmgr(&llf_lock, LK_RELEASE);
            return (0);
     }
 
@@ -500,7 +502,7 @@ linker_file_unload(linker_file_t file)
        if ((error = module_unload(mod)) != 0) {
            KLD_DPF(FILE, ("linker_file_unload: module %p vetoes unload\n",
                           mod));
-           lockmgr(&lock, LK_RELEASE);
+           lockmgr(&llf_lock, LK_RELEASE);
            file->refs--;
            goto out;
        }
@@ -517,19 +519,19 @@ linker_file_unload(linker_file_t file)
     /* Don't try to run SYSUNINITs if we are unloaded due to a link error */
     if (file->flags & LINKER_FILE_LINKED) {
        file->flags &= ~LINKER_FILE_LINKED;
-       lockmgr(&lock, LK_RELEASE);
+       lockmgr(&llf_lock, LK_RELEASE);
        linker_file_sysuninit(file);
        linker_file_unregister_sysctls(file);
-       lockmgr(&lock, LK_EXCLUSIVE);
+       lockmgr(&llf_lock, LK_EXCLUSIVE);
     }
 
     TAILQ_REMOVE(&linker_files, file, link);
 
     if (file->deps) {
-       lockmgr(&lock, LK_RELEASE);
+       lockmgr(&llf_lock, LK_RELEASE);
        for (i = 0; i < file->ndeps; i++)
            linker_file_unload(file->deps[i]);
-       lockmgr(&lock, LK_EXCLUSIVE);
+       lockmgr(&llf_lock, LK_EXCLUSIVE);
        kfree(file->deps, M_LINKER);
        file->deps = NULL;
     }
@@ -548,7 +550,7 @@ linker_file_unload(linker_file_t file)
 
     kfree(file, M_LINKER);
 
-    lockmgr(&lock, LK_RELEASE);
+    lockmgr(&llf_lock, LK_RELEASE);
 
 out:
     return error;
@@ -794,9 +796,9 @@ sys_kldload(struct kldload_args *uap)
        modname = file;
     }
 
-    get_mplock();
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     error = linker_load_module(kldname, modname, NULL, NULL, &lf);
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
     if (error)
        goto out;
 
@@ -825,7 +827,7 @@ sys_kldunload(struct kldunload_args *uap)
     if ((error = priv_check(td, PRIV_KLD_UNLOAD)) != 0)
        return error;
 
-    get_mplock();
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     lf = linker_find_file_by_id(uap->fileid);
     if (lf) {
        KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
@@ -842,7 +844,8 @@ sys_kldunload(struct kldunload_args *uap)
        error = ENOENT;
     }
 out:
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
+
     return error;
 }
 
@@ -866,13 +869,13 @@ sys_kldfind(struct kldfind_args *uap)
     if (modulename == NULL)
        modulename = filename;
 
-    get_mplock();
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     lf = linker_find_file_by_name(modulename);
     if (lf)
        uap->sysmsg_result = lf->id;
     else
        error = ENOENT;
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
 
 out:
     if (filename)
@@ -889,7 +892,7 @@ sys_kldnext(struct kldnext_args *uap)
     linker_file_t lf;
     int error = 0;
 
-    get_mplock();
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     if (uap->fileid == 0) {
            lf = TAILQ_FIRST(&linker_files);
     } else {
@@ -912,7 +915,8 @@ sys_kldnext(struct kldnext_args *uap)
        uap->sysmsg_result = 0;
 
 out:
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
+
     return error;
 }
 
@@ -928,7 +932,7 @@ sys_kldstat(struct kldstat_args *uap)
     struct kld_file_stat* stat;
     int namelen;
 
-    get_mplock();
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     lf = linker_find_file_by_id(uap->fileid);
     if (!lf) {
        error = ENOENT;
@@ -964,7 +968,8 @@ sys_kldstat(struct kldstat_args *uap)
     uap->sysmsg_result = 0;
 
 out:
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
+
     return error;
 }
 
@@ -977,7 +982,7 @@ sys_kldfirstmod(struct kldfirstmod_args *uap)
     linker_file_t lf;
     int error = 0;
 
-    get_mplock();
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     lf = linker_find_file_by_id(uap->fileid);
     if (lf) {
        if (TAILQ_FIRST(&lf->modules))
@@ -987,7 +992,7 @@ sys_kldfirstmod(struct kldfirstmod_args *uap)
     } else {
        error = ENOENT;
     }
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
 
     return error;
 }
@@ -1005,7 +1010,7 @@ sys_kldsym(struct kldsym_args *uap)
     struct kld_sym_lookup lookup;
     int error = 0;
 
-    get_mplock();
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     if ((error = copyin(uap->data, &lookup, sizeof(lookup))) != 0)
        goto out;
     if (lookup.version != sizeof(lookup) || uap->cmd != KLDSYM_LOOKUP) {
@@ -1044,9 +1049,10 @@ sys_kldsym(struct kldsym_args *uap)
            error = ENOENT;
     }
 out:
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
     if (symstr)
        kfree(symstr, M_TEMP);
+
     return error;
 }
 
@@ -1096,18 +1102,19 @@ linker_reference_module(const char *modname, struct mod_depend *verinfo,
     modlist_t mod;
     int error;
 
-    lockmgr(&lock, LK_SHARED);
+    lockmgr(&llf_lock, LK_SHARED);
     if ((mod = modlist_lookup2(modname, verinfo)) != NULL) {
         *result = mod->container;
         (*result)->refs++;
-        lockmgr(&lock, LK_RELEASE);
+        lockmgr(&llf_lock, LK_RELEASE);
         return (0);
     }
 
-    lockmgr(&lock, LK_RELEASE);
-    get_mplock();
+    lockmgr(&llf_lock, LK_RELEASE);
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     error = linker_load_module(NULL, modname, NULL, verinfo, result);
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
+
     return (error);
 }
 
@@ -1118,23 +1125,24 @@ linker_release_module(const char *modname, struct mod_depend *verinfo,
     modlist_t mod;
     int error;
 
-    lockmgr(&lock, LK_SHARED);
+    lockmgr(&llf_lock, LK_SHARED);
     if (lf == NULL) {
         KASSERT(modname != NULL,
             ("linker_release_module: no file or name"));
         mod = modlist_lookup2(modname, verinfo);
         if (mod == NULL) {
-            lockmgr(&lock, LK_RELEASE);
+            lockmgr(&llf_lock, LK_RELEASE);
             return (ESRCH);
         }
         lf = mod->container;
     } else
         KASSERT(modname == NULL && verinfo == NULL,
             ("linker_release_module: both file and name"));
-    lockmgr(&lock, LK_RELEASE);
-    get_mplock();
+    lockmgr(&llf_lock, LK_RELEASE);
+    lockmgr(&kld_lock, LK_EXCLUSIVE);
     error = linker_file_unload(lf);
-    rel_mplock();
+    lockmgr(&kld_lock, LK_RELEASE);
+
     return (error);
 }
 
index 5ead6fd..94f34fc 100644 (file)
@@ -59,7 +59,6 @@
 #include <sys/sysctl.h>
 
 #include <sys/signal2.h>
-#include <sys/mplock2.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
@@ -95,6 +94,7 @@ static struct dev_ops mem_ops = {
 static int rand_bolt;
 static caddr_t zbuf;
 static cdev_t  zerodev = NULL;
+static struct lock mem_lock = LOCK_INITIALIZER("memlk", 0, 0);
 
 MALLOC_DEFINE(M_MEMDESC, "memdesc", "memory range descriptors");
 static int mem_ioctl (cdev_t, u_long, caddr_t, int, struct ucred *);
@@ -441,7 +441,7 @@ mmioctl(struct dev_ioctl_args *ap)
        cdev_t dev = ap->a_head.a_dev;
        int error;
 
-       get_mplock();
+       lockmgr(&mem_lock, LK_EXCLUSIVE);
 
        switch (minor(dev)) {
        case 0:
@@ -458,7 +458,8 @@ mmioctl(struct dev_ioctl_args *ap)
                break;
        }
 
-       rel_mplock();
+       lockmgr(&mem_lock, LK_RELEASE);
+
        return (error);
 }
 
index 99ccaa0..868b6b0 100644 (file)
@@ -37,8 +37,6 @@
 #include <sys/linker.h>
 #include <sys/proc.h>
 
-#include <sys/mplock2.h>
-
 MALLOC_DEFINE(M_MODULE, "module", "module data structures");
 
 typedef TAILQ_HEAD(, module) modulelist_t;
@@ -57,6 +55,7 @@ struct module {
 #define MOD_EVENT(mod, type) (mod)->handler((mod), (type), (mod)->arg)
 
 static modulelist_t modules = TAILQ_HEAD_INITIALIZER(modules);
+static struct lwkt_token mod_token = LWKT_TOKEN_INITIALIZER(mod_token);
 static int nextid = 1;
 
 static void module_shutdown(void*, int);
@@ -251,7 +250,7 @@ sys_modnext(struct modnext_args *uap)
     int error;
 
     error = 0;
-    get_mplock();
+    lwkt_gettoken(&mod_token);
     uap->sysmsg_result = -1;
     if (uap->modid == 0) {
        mod = TAILQ_FIRST(&modules);
@@ -273,7 +272,8 @@ sys_modnext(struct modnext_args *uap)
     else
        uap->sysmsg_result = 0;
 done:
-    rel_mplock();
+    lwkt_reltoken(&mod_token);
+
     return error;
 }
 
@@ -286,7 +286,7 @@ sys_modfnext(struct modfnext_args *uap)
     module_t mod;
     int error;
 
-    get_mplock();
+    lwkt_gettoken(&mod_token);
     uap->sysmsg_result = -1;
 
     mod = module_lookupbyid(uap->modid);
@@ -301,7 +301,8 @@ sys_modfnext(struct modfnext_args *uap)
        uap->sysmsg_result = 0;
     error = 0;
 done:
-    rel_mplock();
+    lwkt_reltoken(&mod_token);
+
     return error;
 }
 
@@ -324,7 +325,7 @@ sys_modstat(struct modstat_args *uap)
     int version;
     struct module_stat* stat;
 
-    get_mplock();
+    lwkt_gettoken(&mod_token);
     mod = module_lookupbyid(uap->modid);
     if (!mod) {
        error = ENOENT;
@@ -366,7 +367,8 @@ sys_modstat(struct modstat_args *uap)
     uap->sysmsg_result = 0;
 
 out:
-    rel_mplock();
+    lwkt_reltoken(&mod_token);
+
     return error;
 }
 
@@ -380,7 +382,7 @@ sys_modfind(struct modfind_args *uap)
     char name[MAXMODNAME];
     module_t mod;
 
-    get_mplock();
+    lwkt_gettoken(&mod_token);
     if ((error = copyinstr(uap->name, name, sizeof name, 0)) != 0)
        goto out;
 
@@ -391,6 +393,7 @@ sys_modfind(struct modfind_args *uap)
        uap->sysmsg_result = mod->id;
 
 out:
-    rel_mplock();
+    lwkt_reltoken(&mod_token);
+
     return error;
 }
index c54db3b..82a83d5 100644 (file)
 
 #include <sys/thread2.h>
 #include <sys/spinlock2.h>
-#include <sys/mplock2.h>
-
 
 struct csprng_state csprng_state;
 
index b8049da..97399c5 100644 (file)
 #include <sys/uuid.h>
 
 #include <sys/buf2.h>
-#include <sys/mplock2.h>
 #include <sys/msgport2.h>
 #include <sys/thread2.h>
 
@@ -132,6 +131,7 @@ static d_dump_t diskdump;
 
 static LIST_HEAD(, disk) disklist = LIST_HEAD_INITIALIZER(&disklist);
 static struct lwkt_token disklist_token;
+static struct lwkt_token ds_token;
 
 static struct dev_ops disk_ops = {
        { "disk", 0, D_DISK | D_MPSAFE | D_TRACKCLOSE },
@@ -458,7 +458,7 @@ disk_msg_core(void *arg)
        wakeup(curthread);      /* synchronous startup */
        lwkt_reltoken(&disklist_token);
 
-       get_mplock();   /* not mpsafe yet? */
+       lwkt_gettoken(&ds_token);
        run = 1;
 
        while (run) {
@@ -544,6 +544,7 @@ disk_msg_core(void *arg)
                }
                lwkt_replymsg(&msg->hdr, 0);
        }
+       lwkt_reltoken(&ds_token);
        lwkt_exit();
 }
 
@@ -1015,12 +1016,12 @@ diskopen(struct dev_open_args *ap)
        /*
         * Deal with open races
         */
-       get_mplock();
+       lwkt_gettoken(&ds_token);
        while (dp->d_flags & DISKFLAG_LOCK) {
                dp->d_flags |= DISKFLAG_WANTED;
                error = tsleep(dp, PCATCH, "diskopen", hz);
                if (error) {
-                       rel_mplock();
+                       lwkt_reltoken(&ds_token);
                        return (error);
                }
        }
@@ -1051,7 +1052,7 @@ out:
                dp->d_flags &= ~DISKFLAG_WANTED;
                wakeup(dp);
        }
-       rel_mplock();
+       lwkt_reltoken(&ds_token);
 
        KKASSERT(dp->d_opencount >= 0);
        /* If the open was successful, bump open count */
@@ -1087,12 +1088,13 @@ diskclose(struct dev_close_args *ap)
        KKASSERT(dp->d_opencount >= 1);
        lcount = atomic_fetchadd_int(&dp->d_opencount, -1);
 
-       get_mplock();
+       lwkt_gettoken(&ds_token);
        dsclose(dev, ap->a_devtype, dp->d_slice);
        if (lcount <= 1 && !dsisopen(dp->d_slice)) {
                error = dev_dclose(dp->d_rawdev, ap->a_fflag, ap->a_devtype, NULL);
        }
-       rel_mplock();
+       lwkt_reltoken(&ds_token);
+
        return (error);
 }
 
@@ -1135,10 +1137,10 @@ diskioctl(struct dev_ioctl_args *ap)
             dkslice(dev) == WHOLE_DISK_SLICE)) {
                error = ENOIOCTL;
        } else {
-               get_mplock();
+               lwkt_gettoken(&ds_token);
                error = dsioctl(dev, ap->a_cmd, ap->a_data, ap->a_fflag,
                                &dp->d_slice, &dp->d_info);
-               rel_mplock();
+               lwkt_reltoken(&ds_token);
        }
 
        if (error == ENOIOCTL) {
@@ -1286,6 +1288,7 @@ SYSCTL_INT(_kern, OID_AUTO, bioq_reorder_minor_bytes,
 void
 bioqdisksort(struct bio_queue_head *bioq, struct bio *bio)
 {
+#if 0
        /*
         * The BIO wants to be ordered.  Adding to the tail also
         * causes transition to be set to NULL, forcing the ordering
@@ -1295,6 +1298,7 @@ bioqdisksort(struct bio_queue_head *bioq, struct bio *bio)
                bioq_insert_tail(bioq, bio);
                return;
        }
+#endif
 
        switch(bio->bio_buf->b_cmd) {
        case BUF_CMD_READ:
@@ -1480,6 +1484,7 @@ disk_init(void)
                                         &disk_msg_malloc_args);
 
        lwkt_token_init(&disklist_token, "disks");
+       lwkt_token_init(&ds_token, "ds");
 
        /*
         * Initialize the reply-only port which acts as a message drain
index f13bdb9..d5dd3b2 100644 (file)
@@ -43,8 +43,6 @@
 #include <sys/sysent.h>
 #include <sys/jail.h>
 
-#include <sys/mplock2.h>
-
 #include <vm/vm.h>
 #include <vm/vm_param.h>
 #include <sys/lock.h>
@@ -67,6 +65,7 @@ static int shmget_existing (struct proc *p, struct shmget_args *uap, int mode, i
 static int shm_last_free, shm_committed, shmalloced;
 int shm_nused;
 static struct shmid_ds *shmsegs;
+static struct lwkt_token shm_token = LWKT_TOKEN_INITIALIZER(shm_token);
 
 struct shm_handle {
        /* vm_offset_t kva; */
@@ -217,7 +216,7 @@ sys_shmdt(struct shmdt_args *uap)
        if (!jail_sysvipc_allowed && td->td_ucred->cr_prison != NULL)
                return (ENOSYS);
 
-       get_mplock();
+       lwkt_gettoken(&shm_token);
        shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm;
        if (shmmap_s == NULL) {
                error = EINVAL;
@@ -233,7 +232,8 @@ sys_shmdt(struct shmdt_args *uap)
        else
                error = shm_delete_mapping(p->p_vmspace, shmmap_s);
 done:
-       rel_mplock();
+       lwkt_reltoken(&shm_token);
+
        return (error);
 }
 
@@ -259,7 +259,7 @@ sys_shmat(struct shmat_args *uap)
        if (!jail_sysvipc_allowed && td->td_ucred->cr_prison != NULL)
                return (ENOSYS);
 
-       get_mplock();
+       lwkt_gettoken(&shm_token);
 again:
        shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm;
        if (shmmap_s == NULL) {
@@ -357,7 +357,8 @@ again:
        uap->sysmsg_resultp = (void *)attach_va;
        error = 0;
 done:
-       rel_mplock();
+       lwkt_reltoken(&shm_token);
+
        return error;
 }
 
@@ -376,7 +377,7 @@ sys_shmctl(struct shmctl_args *uap)
        if (!jail_sysvipc_allowed && td->td_ucred->cr_prison != NULL)
                return (ENOSYS);
 
-       get_mplock();
+       lwkt_gettoken(&shm_token);
        shmseg = shm_find_segment_by_shmid(uap->shmid);
        if (shmseg == NULL) {
                error = EINVAL;
@@ -422,7 +423,8 @@ sys_shmctl(struct shmctl_args *uap)
                break;
        }
 done:
-       rel_mplock();
+       lwkt_reltoken(&shm_token);
+
        return error;
 }
 
@@ -581,7 +583,8 @@ sys_shmget(struct shmget_args *uap)
                return (ENOSYS);
 
        mode = uap->shmflg & ACCESSPERMS;
-       get_mplock();
+
+       lwkt_gettoken(&shm_token);
 
        if (uap->key != IPC_PRIVATE) {
        again:
@@ -599,7 +602,8 @@ sys_shmget(struct shmget_args *uap)
        }
        error = shmget_allocate_segment(p, uap, mode);
 done:
-       rel_mplock();
+       lwkt_reltoken(&shm_token);
+
        return (error);
 }
 
@@ -610,7 +614,7 @@ shmfork(struct proc *p1, struct proc *p2)
        size_t size;
        int i;
 
-       get_mplock();
+       lwkt_gettoken(&shm_token);
        size = shminfo.shmseg * sizeof(struct shmmap_state);
        shmmap_s = kmalloc(size, M_SHM, M_WAITOK);
        bcopy((caddr_t)p1->p_vmspace->vm_shm, (caddr_t)shmmap_s, size);
@@ -619,7 +623,7 @@ shmfork(struct proc *p1, struct proc *p2)
                if (shmmap_s->shmid != -1)
                        shmsegs[IPCID_TO_IX(shmmap_s->shmid)].shm_nattch++;
        }
-       rel_mplock();
+       lwkt_reltoken(&shm_token);
 }
 
 void
@@ -630,13 +634,13 @@ shmexit(struct vmspace *vm)
 
        if ((base = (struct shmmap_state *)vm->vm_shm) != NULL) {
                vm->vm_shm = NULL;
-               get_mplock();
+               lwkt_gettoken(&shm_token);
                for (i = 0, shm = base; i < shminfo.shmseg; i++, shm++) {
                        if (shm->shmid != -1)
                                shm_delete_mapping(vm, shm);
                }
                kfree(base, M_SHM);
-               rel_mplock();
+               lwkt_reltoken(&shm_token);
        }
 }
 
index e41c36a..03e44a9 100644 (file)
@@ -105,9 +105,8 @@ sys_aio_waitcomplete(struct aio_waitcomplete_args *uap)
 static int
 filt_aioattach(struct knote *kn)
 {
-
        return ENXIO;
 }
 
 struct filterops aio_filtops =
-       { 0, filt_aioattach, NULL, NULL };
+       { FILTEROP_MPSAFE, filt_aioattach, NULL, NULL };