#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();
+}
/*
DEVFS_LOCK();
file_node = VTODN(vp);
- microtime(&now);
- dn_times(file_node, &now, &now, &now);
-
VATTR_RETURN(vap, va_mode, file_node->dn_mode);
/*
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:
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_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();
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_flags, 0);
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;
{
struct vnode * vp = ap->a_vp;
register devnode_t * dnp;
- struct timeval now;
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);
{
struct vnode * vp = ap->a_vp;
register devnode_t * dnp;
- struct timeval now;
- if (vnode_isinuse(vp, 1)) {
+ if (vnode_isinuse(vp, 0)) {
DEVFS_LOCK();
- microtime(&now);
dnp = VTODN(vp);
- dn_times(dnp, &now, &now, &now);
+ dn_times_now(dnp, 0);
DEVFS_UNLOCK();
}
+
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 {
{
register 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));
}
{
register 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 0; /* not reached */
}
+/*
+ * Deviates from UFS naming convention because there is a KPI function
+ * called devfs_remove().
+ */
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;
/***********************************
* 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
devnode_t * tdp;
devdirent_t * tnp;
int error = 0;
- struct timeval now;
/*
* First catch an arbitrary restriction for this FS
/***********************************
* 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);
devdirent_t *fnp,*tnp;
int doingdirectory = 0;
int error = 0;
- struct timeval now;
DEVFS_LOCK();
/*
/***********************************
* 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.
*/
ra.a_flags = 0; /* XXX */
ra.a_context = ap->a_context;
- return devfs_remove(&ra);
+ return devfs_vnop_remove(&ra);
}
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;
- devnode_t * dir_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;
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);
- error = devfs_dntovn(dev_p, vpp, p);
+ if (newent) {
+ *newent = nm_p;
+ }
+
failure:
- DEVFS_UNLOCK();
return error;
}
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:
- 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)
- dirent.d_fileno
- = (int32_t)dir_node->dn_typeinfo.Dir.parent;
+ dirent.d_fileno = dir_node->dn_typeinfo.Dir.parent->dn_ino;
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:
- 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) {
DEVFS_UNLOCK();
uio->uio_offset = pos;
+ devfs_consider_time_update(dir_node, DEVFS_UPDATE_ACCESS);
+
return (error);
}
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;
- 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();
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);
}
/*
return (0);
}
+
+ DEVFS_ATTR_LOCK_SPIN();
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);
}
{ &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_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 */
};
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 */
+
+
projects / apple / xnu.git / blobdiff