kernel - Adjust device D_MPSAFE_* flags
authorMatthew Dillon <dillon@apollo.backplane.com>
Wed, 25 Aug 2010 18:35:53 +0000 (11:35 -0700)
committerMatthew Dillon <dillon@apollo.backplane.com>
Wed, 25 Aug 2010 18:35:53 +0000 (11:35 -0700)
* Replace all device D_MPSAFE_* flags with just D_MPSAFE
    - Mark CAM's "da" and "cd" devices D_MPSAFE
    - Mark dm (device mapper) D_MPSAFE
    - Mark memio MPSAFE
    - Mark the disk subsystem D_MPSAFE
    - Mark the crypto device D_MPSAFE

* Devices marked D_MPSAFE now call their strategy functions without the
  mp lock.

* Do a pass on devfs and mark it MNTK_ALL_MPSAFE.  devfs was essentially
  already MPSAFE but the D_MPSAFE checks have been moved out of devfs
  and into the dev_d*() API wrappers.

sys/bus/cam/scsi/scsi_cd.c
sys/bus/cam/scsi/scsi_da.c
sys/dev/disk/dm/device-mapper.c
sys/kern/kern_device.c
sys/kern/kern_memio.c
sys/kern/subr_disk.c
sys/opencrypto/cryptodev.c
sys/sys/device.h
sys/vfs/devfs/devfs_vfsops.c
sys/vfs/devfs/devfs_vnops.c

index b38adbf..d27ea38 100644 (file)
@@ -302,7 +302,7 @@ static struct periph_driver cddriver =
 PERIPHDRIVER_DECLARE(cd, cddriver);
 
 static struct dev_ops cd_ops = {
-       { "cd", SCSICD_CDEV_MAJOR, D_DISK },
+       { "cd", SCSICD_CDEV_MAJOR, D_DISK | D_MPSAFE },
        .d_open = cdopen,
        .d_close = cdclose,
        .d_read = physread,
index b0154b4..3964ab7 100644 (file)
@@ -388,7 +388,7 @@ static struct periph_driver dadriver =
 PERIPHDRIVER_DECLARE(da, dadriver);
 
 static struct dev_ops da_ops = {
-       { "da", DA_CDEV_MAJOR, D_DISK },
+       { "da", DA_CDEV_MAJOR, D_DISK | D_MPSAFE },
        .d_open =       daopen,
        .d_close =      daclose,
        .d_read =       physread,
index 6dbba69..1206fb6 100644 (file)
@@ -72,8 +72,7 @@ static void dmminphys(struct buf *);
 
 /* ***Variable-definitions*** */
 struct dev_ops dm_ops = {
-       { "dm", 0, D_DISK |
-           D_MPSAFE_READ | D_MPSAFE_WRITE | D_MPSAFE_IOCTL },
+       { "dm", 0, D_DISK | D_MPSAFE },
        .d_open         = dmopen,
        .d_close        = dmclose,
        .d_read         = physread,
index 4113070..1194d80 100644 (file)
 #include <sys/tree.h>
 #include <sys/syslink_rpc.h>
 #include <sys/proc.h>
+#include <sys/sysctl.h>
 #include <machine/stdarg.h>
-#include <sys/thread2.h>
 #include <sys/devfs.h>
 #include <sys/dsched.h>
 
+#include <sys/thread2.h>
+#include <sys/mplock2.h>
+
+static int mpsafe_writes;
+static int mplock_writes;
+static int mpsafe_reads;
+static int mplock_reads;
+static int mpsafe_strategies;
+static int mplock_strategies;
+
+SYSCTL_INT(_kern, OID_AUTO, mpsafe_writes, CTLFLAG_RD, &mpsafe_writes,
+          0, "mpsafe writes");
+SYSCTL_INT(_kern, OID_AUTO, mplock_writes, CTLFLAG_RD, &mplock_writes,
+          0, "non-mpsafe writes");
+SYSCTL_INT(_kern, OID_AUTO, mpsafe_reads, CTLFLAG_RD, &mpsafe_reads,
+          0, "mpsafe reads");
+SYSCTL_INT(_kern, OID_AUTO, mplock_reads, CTLFLAG_RD, &mplock_reads,
+          0, "non-mpsafe reads");
+SYSCTL_INT(_kern, OID_AUTO, mpsafe_strategies, CTLFLAG_RD, &mpsafe_strategies,
+          0, "mpsafe strategies");
+SYSCTL_INT(_kern, OID_AUTO, mplock_strategies, CTLFLAG_RD, &mplock_strategies,
+          0, "non-mpsafe strategies");
+
 /*
  * system link descriptors identify the command in the
  * arguments structure.
@@ -96,47 +119,82 @@ struct dev_ops default_dev_ops = {
        .d_revoke = norevoke,
        .d_clone = noclone
 };
+
+static __inline
+int
+dev_needmplock(cdev_t dev)
+{
+    return((dev->si_ops->head.flags & D_MPSAFE) == 0);
+}
     
 /************************************************************************
  *                     GENERAL DEVICE API FUNCTIONS                    *
- ************************************************************************/
-
+ ************************************************************************
+ *
+ * The MPSAFEness of these depends on dev->si_ops->head.flags
+ */
 int
 dev_dopen(cdev_t dev, int oflags, int devtype, struct ucred *cred)
 {
        struct dev_open_args ap;
+       int needmplock = dev_needmplock(dev);
+       int error;
 
        ap.a_head.a_desc = &dev_open_desc;
        ap.a_head.a_dev = dev;
        ap.a_oflags = oflags;
        ap.a_devtype = devtype;
        ap.a_cred = cred;
-       return(dev->si_ops->d_open(&ap));
+
+       if (needmplock)
+               get_mplock();
+       error = dev->si_ops->d_open(&ap);
+       if (needmplock)
+               rel_mplock();
+       return (error);
 }
 
 int
 dev_dclose(cdev_t dev, int fflag, int devtype)
 {
        struct dev_close_args ap;
+       int needmplock = dev_needmplock(dev);
+       int error;
 
        ap.a_head.a_desc = &dev_close_desc;
        ap.a_head.a_dev = dev;
        ap.a_fflag = fflag;
        ap.a_devtype = devtype;
-       return(dev->si_ops->d_close(&ap));
+
+       if (needmplock)
+               get_mplock();
+       error = dev->si_ops->d_close(&ap);
+       if (needmplock)
+               rel_mplock();
+       return (error);
 }
 
 int
 dev_dread(cdev_t dev, struct uio *uio, int ioflag)
 {
        struct dev_read_args ap;
+       int needmplock = dev_needmplock(dev);
        int error;
 
        ap.a_head.a_desc = &dev_read_desc;
        ap.a_head.a_dev = dev;
        ap.a_uio = uio;
        ap.a_ioflag = ioflag;
+
+       if (needmplock) {
+               get_mplock();
+               ++mplock_reads;
+       } else {
+               ++mpsafe_reads;
+       }
        error = dev->si_ops->d_read(&ap);
+       if (needmplock)
+               rel_mplock();
        if (error == 0)
                dev->si_lastread = time_second;
        return (error);
@@ -146,6 +204,7 @@ int
 dev_dwrite(cdev_t dev, struct uio *uio, int ioflag)
 {
        struct dev_write_args ap;
+       int needmplock = dev_needmplock(dev);
        int error;
 
        dev->si_lastwrite = time_second;
@@ -153,7 +212,16 @@ dev_dwrite(cdev_t dev, struct uio *uio, int ioflag)
        ap.a_head.a_dev = dev;
        ap.a_uio = uio;
        ap.a_ioflag = ioflag;
+
+       if (needmplock) {
+               get_mplock();
+               ++mplock_writes;
+       } else {
+               ++mpsafe_writes;
+       }
        error = dev->si_ops->d_write(&ap);
+       if (needmplock)
+               rel_mplock();
        return (error);
 }
 
@@ -162,6 +230,8 @@ dev_dioctl(cdev_t dev, u_long cmd, caddr_t data, int fflag, struct ucred *cred,
           struct sysmsg *msg)
 {
        struct dev_ioctl_args ap;
+       int needmplock = dev_needmplock(dev);
+       int error;
 
        ap.a_head.a_desc = &dev_ioctl_desc;
        ap.a_head.a_dev = dev;
@@ -170,20 +240,33 @@ dev_dioctl(cdev_t dev, u_long cmd, caddr_t data, int fflag, struct ucred *cred,
        ap.a_fflag = fflag;
        ap.a_cred = cred;
        ap.a_sysmsg = msg;
-       return(dev->si_ops->d_ioctl(&ap));
+
+       if (needmplock)
+               get_mplock();
+       error = dev->si_ops->d_ioctl(&ap);
+       if (needmplock)
+               rel_mplock();
+       return (error);
 }
 
 int
 dev_dmmap(cdev_t dev, vm_offset_t offset, int nprot)
 {
        struct dev_mmap_args ap;
+       int needmplock = dev_needmplock(dev);
        int error;
 
        ap.a_head.a_desc = &dev_mmap_desc;
        ap.a_head.a_dev = dev;
        ap.a_offset = offset;
        ap.a_nprot = nprot;
+
+       if (needmplock)
+               get_mplock();
        error = dev->si_ops->d_mmap(&ap);
+       if (needmplock)
+               rel_mplock();
+
        if (error == 0)
                return(ap.a_result);
        return(-1);
@@ -193,20 +276,37 @@ int
 dev_dclone(cdev_t dev)
 {
        struct dev_clone_args ap;
+       int needmplock = dev_needmplock(dev);
+       int error;
 
        ap.a_head.a_desc = &dev_clone_desc;
        ap.a_head.a_dev = dev;
-       return (dev->si_ops->d_clone(&ap));
+
+       if (needmplock)
+               get_mplock();
+       error = dev->si_ops->d_clone(&ap);
+       if (needmplock)
+               rel_mplock();
+       return (error);
 }
 
 int
 dev_drevoke(cdev_t dev)
 {
        struct dev_revoke_args ap;
+       int needmplock = dev_needmplock(dev);
+       int error;
 
        ap.a_head.a_desc = &dev_revoke_desc;
        ap.a_head.a_dev = dev;
-       return (dev->si_ops->d_revoke(&ap));
+
+       if (needmplock)
+               get_mplock();
+       error = dev->si_ops->d_revoke(&ap);
+       if (needmplock)
+               rel_mplock();
+
+       return (error);
 }
 
 /*
@@ -221,6 +321,7 @@ dev_dstrategy(cdev_t dev, struct bio *bio)
 {
        struct dev_strategy_args ap;
        struct bio_track *track;
+       int needmplock = dev_needmplock(dev);
 
        ap.a_head.a_desc = &dev_strategy_desc;
        ap.a_head.a_dev = dev;
@@ -239,13 +340,22 @@ dev_dstrategy(cdev_t dev, struct bio *bio)
                dsched_new_buf(bio->bio_buf);
 
        KKASSERT((bio->bio_flags & BIO_DONE) == 0);
+       if (needmplock) {
+               get_mplock();
+               ++mplock_strategies;
+       } else {
+               ++mpsafe_strategies;
+       }
        (void)dev->si_ops->d_strategy(&ap);
+       if (needmplock)
+               rel_mplock();
 }
 
 void
 dev_dstrategy_chain(cdev_t dev, struct bio *bio)
 {
        struct dev_strategy_args ap;
+       int needmplock = dev_needmplock(dev);
 
        ap.a_head.a_desc = &dev_strategy_desc;
        ap.a_head.a_dev = dev;
@@ -253,7 +363,11 @@ dev_dstrategy_chain(cdev_t dev, struct bio *bio)
 
        KKASSERT(bio->bio_track != NULL);
        KKASSERT((bio->bio_flags & BIO_DONE) == 0);
+       if (needmplock)
+               get_mplock();
        (void)dev->si_ops->d_strategy(&ap);
+       if (needmplock)
+               rel_mplock();
 }
 
 /*
@@ -265,6 +379,8 @@ dev_ddump(cdev_t dev, void *virtual, vm_offset_t physical, off_t offset,
     size_t length)
 {
        struct dev_dump_args ap;
+       int needmplock = dev_needmplock(dev);
+       int error;
 
        ap.a_head.a_desc = &dev_dump_desc;
        ap.a_head.a_dev = dev;
@@ -275,18 +391,31 @@ dev_ddump(cdev_t dev, void *virtual, vm_offset_t physical, off_t offset,
        ap.a_physical = physical;
        ap.a_offset = offset;
        ap.a_length = length;
-       return(dev->si_ops->d_dump(&ap));
+
+       if (needmplock)
+               get_mplock();
+       error = dev->si_ops->d_dump(&ap);
+       if (needmplock)
+               get_mplock();
+       return (error);
 }
 
 int64_t
 dev_dpsize(cdev_t dev)
 {
        struct dev_psize_args ap;
+       int needmplock = dev_needmplock(dev);
        int error;
 
        ap.a_head.a_desc = &dev_psize_desc;
        ap.a_head.a_dev = dev;
+
+       if (needmplock)
+               get_mplock();
        error = dev->si_ops->d_psize(&ap);
+       if (needmplock)
+               rel_mplock();
+
        if (error == 0)
                return (ap.a_result);
        return(-1);
@@ -302,13 +431,20 @@ int
 dev_dkqfilter(cdev_t dev, struct knote *kn)
 {
        struct dev_kqfilter_args ap;
+       int needmplock = dev_needmplock(dev);
        int error;
 
        ap.a_head.a_desc = &dev_kqfilter_desc;
        ap.a_head.a_dev = dev;
        ap.a_kn = kn;
        ap.a_result = 0;
+
+       if (needmplock)
+               get_mplock();
        error = dev->si_ops->d_kqfilter(&ap);
+       if (needmplock)
+               rel_mplock();
+
        if (error == 0)
                return(ap.a_result);
        return(ENODEV);
@@ -362,9 +498,18 @@ int
 dev_doperate(struct dev_generic_args *ap)
 {
     int (*func)(struct dev_generic_args *);
+    int needmplock = dev_needmplock(ap->a_dev);
+    int error;
 
     func = *(void **)((char *)ap->a_dev->si_ops + ap->a_desc->sd_offset);
-    return (func(ap));
+
+    if (needmplock)
+           get_mplock();
+    error = func(ap);
+    if (needmplock)
+           rel_mplock();
+
+    return (error);
 }
 
 /*
@@ -376,9 +521,18 @@ int
 dev_doperate_ops(struct dev_ops *ops, struct dev_generic_args *ap)
 {
     int (*func)(struct dev_generic_args *);
+    int needmplock = ((ops->head.flags & D_MPSAFE) == 0);
+    int error;
 
     func = *(void **)((char *)ops + ap->a_desc->sd_offset);
-    return (func(ap));
+
+    if (needmplock)
+           get_mplock();
+    error = func(ap);
+    if (needmplock)
+           rel_mplock();
+
+    return (error);
 }
 
 /*
index bb32304..989b343 100644 (file)
 #include <sys/priv.h>
 #include <sys/random.h>
 #include <sys/signalvar.h>
-#include <sys/signal2.h>
 #include <sys/uio.h>
 #include <sys/vnode.h>
 
+#include <sys/signal2.h>
+#include <sys/mplock2.h>
+
 #include <vm/vm.h>
 #include <vm/pmap.h>
 #include <vm/vm_extern.h>
@@ -78,7 +80,7 @@ static        d_kqfilter_t    mmkqfilter;
 
 #define CDEV_MAJOR 2
 static struct dev_ops mem_ops = {
-       { "mem", CDEV_MAJOR, D_MEM | D_MPSAFE_READ | D_MPSAFE_WRITE | D_KQFILTER },
+       { "mem", CDEV_MAJOR, D_MPSAFE },
        .d_open =       mmopen,
        .d_close =      mmclose,
        .d_read =       mmread,
@@ -365,17 +367,27 @@ static int
 mmioctl(struct dev_ioctl_args *ap)
 {
        cdev_t dev = ap->a_head.a_dev;
+       int error;
+
+       get_mplock();
 
        switch (minor(dev)) {
        case 0:
-               return mem_ioctl(dev, ap->a_cmd, ap->a_data,
-                                ap->a_fflag, ap->a_cred);
+               error = mem_ioctl(dev, ap->a_cmd, ap->a_data,
+                                 ap->a_fflag, ap->a_cred);
+               break;
        case 3:
        case 4:
-               return random_ioctl(dev, ap->a_cmd, ap->a_data,
-                                   ap->a_fflag, ap->a_cred);
+               error = random_ioctl(dev, ap->a_cmd, ap->a_data,
+                                    ap->a_fflag, ap->a_cred);
+               break;
+       default:
+               error = ENODEV;
+               break;
        }
-       return (ENODEV);
+
+       rel_mplock();
+       return (error);
 }
 
 /*
index 4840046..81f3a67 100644 (file)
 #include <sys/syslog.h>
 #include <sys/device.h>
 #include <sys/msgport.h>
-#include <sys/msgport2.h>
-#include <sys/buf2.h>
 #include <sys/devfs.h>
 #include <sys/thread.h>
-#include <sys/thread2.h>
 #include <sys/dsched.h>
 #include <sys/queue.h>
 #include <sys/lock.h>
 #include <sys/udev.h>
 
+#include <sys/buf2.h>
+#include <sys/mplock2.h>
+#include <sys/msgport2.h>
+#include <sys/thread2.h>
+
 static MALLOC_DEFINE(M_DISK, "disk", "disk data");
 static int disk_debug_enable = 0;
 
@@ -134,7 +136,7 @@ static LIST_HEAD(, disk) disklist = LIST_HEAD_INITIALIZER(&disklist);
 static struct lwkt_token disklist_token;
 
 static struct dev_ops disk_ops = {
-       { "disk", 0, D_DISK },
+       { "disk", 0, D_DISK | D_MPSAFE },
        .d_open = diskopen,
        .d_close = diskclose,
        .d_read = physread,
@@ -801,11 +803,14 @@ diskopen(struct dev_open_args *ap)
        /*
         * Deal with open races
         */
+       get_mplock();
        while (dp->d_flags & DISKFLAG_LOCK) {
                dp->d_flags |= DISKFLAG_WANTED;
                error = tsleep(dp, PCATCH, "diskopen", hz);
-               if (error)
+               if (error) {
+                       rel_mplock();
                        return (error);
+               }
        }
        dp->d_flags |= DISKFLAG_LOCK;
 
@@ -841,6 +846,7 @@ out:
                dp->d_flags &= ~DISKFLAG_WANTED;
                wakeup(dp);
        }
+       rel_mplock();
 
        return(error);
 }
@@ -859,10 +865,12 @@ diskclose(struct dev_close_args *ap)
        error = 0;
        dp = dev->si_disk;
 
+       get_mplock();
        dsclose(dev, ap->a_devtype, dp->d_slice);
        if (!dsisopen(dp->d_slice)) {
                error = dev_dclose(dp->d_rawdev, ap->a_fflag, ap->a_devtype);
        }
+       rel_mplock();
        return (error);
 }
 
@@ -898,8 +906,10 @@ diskioctl(struct dev_ioctl_args *ap)
        if (&dp->d_slice == NULL || dp->d_slice == NULL) {
                error = ENOIOCTL;
        } else {
+               get_mplock();
                error = dsioctl(dev, ap->a_cmd, ap->a_data, ap->a_fflag,
                                &dp->d_slice, &dp->d_info);
+               rel_mplock();
        }
 
        if (error == ENOIOCTL) {
index e44658b..33d2c3e 100644 (file)
@@ -852,7 +852,7 @@ cryptoioctl(struct dev_ioctl_args *ap)
 }
 
 static struct dev_ops crypto_ops = {
-       { "crypto", 0, D_MPSAFE_READ | D_MPSAFE_WRITE | D_MPSAFE_IOCTL },
+       { "crypto", 0, D_MPSAFE },
        .d_open =       cryptoopen,
        .d_read =       cryptoread,
        .d_write =      cryptowrite,
index 52d2d10..cba4774 100644 (file)
@@ -250,9 +250,7 @@ struct dev_ops {
 #define D_TRACKCLOSE   0x00080000      /* track all closes */
 #define D_MASTER       0x00100000      /* used by pty/tty code */
 #define D_KQFILTER     0x00200000      /* has kqfilter entry */
-#define D_MPSAFE_READ  0x00400000      /* doesn't require mplock for reads */
-#define D_MPSAFE_WRITE 0x00800000      /* doesn't require mplock for writes */
-#define D_MPSAFE_IOCTL 0x01000000      /* doesn't require mplock for ioctls */
+#define D_MPSAFE       0x00400000      /* all dev_d*() calls are MPSAFE */
 
 /*
  * A union of all possible argument structures.
index e365280..316b6cc 100644 (file)
@@ -1,4 +1,6 @@
 /*
+ * (MPSAFE)
+ *
  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
  *
  * This code is derived from software contributed to The DragonFly Project
@@ -46,17 +48,17 @@ extern struct vop_ops devfs_vnode_norm_vops;
 extern struct vop_ops devfs_vnode_dev_vops;
 extern struct lock     devfs_lock;
 
-static int     devfs_mount (struct mount *mp, char *path, caddr_t data,
+static int     devfs_vfs_mount (struct mount *mp, char *path, caddr_t data,
                                  struct ucred *cred);
-static int     devfs_statfs (struct mount *mp, struct statfs *sbp,
+static int     devfs_vfs_statfs (struct mount *mp, struct statfs *sbp,
                                struct ucred *cred);
-static int     devfs_unmount (struct mount *mp, int mntflags);
-int                    devfs_root(struct mount *mp, struct vnode **vpp);
-static int     devfs_vget(struct mount *mp, struct vnode *dvp,
+static int     devfs_vfs_unmount (struct mount *mp, int mntflags);
+int            devfs_vfs_root(struct mount *mp, struct vnode **vpp);
+static int     devfs_vfs_vget(struct mount *mp, struct vnode *dvp,
                                ino_t ino, struct vnode **vpp);
-static int     devfs_fhtovp(struct mount *mp, struct vnode *rootvp,
+static int     devfs_vfs_fhtovp(struct mount *mp, struct vnode *rootvp,
                                struct fid *fhp, struct vnode **vpp);
-static int     devfs_vptofh(struct vnode *vp, struct fid *fhp);
+static int     devfs_vfs_vptofh(struct vnode *vp, struct fid *fhp);
 
 
 /*
@@ -64,9 +66,8 @@ static int    devfs_vptofh(struct vnode *vp, struct fid *fhp);
  *
  * mount system call
  */
-/* ARGSUSED */
 static int
-devfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
+devfs_vfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
 {
        struct devfs_mount_info info;
        struct devfs_mnt_data *mnt;
@@ -86,14 +87,14 @@ devfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
        }
 
        mp->mnt_flag |= MNT_LOCAL;
-       mp->mnt_kern_flag |= MNTK_NOSTKMNT;
+       mp->mnt_kern_flag |= MNTK_NOSTKMNT | MNTK_ALL_MPSAFE;
        mp->mnt_data = NULL;
        vfs_getnewfsid(mp);
 
        size = sizeof("devfs") - 1;
        bcopy("devfs", mp->mnt_stat.f_mntfromname, size);
        bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
-       devfs_statfs(mp, &mp->mnt_stat, cred);
+       devfs_vfs_statfs(mp, &mp->mnt_stat, cred);
 
        /*
         * XXX: save other mount info passed from userland or so.
@@ -129,7 +130,7 @@ devfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
  * unmount system call
  */
 static int
-devfs_unmount(struct mount *mp, int mntflags)
+devfs_vfs_unmount(struct mount *mp, int mntflags)
 {
        int error = 0;
        int flags = 0;
@@ -143,7 +144,9 @@ devfs_unmount(struct mount *mp, int mntflags)
 
        if (error)
                return (error);
+       lockmgr(&devfs_lock, LK_EXCLUSIVE);
        devfs_tracer_orphan_count(mp, 1);
+       lockmgr(&devfs_lock, LK_RELEASE);
        devfs_mount_del(DEVFS_MNTDATA(mp));
        kfree(mp->mnt_data, M_DEVFS);
        mp->mnt_data = NULL;
@@ -155,13 +158,15 @@ devfs_unmount(struct mount *mp, int mntflags)
  * Sets *vpp to the root procfs vnode, referenced and exclusively locked
  */
 int
-devfs_root(struct mount *mp, struct vnode **vpp)
+devfs_vfs_root(struct mount *mp, struct vnode **vpp)
 {
        int ret;
+
        devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_root() called!\n");
        lockmgr(&devfs_lock, LK_EXCLUSIVE);
        ret = devfs_allocv(vpp, DEVFS_MNTDATA(mp)->root_node);
        lockmgr(&devfs_lock, LK_RELEASE);
+
        return ret;
 }
 
@@ -169,7 +174,7 @@ devfs_root(struct mount *mp, struct vnode **vpp)
  * Get file system statistics.
  */
 static int
-devfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
+devfs_vfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 {
        devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_stat() called!\n");
        sbp->f_bsize = DEV_BSIZE;
@@ -190,8 +195,8 @@ devfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 }
 
 static int
-devfs_fhtovp(struct mount *mp, struct vnode *rootvp,
-          struct fid *fhp, struct vnode **vpp)
+devfs_vfs_fhtovp(struct mount *mp, struct vnode *rootvp,
+                struct fid *fhp, struct vnode **vpp)
 {
        struct vnode            *vp;
        struct devfs_fid        *dfhp;
@@ -213,9 +218,8 @@ devfs_fhtovp(struct mount *mp, struct vnode *rootvp,
 /*
  * Vnode pointer to File handle
  */
-/* ARGSUSED */
 static int
-devfs_vptofh(struct vnode *vp, struct fid *fhp)
+devfs_vfs_vptofh(struct vnode *vp, struct fid *fhp)
 {
        struct devfs_node       *node;
        struct devfs_fid        *dfhp;
@@ -233,7 +237,8 @@ devfs_vptofh(struct vnode *vp, struct fid *fhp)
 }
 
 static int
-devfs_vget(struct mount *mp, struct vnode *dvp, ino_t ino, struct vnode **vpp)
+devfs_vfs_vget(struct mount *mp, struct vnode *dvp,
+              ino_t ino, struct vnode **vpp)
 {
        struct vnode *vp;
        vp = devfs_inode_to_vnode(mp, ino);
@@ -247,14 +252,14 @@ devfs_vget(struct mount *mp, struct vnode *dvp, ino_t ino, struct vnode **vpp)
 
 
 static struct vfsops devfs_vfsops = {
-       .vfs_mount      =   devfs_mount,
-       .vfs_unmount =  devfs_unmount,
-       .vfs_root       =   devfs_root,
-       .vfs_statfs =   devfs_statfs,
-       .vfs_sync       =   vfs_stdsync,
-       .vfs_vget       =       devfs_vget,
-       .vfs_vptofh     =       devfs_vptofh,
-       .vfs_fhtovp     =       devfs_fhtovp
+       .vfs_mount      = devfs_vfs_mount,
+       .vfs_unmount    = devfs_vfs_unmount,
+       .vfs_root       = devfs_vfs_root,
+       .vfs_statfs     = devfs_vfs_statfs,
+       .vfs_sync       = vfs_stdsync,
+       .vfs_vget       = devfs_vfs_vget,
+       .vfs_vptofh     = devfs_vfs_vptofh,
+       .vfs_fhtovp     = devfs_vfs_fhtovp
 };
 
 VFS_SET(devfs_vfsops, devfs, VFCF_SYNTHETIC);
index 9fb5ced..bce2879 100644 (file)
@@ -1,4 +1,6 @@
 /*
+ * (MPSAFE)
+ *
  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
  *
  * This code is derived from software contributed to The DragonFly Project
 #include <vm/vm_page2.h>
 
 MALLOC_DECLARE(M_DEVFS);
-#define DEVFS_BADOP    (void *)devfs_badop
-
-static int devfs_badop(struct vop_generic_args *);
-static int devfs_access(struct vop_access_args *);
-static int devfs_inactive(struct vop_inactive_args *);
-static int devfs_reclaim(struct vop_reclaim_args *);
-static int devfs_readdir(struct vop_readdir_args *);
-static int devfs_getattr(struct vop_getattr_args *);
-static int devfs_setattr(struct vop_setattr_args *);
-static int devfs_readlink(struct vop_readlink_args *);
-static int devfs_print(struct vop_print_args *);
-
-static int devfs_nresolve(struct vop_nresolve_args *);
-static int devfs_nlookupdotdot(struct vop_nlookupdotdot_args *);
-static int devfs_nmkdir(struct vop_nmkdir_args *);
-static int devfs_nsymlink(struct vop_nsymlink_args *);
-static int devfs_nrmdir(struct vop_nrmdir_args *);
-static int devfs_nremove(struct vop_nremove_args *);
+#define DEVFS_BADOP    (void *)devfs_vop_badop
+
+static int devfs_vop_badop(struct vop_generic_args *);
+static int devfs_vop_access(struct vop_access_args *);
+static int devfs_vop_inactive(struct vop_inactive_args *);
+static int devfs_vop_reclaim(struct vop_reclaim_args *);
+static int devfs_vop_readdir(struct vop_readdir_args *);
+static int devfs_vop_getattr(struct vop_getattr_args *);
+static int devfs_vop_setattr(struct vop_setattr_args *);
+static int devfs_vop_readlink(struct vop_readlink_args *);
+static int devfs_vop_print(struct vop_print_args *);
+
+static int devfs_vop_nresolve(struct vop_nresolve_args *);
+static int devfs_vop_nlookupdotdot(struct vop_nlookupdotdot_args *);
+static int devfs_vop_nmkdir(struct vop_nmkdir_args *);
+static int devfs_vop_nsymlink(struct vop_nsymlink_args *);
+static int devfs_vop_nrmdir(struct vop_nrmdir_args *);
+static int devfs_vop_nremove(struct vop_nremove_args *);
 
 static int devfs_spec_open(struct vop_open_args *);
 static int devfs_spec_close(struct vop_close_args *);
@@ -105,100 +107,102 @@ static int devfs_spec_advlock(struct vop_advlock_args *);
 static void devfs_spec_getpages_iodone(struct bio *);
 static int devfs_spec_getpages(struct vop_getpages_args *);
 
-
-static int devfs_specf_close(struct file *);
-static int devfs_specf_read(struct file *, struct uio *, struct ucred *, int);
-static int devfs_specf_write(struct file *, struct uio *, struct ucred *, int);
-static int devfs_specf_stat(struct file *, struct stat *, struct ucred *);
-static int devfs_specf_kqfilter(struct file *, struct knote *);
-static int devfs_specf_ioctl(struct file *, u_long, caddr_t,
+static int devfs_fo_close(struct file *);
+static int devfs_fo_read(struct file *, struct uio *, struct ucred *, int);
+static int devfs_fo_write(struct file *, struct uio *, struct ucred *, int);
+static int devfs_fo_stat(struct file *, struct stat *, struct ucred *);
+static int devfs_fo_kqfilter(struct file *, struct knote *);
+static int devfs_fo_ioctl(struct file *, u_long, caddr_t,
                                struct ucred *, struct sysmsg *);
 static __inline int sequential_heuristic(struct uio *, struct file *);
 
 extern struct lock devfs_lock;
 
-static int mpsafe_reads, mpsafe_writes, mplock_reads, mplock_writes;
-
 /*
- * devfs vnode operations for regular files
+ * devfs vnode operations for regular files.  All vnode ops are MPSAFE.
  */
 struct vop_ops devfs_vnode_norm_vops = {
        .vop_default =          vop_defaultop,
-       .vop_access =           devfs_access,
+       .vop_access =           devfs_vop_access,
        .vop_advlock =          DEVFS_BADOP,
-       .vop_bmap =                     DEVFS_BADOP,
+       .vop_bmap =             DEVFS_BADOP,
        .vop_close =            vop_stdclose,
-       .vop_getattr =          devfs_getattr,
-       .vop_inactive =         devfs_inactive,
+       .vop_getattr =          devfs_vop_getattr,
+       .vop_inactive =         devfs_vop_inactive,
        .vop_ncreate =          DEVFS_BADOP,
-       .vop_nresolve =         devfs_nresolve,
-       .vop_nlookupdotdot =    devfs_nlookupdotdot,
+       .vop_nresolve =         devfs_vop_nresolve,
+       .vop_nlookupdotdot =    devfs_vop_nlookupdotdot,
        .vop_nlink =            DEVFS_BADOP,
-       .vop_nmkdir =           devfs_nmkdir,
+       .vop_nmkdir =           devfs_vop_nmkdir,
        .vop_nmknod =           DEVFS_BADOP,
-       .vop_nremove =          devfs_nremove,
+       .vop_nremove =          devfs_vop_nremove,
        .vop_nrename =          DEVFS_BADOP,
-       .vop_nrmdir =           devfs_nrmdir,
-       .vop_nsymlink =         devfs_nsymlink,
-       .vop_open =                     vop_stdopen,
+       .vop_nrmdir =           devfs_vop_nrmdir,
+       .vop_nsymlink =         devfs_vop_nsymlink,
+       .vop_open =             vop_stdopen,
        .vop_pathconf =         vop_stdpathconf,
-       .vop_print =            devfs_print,
-       .vop_read =                     DEVFS_BADOP,
-       .vop_readdir =          devfs_readdir,
-       .vop_readlink =         devfs_readlink,
-       .vop_reclaim =          devfs_reclaim,
-       .vop_setattr =          devfs_setattr,
+       .vop_print =            devfs_vop_print,
+       .vop_read =             DEVFS_BADOP,
+       .vop_readdir =          devfs_vop_readdir,
+       .vop_readlink =         devfs_vop_readlink,
+       .vop_reclaim =          devfs_vop_reclaim,
+       .vop_setattr =          devfs_vop_setattr,
        .vop_write =            DEVFS_BADOP,
        .vop_ioctl =            DEVFS_BADOP
 };
 
 /*
- * devfs vnode operations for character devices
+ * devfs vnode operations for character devices.  All vnode ops are MPSAFE.
  */
 struct vop_ops devfs_vnode_dev_vops = {
        .vop_default =          vop_defaultop,
-       .vop_access =           devfs_access,
+       .vop_access =           devfs_vop_access,
        .vop_advlock =          devfs_spec_advlock,
-       .vop_bmap =                     devfs_spec_bmap,
+       .vop_bmap =             devfs_spec_bmap,
        .vop_close =            devfs_spec_close,
        .vop_freeblks =         devfs_spec_freeblks,
        .vop_fsync =            devfs_spec_fsync,
-       .vop_getattr =          devfs_getattr,
+       .vop_getattr =          devfs_vop_getattr,
        .vop_getpages =         devfs_spec_getpages,
-       .vop_inactive =         devfs_inactive,
-       .vop_open =                     devfs_spec_open,
+       .vop_inactive =         devfs_vop_inactive,
+       .vop_open =             devfs_spec_open,
        .vop_pathconf =         vop_stdpathconf,
-       .vop_print =            devfs_print,
+       .vop_print =            devfs_vop_print,
        .vop_kqfilter =         devfs_spec_kqfilter,
-       .vop_read =                     devfs_spec_read,
+       .vop_read =             devfs_spec_read,
        .vop_readdir =          DEVFS_BADOP,
        .vop_readlink =         DEVFS_BADOP,
-       .vop_reclaim =          devfs_reclaim,
-       .vop_setattr =          devfs_setattr,
+       .vop_reclaim =          devfs_vop_reclaim,
+       .vop_setattr =          devfs_vop_setattr,
        .vop_strategy =         devfs_spec_strategy,
        .vop_write =            devfs_spec_write,
        .vop_ioctl =            devfs_spec_ioctl
 };
 
+/*
+ * devfs file pointer operations.  All fileops are MPSAFE.
+ */
 struct vop_ops *devfs_vnode_dev_vops_p = &devfs_vnode_dev_vops;
 
 struct fileops devfs_dev_fileops = {
-       .fo_read = devfs_specf_read,
-       .fo_write = devfs_specf_write,
-       .fo_ioctl = devfs_specf_ioctl,
-       .fo_kqfilter = devfs_specf_kqfilter,
-       .fo_stat = devfs_specf_stat,
-       .fo_close = devfs_specf_close,
-       .fo_shutdown = nofo_shutdown
+       .fo_read        = devfs_fo_read,
+       .fo_write       = devfs_fo_write,
+       .fo_ioctl       = devfs_fo_ioctl,
+       .fo_kqfilter    = devfs_fo_kqfilter,
+       .fo_stat        = devfs_fo_stat,
+       .fo_close       = devfs_fo_close,
+       .fo_shutdown    = nofo_shutdown
 };
 
 /*
- * These two functions are possibly temporary hacks for
- * devices (aka the pty code) which want to control the
- * node attributes themselves.
+ * These two functions are possibly temporary hacks for devices (aka
+ * the pty code) which want to control the node attributes themselves.
  *
  * XXX we may ultimately desire to simply remove the uid/gid/mode
  * from the node entirely.
+ *
+ * MPSAFE - sorta.  Theoretically the overwrite can compete since they
+ *         are loading from the same fields.
  */
 static __inline void
 node_sync_dev_get(struct devfs_node *node)
@@ -228,14 +232,14 @@ node_sync_dev_set(struct devfs_node *node)
  * generic entry point for unsupported operations
  */
 static int
-devfs_badop(struct vop_generic_args *ap)
+devfs_vop_badop(struct vop_generic_args *ap)
 {
        return (EIO);
 }
 
 
 static int
-devfs_access(struct vop_access_args *ap)
+devfs_vop_access(struct vop_access_args *ap)
 {
        struct devfs_node *node = DEVFS_NODE(ap->a_vp);
        int error;
@@ -251,7 +255,7 @@ devfs_access(struct vop_access_args *ap)
 
 
 static int
-devfs_inactive(struct vop_inactive_args *ap)
+devfs_vop_inactive(struct vop_inactive_args *ap)
 {
        struct devfs_node *node = DEVFS_NODE(ap->a_vp);
 
@@ -262,7 +266,7 @@ devfs_inactive(struct vop_inactive_args *ap)
 
 
 static int
-devfs_reclaim(struct vop_reclaim_args *ap)
+devfs_vop_reclaim(struct vop_reclaim_args *ap)
 {
        struct devfs_node *node;
        struct vnode *vp;
@@ -303,7 +307,7 @@ devfs_reclaim(struct vop_reclaim_args *ap)
 
 
 static int
-devfs_readdir(struct vop_readdir_args *ap)
+devfs_vop_readdir(struct vop_readdir_args *ap)
 {
        struct devfs_node *dnode = DEVFS_NODE(ap->a_vp);
        struct devfs_node *node;
@@ -385,9 +389,9 @@ devfs_readdir(struct vop_readdir_args *ap)
                }
 
                /*
-                * If the node type is a valid devfs alias, then we make sure that the
-                * target isn't hidden. If it is, we don't show the link in the
-                * directory listing.
+                * If the node type is a valid devfs alias, then we make
+                * sure that the target isn't hidden. If it is, we don't
+                * show the link in the directory listing.
                 */
                if ((node->node_type == Plink) && (node->link_target != NULL) &&
                        (node->link_target->flags & DEVFS_HIDDEN))
@@ -437,7 +441,7 @@ done:
 
 
 static int
-devfs_nresolve(struct vop_nresolve_args *ap)
+devfs_vop_nresolve(struct vop_nresolve_args *ap)
 {
        struct devfs_node *dnode = DEVFS_NODE(ap->a_dvp);
        struct devfs_node *node, *found = NULL;
@@ -504,7 +508,7 @@ out:
 
 
 static int
-devfs_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
+devfs_vop_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
 {
        struct devfs_node *dnode = DEVFS_NODE(ap->a_dvp);
 
@@ -524,7 +528,7 @@ devfs_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
 
 
 static int
-devfs_getattr(struct vop_getattr_args *ap)
+devfs_vop_getattr(struct vop_getattr_args *ap)
 {
        struct devfs_node *node = DEVFS_NODE(ap->a_vp);
        struct vattr *vap = ap->a_vap;
@@ -598,7 +602,7 @@ devfs_getattr(struct vop_getattr_args *ap)
 
 
 static int
-devfs_setattr(struct vop_setattr_args *ap)
+devfs_vop_setattr(struct vop_setattr_args *ap)
 {
        struct devfs_node *node = DEVFS_NODE(ap->a_vp);
        struct vattr *vap;
@@ -651,7 +655,7 @@ out:
 
 
 static int
-devfs_readlink(struct vop_readlink_args *ap)
+devfs_vop_readlink(struct vop_readlink_args *ap)
 {
        struct devfs_node *node = DEVFS_NODE(ap->a_vp);
        int ret;
@@ -668,13 +672,13 @@ devfs_readlink(struct vop_readlink_args *ap)
 
 
 static int
-devfs_print(struct vop_print_args *ap)
+devfs_vop_print(struct vop_print_args *ap)
 {
        return (0);
 }
 
 static int
-devfs_nmkdir(struct vop_nmkdir_args *ap)
+devfs_vop_nmkdir(struct vop_nmkdir_args *ap)
 {
        struct devfs_node *dnode = DEVFS_NODE(ap->a_dvp);
        struct devfs_node *node;
@@ -701,7 +705,7 @@ out:
 }
 
 static int
-devfs_nsymlink(struct vop_nsymlink_args *ap)
+devfs_vop_nsymlink(struct vop_nsymlink_args *ap)
 {
        struct devfs_node *dnode = DEVFS_NODE(ap->a_dvp);
        struct devfs_node *node;
@@ -736,7 +740,7 @@ out:
 }
 
 static int
-devfs_nrmdir(struct vop_nrmdir_args *ap)
+devfs_vop_nrmdir(struct vop_nrmdir_args *ap)
 {
        struct devfs_node *dnode = DEVFS_NODE(ap->a_dvp);
        struct devfs_node *node;
@@ -789,7 +793,7 @@ out:
 }
 
 static int
-devfs_nremove(struct vop_nremove_args *ap)
+devfs_vop_nremove(struct vop_nremove_args *ap)
 {
        struct devfs_node *dnode = DEVFS_NODE(ap->a_dvp);
        struct devfs_node *node;
@@ -909,6 +913,9 @@ devfs_spec_open(struct vop_open_args *ap)
        if (dev_dflags(dev) & D_TTY)
                vsetflags(vp, VISTTY);
 
+       /*
+        * Open underlying device
+        */
        vn_unlock(vp);
        error = dev_dopen(dev, ap->a_mode, S_IFCHR, ap->a_cred);
        vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
@@ -1083,15 +1090,13 @@ devfs_spec_close(struct vop_close_args *ap)
 
 
 static int
-devfs_specf_close(struct file *fp)
+devfs_fo_close(struct file *fp)
 {
        struct vnode *vp = (struct vnode *)fp->f_data;
        int error;
 
-       get_mplock();
        fp->f_ops = &badfileops;
        error = vn_close(vp, fp->f_flag);
-       rel_mplock();
 
        return (error);
 }
@@ -1106,7 +1111,7 @@ devfs_specf_close(struct file *fp)
  * MPALMOSTSAFE - acquires mplock
  */
 static int
-devfs_specf_read(struct file *fp, struct uio *uio,
+devfs_fo_read(struct file *fp, struct uio *uio,
                 struct ucred *cred, int flags)
 {
        struct devfs_node *node;
@@ -1130,14 +1135,6 @@ devfs_specf_read(struct file *fp, struct uio *uio,
        if ((dev = vp->v_rdev) == NULL)
                return EBADF;
 
-       /* only acquire mplock for devices that require it */
-       if (!(dev_dflags(dev) & D_MPSAFE_READ)) {
-               atomic_add_int(&mplock_reads, 1);
-               get_mplock();
-       } else {
-               atomic_add_int(&mpsafe_reads, 1);
-       }
-
        reference_dev(dev);
 
        if ((flags & O_FOFFSET) == 0)
@@ -1169,15 +1166,12 @@ devfs_specf_read(struct file *fp, struct uio *uio,
                fp->f_offset = uio->uio_offset;
        fp->f_nextoff = uio->uio_offset;
 
-       if (!(dev_dflags(dev) & D_MPSAFE_READ))
-               rel_mplock();
-
        return (error);
 }
 
 
 static int
-devfs_specf_write(struct file *fp, struct uio *uio,
+devfs_fo_write(struct file *fp, struct uio *uio,
                  struct ucred *cred, int flags)
 {
        struct devfs_node *node;
@@ -1203,14 +1197,6 @@ devfs_specf_write(struct file *fp, struct uio *uio,
        if ((dev = vp->v_rdev) == NULL)
                return EBADF;
 
-       /* only acquire mplock for devices that require it */
-       if (!(dev_dflags(dev) & D_MPSAFE_WRITE)) {
-               atomic_add_int(&mplock_writes, 1);
-               get_mplock();
-       } else {
-               atomic_add_int(&mpsafe_writes, 1);
-       }
-
        reference_dev(dev);
 
        if ((flags & O_FOFFSET) == 0)
@@ -1260,14 +1246,12 @@ devfs_specf_write(struct file *fp, struct uio *uio,
                fp->f_offset = uio->uio_offset;
        fp->f_nextoff = uio->uio_offset;
 
-       if (!(dev_dflags(dev) & D_MPSAFE_WRITE))
-               rel_mplock();
        return (error);
 }
 
 
 static int
-devfs_specf_stat(struct file *fp, struct stat *sb, struct ucred *cred)
+devfs_fo_stat(struct file *fp, struct stat *sb, struct ucred *cred)
 {
        struct vnode *vp;
        struct vattr vattr;
@@ -1367,14 +1351,12 @@ devfs_specf_stat(struct file *fp, struct stat *sb, struct ucred *cred)
 
 
 static int
-devfs_specf_kqfilter(struct file *fp, struct knote *kn)
+devfs_fo_kqfilter(struct file *fp, struct knote *kn)
 {
        struct vnode *vp;
        int error;
        cdev_t dev;
 
-       get_mplock();
-
        vp = (struct vnode *)fp->f_data;
        if (vp == NULL || vp->v_type == VBAD) {
                error = EBADF;
@@ -1391,7 +1373,6 @@ devfs_specf_kqfilter(struct file *fp, struct knote *kn)
        release_dev(dev);
 
 done:
-       rel_mplock();
        return (error);
 }
 
@@ -1399,7 +1380,7 @@ done:
  * MPALMOSTSAFE - acquires mplock
  */
 static int
-devfs_specf_ioctl(struct file *fp, u_long com, caddr_t data,
+devfs_fo_ioctl(struct file *fp, u_long com, caddr_t data,
                  struct ucred *ucred, struct sysmsg *msg)
 {
        struct devfs_node *node;
@@ -1421,7 +1402,7 @@ devfs_specf_ioctl(struct file *fp, u_long com, caddr_t data,
        node = DEVFS_NODE(vp);
 
        devfs_debug(DEVFS_DEBUG_DEBUG,
-                   "devfs_specf_ioctl() called! for dev %s\n",
+                   "devfs_fo_ioctl() called! for dev %s\n",
                    dev->si_name);
 
        if (com == FIODTYPE) {
@@ -1446,10 +1427,6 @@ devfs_specf_ioctl(struct file *fp, u_long com, caddr_t data,
                goto out;
        }
 
-       /* only acquire mplock for devices that require it */
-       if (!(dev_dflags(dev) & D_MPSAFE_IOCTL))
-               get_mplock();
-
        error = dev_dioctl(dev, com, data, fp->f_flag, ucred, msg);
 
 #if 0
@@ -1458,13 +1435,9 @@ devfs_specf_ioctl(struct file *fp, u_long com, caddr_t data,
                nanotime(&node->mtime);
        }
 #endif
-
-       if (!(dev_dflags(dev) & D_MPSAFE_IOCTL))
-               rel_mplock();
-
        if (com == TIOCSCTTY) {
                devfs_debug(DEVFS_DEBUG_DEBUG,
-                           "devfs_specf_ioctl: got TIOCSCTTY on %s\n",
+                           "devfs_fo_ioctl: got TIOCSCTTY on %s\n",
                            dev->si_name);
        }
        if (error == 0 && com == TIOCSCTTY) {
@@ -1472,7 +1445,7 @@ devfs_specf_ioctl(struct file *fp, u_long com, caddr_t data,
                struct session *sess;
 
                devfs_debug(DEVFS_DEBUG_DEBUG,
-                           "devfs_specf_ioctl: dealing with TIOCSCTTY on %s\n",
+                           "devfs_fo_ioctl: dealing with TIOCSCTTY on %s\n",
                            dev->si_name);
                if (p == NULL) {
                        error = ENOTTY;
@@ -1500,7 +1473,7 @@ devfs_specf_ioctl(struct file *fp, u_long com, caddr_t data,
 
 out:
        release_dev(dev);
-       devfs_debug(DEVFS_DEBUG_DEBUG, "devfs_specf_ioctl() finished! \n");
+       devfs_debug(DEVFS_DEBUG_DEBUG, "devfs_fo_ioctl() finished! \n");
        return (error);
 }
 
@@ -2125,14 +2098,3 @@ sequential_heuristic(struct uio *uio, struct file *fp)
                fp->f_seqcount = 0;
        return(0);
 }
-
-extern SYSCTL_NODE(_vfs, OID_AUTO, devfs, CTLFLAG_RW, 0, "devfs");
-
-SYSCTL_INT(_vfs_devfs, OID_AUTO, mpsafe_writes, CTLFLAG_RD, &mpsafe_writes,
-               0, "mpsafe writes");
-SYSCTL_INT(_vfs_devfs, OID_AUTO, mplock_writes, CTLFLAG_RD, &mplock_writes,
-               0, "non-mpsafe writes");
-SYSCTL_INT(_vfs_devfs, OID_AUTO, mpsafe_reads, CTLFLAG_RD, &mpsafe_reads,
-               0, "mpsafe reads");
-SYSCTL_INT(_vfs_devfs, OID_AUTO, mplock_reads, CTLFLAG_RD, &mplock_reads,
-               0, "non-mpsafe reads");