xnu-3789.1.32.tar.gz

[apple/xnu.git] / bsd / miscfs / devfs / devfs_vnops.c

diff --git a/bsd/miscfs/devfs/devfs_vnops.c b/bsd/miscfs/devfs/devfs_vnops.c
index d9aedf798df57c93e32d49946810b4e01c335bb7..ebf0f0c14db84d27a084a96467d88aba6098c789 100644 (file)
--- a/bsd/miscfs/devfs/devfs_vnops.c
+++ b/bsd/miscfs/devfs/devfs_vnops.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2016 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -104,9 +104,85 @@
 #endif
 
 #include "devfsdefs.h"
 #endif
 
 #include "devfsdefs.h"

+#include "devfs.h"
+
+#if FDESC
+#include "fdesc.h"
+#endif /* FDESC */
+
+static int             devfs_update(struct vnode *vp, struct timeval *access,
+                               struct timeval *modify);
+void                   devfs_rele_node(devnode_t *);
+static void            devfs_consider_time_update(devnode_t *dnp, uint32_t just_changed_flags);
+static boolean_t       devfs_update_needed(long now_s, long last_s);
+void                   dn_times_locked(devnode_t * dnp, struct timeval *t1, struct timeval *t2, struct timeval *t3, uint32_t just_changed_flags);
+void                   dn_times_now(devnode_t *dnp, uint32_t just_changed_flags);
+void                   dn_mark_for_delayed_times_update(devnode_t *dnp, uint32_t just_changed_flags);
+
+void 
+dn_times_locked(devnode_t * dnp, struct timeval *t1, struct timeval *t2, struct timeval *t3, uint32_t just_changed_flags)
+{
+
+       lck_mtx_assert(&devfs_attr_mutex, LCK_MTX_ASSERT_OWNED);
+
+       if (just_changed_flags & DEVFS_UPDATE_ACCESS) {
+               dnp->dn_atime.tv_sec = t1->tv_sec;
+               dnp->dn_atime.tv_nsec = t1->tv_usec * 1000;
+               dnp->dn_access = 0;
+       } else if (dnp->dn_access) {
+               dnp->dn_atime.tv_sec = MIN(t1->tv_sec, dnp->dn_atime.tv_sec + DEVFS_LAZY_UPDATE_SECONDS);
+               dnp->dn_atime.tv_nsec = t1->tv_usec * 1000;
+               dnp->dn_access = 0;
+       }

 
 

-static int devfs_update(struct vnode *vp, struct timeval *access,
-                        struct timeval *modify);
+       if (just_changed_flags & DEVFS_UPDATE_MOD) {
+               dnp->dn_mtime.tv_sec = t2->tv_sec;
+               dnp->dn_mtime.tv_nsec = t2->tv_usec * 1000;
+               dnp->dn_update = 0;
+       } else if (dnp->dn_update) {
+               dnp->dn_mtime.tv_sec = MIN(t2->tv_sec, dnp->dn_mtime.tv_sec + DEVFS_LAZY_UPDATE_SECONDS);
+               dnp->dn_mtime.tv_nsec = t2->tv_usec * 1000;
+               dnp->dn_update = 0;
+       }
+
+       if (just_changed_flags & DEVFS_UPDATE_CHANGE) {
+               dnp->dn_ctime.tv_sec = t3->tv_sec;
+               dnp->dn_ctime.tv_nsec = t3->tv_usec * 1000;
+               dnp->dn_change = 0;
+       } else if (dnp->dn_change) {
+               dnp->dn_ctime.tv_sec = MIN(t3->tv_sec, dnp->dn_ctime.tv_sec + DEVFS_LAZY_UPDATE_SECONDS);
+               dnp->dn_ctime.tv_nsec = t3->tv_usec * 1000;
+               dnp->dn_change = 0;
+       }
+}
+
+void
+dn_mark_for_delayed_times_update(devnode_t *dnp, uint32_t just_changed_flags)
+{
+       if (just_changed_flags & DEVFS_UPDATE_CHANGE) {
+               dnp->dn_change = 1;
+       }
+       if (just_changed_flags & DEVFS_UPDATE_ACCESS) {
+               dnp->dn_access = 1;
+       }
+       if (just_changed_flags & DEVFS_UPDATE_MOD) {
+               dnp->dn_update = 1;
+       }
+}
+
+/*
+ * Update times based on pending updates and optionally a set of new changes.
+ */
+void
+dn_times_now(devnode_t * dnp, uint32_t just_changed_flags)
+{
+       struct timeval now;
+
+       DEVFS_ATTR_LOCK_SPIN();
+       microtime(&now);
+       dn_times_locked(dnp, &now, &now, &now, just_changed_flags);
+       DEVFS_ATTR_UNLOCK();
+}

 
 
 /*
 
 
 /*


@@ -347,9 +423,6 @@ devfs_getattr(struct vnop_getattr_args *ap)
        DEVFS_LOCK();
        file_node = VTODN(vp);
 
        DEVFS_LOCK();
        file_node = VTODN(vp);
 

-       microtime(&now);
-       dn_times(file_node, &now, &now, &now);
-

        VATTR_RETURN(vap, va_mode, file_node->dn_mode);
 
        /*
        VATTR_RETURN(vap, va_mode, file_node->dn_mode);
 
        /*


@@ -360,7 +433,10 @@ devfs_getattr(struct vnop_getattr_args *ap)
        switch (file_node->dn_type)
        {
        case    DEV_DIR:
        switch (file_node->dn_type)
        {
        case    DEV_DIR:

-               VATTR_RETURN(vap, va_rdev,  (dev_t)file_node->dn_dvm);
+#if FDESC
+       case    DEV_DEVFD:      /* Like a directory */
+#endif /* FDESC */
+               VATTR_RETURN(vap, va_rdev,  0);

                vap->va_mode |= (S_IFDIR);
                break;
        case    DEV_CDEV:
                vap->va_mode |= (S_IFDIR);
                break;
        case    DEV_CDEV:


@@ -383,7 +459,7 @@ devfs_getattr(struct vnop_getattr_args *ap)
        VATTR_RETURN(vap, va_uid, file_node->dn_uid);
        VATTR_RETURN(vap, va_gid, file_node->dn_gid);
        VATTR_RETURN(vap, va_fsid, (uintptr_t)file_node->dn_dvm);
        VATTR_RETURN(vap, va_uid, file_node->dn_uid);
        VATTR_RETURN(vap, va_gid, file_node->dn_gid);
        VATTR_RETURN(vap, va_fsid, (uintptr_t)file_node->dn_dvm);

-       VATTR_RETURN(vap, va_fileid, (uintptr_t)file_node);
+       VATTR_RETURN(vap, va_fileid, (uintptr_t)file_node->dn_ino);

        VATTR_RETURN(vap, va_data_size, file_node->dn_len);
 
        /* return an override block size (advisory) */
        VATTR_RETURN(vap, va_data_size, file_node->dn_len);
 
        /* return an override block size (advisory) */


@@ -393,6 +469,13 @@ devfs_getattr(struct vnop_getattr_args *ap)
                VATTR_RETURN(vap, va_iosize, MAXPHYSIO);
        else
                VATTR_RETURN(vap, va_iosize, vp->v_mount->mnt_vfsstat.f_iosize);
                VATTR_RETURN(vap, va_iosize, MAXPHYSIO);
        else
                VATTR_RETURN(vap, va_iosize, vp->v_mount->mnt_vfsstat.f_iosize);

+
+
+       DEVFS_ATTR_LOCK_SPIN();
+
+       microtime(&now);
+       dn_times_locked(file_node, &now, &now, &now, 0);
+

        /* if the time is bogus, set it to the boot time */
        if (file_node->dn_ctime.tv_sec == 0) {
                file_node->dn_ctime.tv_sec = boottime_sec();
        /* if the time is bogus, set it to the boot time */
        if (file_node->dn_ctime.tv_sec == 0) {
                file_node->dn_ctime.tv_sec = boottime_sec();


@@ -405,11 +488,20 @@ devfs_getattr(struct vnop_getattr_args *ap)
        VATTR_RETURN(vap, va_change_time, file_node->dn_ctime);
        VATTR_RETURN(vap, va_modify_time, file_node->dn_mtime);
        VATTR_RETURN(vap, va_access_time, file_node->dn_atime);
        VATTR_RETURN(vap, va_change_time, file_node->dn_ctime);
        VATTR_RETURN(vap, va_modify_time, file_node->dn_mtime);
        VATTR_RETURN(vap, va_access_time, file_node->dn_atime);

+
+       DEVFS_ATTR_UNLOCK();
+

        VATTR_RETURN(vap, va_gen, 0);
        VATTR_RETURN(vap, va_gen, 0);

-       VATTR_RETURN(vap, va_flags, 0);

        VATTR_RETURN(vap, va_filerev, 0);
        VATTR_RETURN(vap, va_acl, NULL);
 
        VATTR_RETURN(vap, va_filerev, 0);
        VATTR_RETURN(vap, va_acl, NULL);
 

+       /* Hide the root so Finder doesn't display it */
+       if (vnode_isvroot(vp)) {
+               VATTR_RETURN(vap, va_flags, UF_HIDDEN);
+       } else {
+               VATTR_RETURN(vap, va_flags, 0);
+       }
+

        DEVFS_UNLOCK();
 
        return 0;
        DEVFS_UNLOCK();
 
        return 0;


@@ -526,10 +618,8 @@ devfs_read(struct vnop_read_args *ap)
          default: {
              printf("devfs_read(): bad file type %d", ap->a_vp->v_type);
              return(EINVAL);
          default: {
              printf("devfs_read(): bad file type %d", ap->a_vp->v_type);
              return(EINVAL);

-             break;

          }
        }
          }
        }

-       return (0); /* not reached */

 }
 
 static int
 }
 
 static int


@@ -541,14 +631,12 @@ devfs_close(struct vnop_close_args *ap)
        } */
 {
        struct vnode *          vp = ap->a_vp;
        } */
 {
        struct vnode *          vp = ap->a_vp;

-       register devnode_t *    dnp;
-       struct timeval now;
+       devnode_t *     dnp;

 
        if (vnode_isinuse(vp, 1)) {
            DEVFS_LOCK();
            dnp = VTODN(vp);
 
        if (vnode_isinuse(vp, 1)) {
            DEVFS_LOCK();
            dnp = VTODN(vp);

-           microtime(&now);
-           dn_times(dnp, &now, &now, &now);
+           dn_times_now(dnp, 0);

            DEVFS_UNLOCK();
        }
        return (0);
            DEVFS_UNLOCK();
        }
        return (0);


@@ -563,19 +651,69 @@ devfsspec_close(struct vnop_close_args *ap)
        } */
 {
        struct vnode *          vp = ap->a_vp;
        } */
 {
        struct vnode *          vp = ap->a_vp;

-       register devnode_t *    dnp;
-       struct timeval now;
+       devnode_t *     dnp;

 
 

-       if (vnode_isinuse(vp, 1)) {
+       if (vnode_isinuse(vp, 0)) {

            DEVFS_LOCK();
            DEVFS_LOCK();

-           microtime(&now);

            dnp = VTODN(vp);
            dnp = VTODN(vp);

-           dn_times(dnp, &now, &now, &now);
+           dn_times_now(dnp, 0);

            DEVFS_UNLOCK();
        }
            DEVFS_UNLOCK();
        }

+

        return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_close), ap));
 }
 
        return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_close), ap));
 }
 

+static boolean_t
+devfs_update_needed(long now_s, long last_s)
+{
+       if (now_s > last_s) {
+               if (now_s - last_s >= DEVFS_LAZY_UPDATE_SECONDS) {
+                       return TRUE;
+               }
+       }
+
+       return FALSE;
+}
+
+/*
+ * Given a set of time updates required [to happen at some point], check
+ * either make those changes (and resolve other pending updates) or mark
+ * the devnode for a subsequent update.
+ */
+static void
+devfs_consider_time_update(devnode_t *dnp, uint32_t just_changed_flags)
+{
+       struct timeval          now;
+       long now_s;
+
+       microtime(&now);
+       now_s = now.tv_sec;
+
+       if (dnp->dn_change || (just_changed_flags & DEVFS_UPDATE_CHANGE)) {
+               if (devfs_update_needed(now_s, dnp->dn_ctime.tv_sec)) {
+                       dn_times_now(dnp, just_changed_flags);
+                       return;
+               }
+       }
+       if (dnp->dn_access || (just_changed_flags & DEVFS_UPDATE_ACCESS)) {
+               if (devfs_update_needed(now_s, dnp->dn_atime.tv_sec)) {
+                       dn_times_now(dnp, just_changed_flags);
+                       return;
+               }
+       }
+       if (dnp->dn_update || (just_changed_flags & DEVFS_UPDATE_MOD)) {
+               if (devfs_update_needed(now_s, dnp->dn_mtime.tv_sec)) {
+                       dn_times_now(dnp, just_changed_flags);
+                       return;
+               }
+       }
+
+       /* Not going to do anything now--mark for later update */
+       dn_mark_for_delayed_times_update(dnp, just_changed_flags);
+
+       return;
+}
+

 static int
 devfsspec_read(struct vnop_read_args *ap)
         /* struct vnop_read_args {
 static int
 devfsspec_read(struct vnop_read_args *ap)
         /* struct vnop_read_args {


@@ -585,9 +723,9 @@ devfsspec_read(struct vnop_read_args *ap)
                 kauth_cred_t a_cred;
         } */
 {
                 kauth_cred_t a_cred;
         } */
 {

-       register devnode_t *    dnp = VTODN(ap->a_vp);
+       devnode_t *     dnp = VTODN(ap->a_vp);

 
 

-       dnp->dn_access = 1;
+       devfs_consider_time_update(dnp, DEVFS_UPDATE_ACCESS);

 
        return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_read), ap));
 }
 
        return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_read), ap));
 }


@@ -601,10 +739,9 @@ devfsspec_write(struct vnop_write_args *ap)
                vfs_context_t a_context;
         } */
 {
                vfs_context_t a_context;
         } */
 {

-       register devnode_t *    dnp = VTODN(ap->a_vp);
+       devnode_t *     dnp = VTODN(ap->a_vp);

 
 

-       dnp->dn_change = 1;
-       dnp->dn_update = 1;
+       devfs_consider_time_update(dnp, DEVFS_UPDATE_CHANGE | DEVFS_UPDATE_MOD);

 
        return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_write), ap));
 }
 
        return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_write), ap));
 }


@@ -628,11 +765,14 @@ devfs_write(struct vnop_write_args *ap)
                printf("devfs_write(): bad file type %d", ap->a_vp->v_type);
                return (EINVAL);
        }
                printf("devfs_write(): bad file type %d", ap->a_vp->v_type);
                return (EINVAL);
        }

-       return 0; /* not reached */

 }
 
 }
 

+/* 
+ * Deviates from UFS naming convention because there is a KPI function
+ * called devfs_remove().
+ */

 static int
 static int

-devfs_remove(struct vnop_remove_args *ap)
+devfs_vnop_remove(struct vnop_remove_args *ap)

         /* struct vnop_remove_args  {
                 struct vnode *a_dvp;
                 struct vnode *a_vp;
         /* struct vnop_remove_args  {
                 struct vnode *a_dvp;
                 struct vnode *a_vp;


@@ -684,8 +824,7 @@ devfs_remove(struct vnop_remove_args *ap)
        /***********************************
         * Start actually doing things.... *
         ***********************************/
        /***********************************
         * Start actually doing things.... *
         ***********************************/

-       tdp->dn_change = 1;
-       tdp->dn_update = 1;
+       devfs_consider_time_update(tdp, DEVFS_UPDATE_CHANGE | DEVFS_UPDATE_MOD);

 
        /*
         * Target must be empty if a directory and have no links
 
        /*
         * Target must be empty if a directory and have no links


@@ -721,7 +860,6 @@ devfs_link(struct vnop_link_args *ap)
        devnode_t * tdp;
        devdirent_t * tnp;
        int error = 0;
        devnode_t * tdp;
        devdirent_t * tnp;
        int error = 0;

-       struct timeval now;

 
        /*
         * First catch an arbitrary restriction for this FS
 
        /*
         * First catch an arbitrary restriction for this FS


@@ -750,10 +888,7 @@ devfs_link(struct vnop_link_args *ap)
        /***********************************
         * Start actually doing things.... *
         ***********************************/
        /***********************************
         * Start actually doing things.... *
         ***********************************/

-       fp->dn_change = 1;
-
-       microtime(&now);
-       error = devfs_update(vp, &now, &now);
+       dn_times_now(fp, DEVFS_UPDATE_CHANGE);

 
        if (!error) {
            error = dev_add_name(cnp->cn_nameptr, tdp, NULL, fp, &tnp);
 
        if (!error) {
            error = dev_add_name(cnp->cn_nameptr, tdp, NULL, fp, &tnp);


@@ -813,7 +948,6 @@ devfs_rename(struct vnop_rename_args *ap)
        devdirent_t *fnp,*tnp;
        int doingdirectory = 0;
        int error = 0;
        devdirent_t *fnp,*tnp;
        int doingdirectory = 0;
        int error = 0;

-       struct timeval now;

 
        DEVFS_LOCK();
        /*
 
        DEVFS_LOCK();
        /*


@@ -894,12 +1028,8 @@ devfs_rename(struct vnop_rename_args *ap)
        /***********************************
         * Start actually doing things.... *
         ***********************************/
        /***********************************
         * Start actually doing things.... *
         ***********************************/

-       fp->dn_change = 1;
-       microtime(&now);
+       dn_times_now(fp, DEVFS_UPDATE_CHANGE);

 
 

-       if ( (error = devfs_update(fvp, &now, &now)) ) {
-           goto out;
-       }

        /*
         * Check if just deleting a link name.
         */
        /*
         * Check if just deleting a link name.
         */


@@ -1012,7 +1142,7 @@ devfs_rmdir(struct vnop_rmdir_args *ap)
        ra.a_flags = 0;         /* XXX */
        ra.a_context = ap->a_context;
 
        ra.a_flags = 0;         /* XXX */
        ra.a_context = ap->a_context;
 

-       return devfs_remove(&ra);
+       return devfs_vnop_remove(&ra);

 }
 
 
 }
 
 


@@ -1027,25 +1157,35 @@ devfs_symlink(struct vnop_symlink_args *ap)
                vfs_context_t a_context;
         } */
 {
                vfs_context_t a_context;
         } */
 {

-       struct componentname * cnp = ap->a_cnp;
-       vfs_context_t ctx = cnp->cn_context;
-       struct proc *p = vfs_context_proc(ctx);
+       int error;
+       devdirent_t *newent;
+
+       DEVFS_LOCK();
+       error = devfs_make_symlink(VTODN(ap->a_dvp), ap->a_cnp->cn_nameptr, ap->a_vap->va_mode, ap->a_target, &newent);
+       
+       if (error == 0) {
+               error = devfs_dntovn(newent->de_dnp, ap->a_vpp, vfs_context_proc(ap->a_context));
+       }
+
+       DEVFS_UNLOCK();
+
+       return error;
+
+}
+
+/* Called with devfs locked */
+int
+devfs_make_symlink(devnode_t *dir_p, char *name, int mode, char *target, devdirent_t **newent)
+{

        int error = 0;
        int error = 0;

-       devnode_t * dir_p;

        devnode_type_t typeinfo;
        devdirent_t * nm_p;
        devnode_t * dev_p;
        devnode_type_t typeinfo;
        devdirent_t * nm_p;
        devnode_t * dev_p;

-       struct vnode_attr *     vap = ap->a_vap;
-       struct vnode * * vpp = ap->a_vpp;

 
 

-       typeinfo.Slnk.name = ap->a_target;
-       typeinfo.Slnk.namelen = strlen(ap->a_target);
-
-       DEVFS_LOCK();
+       typeinfo.Slnk.name = target;
+       typeinfo.Slnk.namelen = strlen(target);

 
 

-       dir_p = VTODN(ap->a_dvp);
-
-       error = dev_add_entry(cnp->cn_nameptr, dir_p, DEV_SLNK, 
+       error = dev_add_entry(name, dir_p, DEV_SLNK, 

                              &typeinfo, NULL, NULL, &nm_p);
        if (error) {
            goto failure;
                              &typeinfo, NULL, NULL, &nm_p);
        if (error) {
            goto failure;


@@ -1053,12 +1193,14 @@ devfs_symlink(struct vnop_symlink_args *ap)
        dev_p = nm_p->de_dnp;
        dev_p->dn_uid = dir_p->dn_uid;
        dev_p->dn_gid = dir_p->dn_gid;
        dev_p = nm_p->de_dnp;
        dev_p->dn_uid = dir_p->dn_uid;
        dev_p->dn_gid = dir_p->dn_gid;

-       dev_p->dn_mode = vap->va_mode;
+       dev_p->dn_mode = mode;

        dn_copy_times(dev_p, dir_p);
 
        dn_copy_times(dev_p, dir_p);
 

-       error = devfs_dntovn(dev_p, vpp, p);
+       if (newent) {
+               *newent = nm_p;
+       }
+

 failure:
 failure:

-       DEVFS_UNLOCK();

 
        return error;
 }
 
        return error;
 }


@@ -1160,30 +1302,27 @@ devfs_readdir(struct vnop_readdir_args *ap)
        name_node = dir_node->dn_typeinfo.Dir.dirlist;
        nodenumber = 0;
 
        name_node = dir_node->dn_typeinfo.Dir.dirlist;
        nodenumber = 0;
 

-       dir_node->dn_access = 1;
-

        while ((name_node || (nodenumber < 2)) && (uio_resid(uio) > 0))
        {
                switch(nodenumber)
                {
                case    0:
        while ((name_node || (nodenumber < 2)) && (uio_resid(uio) > 0))
        {
                switch(nodenumber)
                {
                case    0:

-                       dirent.d_fileno = (int32_t)(void *)dir_node;
+                       dirent.d_fileno = dir_node->dn_ino;

                        name = ".";
                        dirent.d_namlen = 1;
                        dirent.d_type = DT_DIR;
                        break;
                case    1:
                        if(dir_node->dn_typeinfo.Dir.parent)
                        name = ".";
                        dirent.d_namlen = 1;
                        dirent.d_type = DT_DIR;
                        break;
                case    1:
                        if(dir_node->dn_typeinfo.Dir.parent)

-                           dirent.d_fileno
-                               = (int32_t)dir_node->dn_typeinfo.Dir.parent;
+                               dirent.d_fileno = dir_node->dn_typeinfo.Dir.parent->dn_ino;

                        else
                        else

-                               dirent.d_fileno = (u_int32_t)dir_node;
+                               dirent.d_fileno = dir_node->dn_ino;

                        name = "..";
                        dirent.d_namlen = 2;
                        dirent.d_type = DT_DIR;
                        break;
                default:
                        name = "..";
                        dirent.d_namlen = 2;
                        dirent.d_type = DT_DIR;
                        break;
                default:

-                       dirent.d_fileno = (int32_t)(void *)name_node->de_dnp;
+                       dirent.d_fileno = name_node->de_dnp->dn_ino;

                        dirent.d_namlen = strlen(name_node->de_name);
                        name = name_node->de_name;
                        switch(name_node->de_dnp->dn_type) {
                        dirent.d_namlen = strlen(name_node->de_name);
                        name = name_node->de_name;
                        switch(name_node->de_dnp->dn_type) {


@@ -1225,6 +1364,8 @@ devfs_readdir(struct vnop_readdir_args *ap)
        DEVFS_UNLOCK();
        uio->uio_offset = pos;
 
        DEVFS_UNLOCK();
        uio->uio_offset = pos;
 

+       devfs_consider_time_update(dir_node, DEVFS_UPDATE_ACCESS);
+

        return (error);
 }
 
        return (error);
 }
 


@@ -1271,16 +1412,12 @@ devfs_reclaim(struct vnop_reclaim_args *ap)
     dnp = VTODN(vp);
 
     if (dnp) {
     dnp = VTODN(vp);
 
     if (dnp) {

-       /* 
-        * do the same as devfs_inactive in case it is not called
-        * before us (can that ever happen?)
-        */
+       /* If this is a cloning device, it didn't have a dn_vn anyway */

        dnp->dn_vn = NULL;
        dnp->dn_vn = NULL;

-       vp->v_data = NULL;
+       vnode_clearfsnode(vp);

 
 

-       if (dnp->dn_delete) {
-           devnode_free(dnp);
-       }
+       /* This could delete the node, if we are the last vnode */
+       devfs_rele_node(dnp);

     }
     DEVFS_UNLOCK();
 
     }
     DEVFS_UNLOCK();
 


@@ -1347,7 +1484,18 @@ devs_vnop_pathconf(
 static int
 devfs_inactive(__unused struct vnop_inactive_args *ap)
 {
 static int
 devfs_inactive(__unused struct vnop_inactive_args *ap)
 {

-    return (0);
+       vnode_t vp = ap->a_vp;
+       devnode_t *dnp = VTODN(vp);
+
+       /* 
+        * Cloned vnodes are not linked in anywhere, so they
+        * can just be recycled.  
+        */
+       if (dnp->dn_clone != NULL) {
+               vnode_recycle(vp);
+       }
+
+       return (0);

 }
 
 /*
 }
 
 /*


@@ -1367,8 +1515,11 @@ devfs_update(struct vnode *vp, struct timeval *access, struct timeval *modify)
 
                return (0);
        }
 
                return (0);
        }

+
+       DEVFS_ATTR_LOCK_SPIN();

        microtime(&now);
        microtime(&now);

-       dn_times(ip, access, modify, &now);
+       dn_times_locked(ip, access, modify, &now, DEVFS_UPDATE_ACCESS | DEVFS_UPDATE_MOD);
+       DEVFS_ATTR_UNLOCK();

 
        return (0);
 }
 
        return (0);
 }


@@ -1394,7 +1545,7 @@ static struct vnodeopv_entry_desc devfs_vnodeop_entries[] = {
        { &vnop_revoke_desc, (VOPFUNC)err_revoke },             /* revoke */
        { &vnop_mmap_desc, (VOPFUNC)err_mmap },                 /* mmap */
        { &vnop_fsync_desc, (VOPFUNC)nop_fsync },               /* fsync */
        { &vnop_revoke_desc, (VOPFUNC)err_revoke },             /* revoke */
        { &vnop_mmap_desc, (VOPFUNC)err_mmap },                 /* mmap */
        { &vnop_fsync_desc, (VOPFUNC)nop_fsync },               /* fsync */

-       { &vnop_remove_desc, (VOPFUNC)devfs_remove },           /* remove */
+       { &vnop_remove_desc, (VOPFUNC)devfs_vnop_remove },      /* remove */

        { &vnop_link_desc, (VOPFUNC)devfs_link },               /* link */
        { &vnop_rename_desc, (VOPFUNC)devfs_rename },           /* rename */
        { &vnop_mkdir_desc, (VOPFUNC)devfs_mkdir },             /* mkdir */
        { &vnop_link_desc, (VOPFUNC)devfs_link },               /* link */
        { &vnop_rename_desc, (VOPFUNC)devfs_rename },           /* rename */
        { &vnop_mkdir_desc, (VOPFUNC)devfs_mkdir },             /* mkdir */


@@ -1440,7 +1591,7 @@ static struct vnodeopv_entry_desc devfs_spec_vnodeop_entries[] = {
        { &vnop_revoke_desc, (VOPFUNC)spec_revoke },            /* revoke */
        { &vnop_mmap_desc, (VOPFUNC)spec_mmap },                        /* mmap */
        { &vnop_fsync_desc, (VOPFUNC)spec_fsync },              /* fsync */
        { &vnop_revoke_desc, (VOPFUNC)spec_revoke },            /* revoke */
        { &vnop_mmap_desc, (VOPFUNC)spec_mmap },                        /* mmap */
        { &vnop_fsync_desc, (VOPFUNC)spec_fsync },              /* fsync */

-       { &vnop_remove_desc, (VOPFUNC)devfs_remove },           /* remove */
+       { &vnop_remove_desc, (VOPFUNC)devfs_vnop_remove },      /* remove */

        { &vnop_link_desc, (VOPFUNC)devfs_link },               /* link */
        { &vnop_rename_desc, (VOPFUNC)spec_rename },            /* rename */
        { &vnop_mkdir_desc, (VOPFUNC)spec_mkdir },              /* mkdir */
        { &vnop_link_desc, (VOPFUNC)devfs_link },               /* link */
        { &vnop_rename_desc, (VOPFUNC)spec_rename },            /* rename */
        { &vnop_mkdir_desc, (VOPFUNC)spec_mkdir },              /* mkdir */


@@ -1467,3 +1618,30 @@ static struct vnodeopv_entry_desc devfs_spec_vnodeop_entries[] = {
 };
 struct vnodeopv_desc devfs_spec_vnodeop_opv_desc =
        { &devfs_spec_vnodeop_p, devfs_spec_vnodeop_entries };
 };
 struct vnodeopv_desc devfs_spec_vnodeop_opv_desc =
        { &devfs_spec_vnodeop_p, devfs_spec_vnodeop_entries };

+
+
+#if FDESC
+int (**devfs_devfd_vnodeop_p)(void*);
+static struct vnodeopv_entry_desc devfs_devfd_vnodeop_entries[] = {
+       { &vnop_default_desc, (VOPFUNC)vn_default_error },
+       { &vnop_lookup_desc, (VOPFUNC)devfs_devfd_lookup},      /* lookup */
+       { &vnop_open_desc, (VOPFUNC)nop_open },                 /* open */
+       { &vnop_close_desc, (VOPFUNC)devfs_close },             /* close */
+       { &vnop_getattr_desc, (VOPFUNC)devfs_getattr },         /* getattr */
+       { &vnop_setattr_desc, (VOPFUNC)devfs_setattr },         /* setattr */
+       { &vnop_revoke_desc, (VOPFUNC)err_revoke },             /* revoke */
+       { &vnop_fsync_desc, (VOPFUNC)nop_fsync },               /* fsync */
+       { &vnop_readdir_desc, (VOPFUNC)devfs_devfd_readdir},            /* readdir */
+       { &vnop_inactive_desc, (VOPFUNC)devfs_inactive },       /* inactive */
+       { &vnop_reclaim_desc, (VOPFUNC)devfs_reclaim },         /* reclaim */
+       { &vnop_pathconf_desc, (VOPFUNC)devs_vnop_pathconf },   /* pathconf */
+#if CONFIG_MACF
+       { &vnop_setlabel_desc, (VOPFUNC)devfs_setlabel },       /* setlabel */
+#endif
+       { (struct vnodeop_desc*)NULL, (int(*)())NULL }
+};
+struct vnodeopv_desc devfs_devfd_vnodeop_opv_desc =
+       { &devfs_devfd_vnodeop_p, devfs_devfd_vnodeop_entries};
+#endif /* FDESC */
+
+