Index: head/sys/miscfs/devfs/devfs_proto.h =================================================================== --- head/sys/miscfs/devfs/devfs_proto.h (revision 10597) +++ head/sys/miscfs/devfs/devfs_proto.h (revision 10598) @@ -1,71 +1,70 @@ /* THIS FILE PRODUCED AUTOMATICALLY */ void devfs_sinit(caddr_t junk) /*proto*/; +dn_p dev_findname(dn_p dir,char *name) /*proto*/; int dev_finddir(char *orig_path, dn_p dirnode, int create, dn_p *dn_pp) /*proto*/; -int dev_add_node(char *name, dn_p dirnode,devnm_p back, int entrytype, union typeinfo *by, devnm_p *devnm_pp) /*proto*/; -int dev_remove(devnm_p devnmp) /*proto*/; +int dev_add_name(char *name, dn_p dirnode,devnm_p back, int entrytype, union typeinfo *by, devnm_p *devnm_pp) /*proto*/; int dev_touch(devnm_p key) /* update the node for this dev */ /*proto*/; void devfs_dn_free(dn_p dnp) /*proto*/; -int get_cdev_major_num(caddr_t addr) /*proto*/; -int get_bdev_major_num(caddr_t addr) /*proto*/; int devfs_add_fronts(devnm_p parent,devnm_p child) /*proto*/; -dn_p dev_findname(dn_p dir,char *name) /*proto*/; -int dev_mk_front(dn_p parent, devnm_p back, devnm_p *dnm_pp, struct devfsmount *dvm) /*proto*/; -int devfs_make_plane(struct devfsmount *devfs_mp_p) /*proto*/; +void dev_remove_dev(devnm_p devnmp) /*proto*/; +int dev_dup_plane(struct devfsmount *devfs_mp_p) /*proto*/; void devfs_free_plane(struct devfsmount *devfs_mp_p) /*proto*/; -void devfs_remove_fronts(devnm_p devnmp) /*proto*/; +int dev_dup_name(dn_p parent, devnm_p back, devnm_p *dnm_pp, struct devfsmount *dvm) /*proto*/; void dev_free_name(devnm_p devnmp) /*proto*/; int devfs_vntodn(struct vnode *vn_p, dn_p *dn_pp) /*proto*/; int devfs_dntovn(dn_p dnp, struct vnode **vn_pp) /*proto*/; +int get_cdev_major_num(caddr_t addr) /*proto*/; +int get_bdev_major_num(caddr_t addr) /*proto*/; int devfs_init(void) /*proto*/; int devfs_mount( struct mount *mp, char *path, caddr_t data, struct nameidata *ndp, struct proc *p) /*proto*/; int mountdevfs( struct mount *mp, struct proc *p) /*proto*/; int devfs_start(struct mount *mp, int flags, struct proc *p) /*proto*/; int devfs_unmount( struct mount *mp, int mntflags, struct proc *p) /*proto*/; int devfs_root(struct mount *mp, struct vnode **vpp) /*proto*/; int devfs_quotactl( struct mount *mp, int cmds, uid_t uid, caddr_t arg, struct proc *p) /*proto*/; int devfs_statfs( struct mount *mp, struct statfs *sbp, struct proc *p) /*proto*/; int devfs_sync(struct mount *mp, int waitfor,struct ucred *cred,struct proc *p) /*proto*/; int devfs_vget(struct mount *mp, ino_t ino,struct vnode **vpp) /*proto*/; int devfs_fhtovp (struct mount *mp, struct fid *fhp, struct mbuf *nam, struct vnode **vpp, int *exflagsp, struct ucred **credanonp) /*proto*/; int devfs_vptofh (struct vnode *vp, struct fid *fhp) /*proto*/; int devfs_lookup(struct vop_lookup_args *ap) /*proto*/; int devfs_create(struct vop_mknod_args *ap) /*proto*/; int devfs_mknod( struct vop_mknod_args *ap) /*proto*/; int devfs_open(struct vop_open_args *ap) /*proto*/; int devfs_close( struct vop_close_args *ap) /*proto*/; int devfs_access(struct vop_access_args *ap) /*proto*/; int devfs_getattr(struct vop_getattr_args *ap) /*proto*/; int devfs_setattr(struct vop_setattr_args *ap) /*proto*/; int devfs_read(struct vop_read_args *ap) /*proto*/; int devfs_write(struct vop_write_args *ap) /*proto*/; int devfs_ioctl(struct vop_ioctl_args *ap) /*proto*/; int devfs_select(struct vop_select_args *ap) /*proto*/; int devfs_mmap(struct vop_mmap_args *ap) /*proto*/; int devfs_fsync(struct vop_fsync_args *ap) /*proto*/; int devfs_seek(struct vop_seek_args *ap) /*proto*/; int devfs_remove(struct vop_remove_args *ap) /*proto*/; int devfs_link(struct vop_link_args *ap) /*proto*/; int devfs_rename(struct vop_rename_args *ap) /*proto*/; int devfs_mkdir(struct vop_mkdir_args *ap) /*proto*/; int devfs_rmdir(struct vop_rmdir_args *ap) /*proto*/; int devfs_symlink(struct vop_symlink_args *ap) /*proto*/; int devfs_readdir(struct vop_readdir_args *ap) /*proto*/; int devfs_readlink(struct vop_readlink_args *ap) /*proto*/; int devfs_abortop(struct vop_abortop_args *ap) /*proto*/; int devfs_inactive(struct vop_inactive_args *ap) /*proto*/; int devfs_lock(struct vop_lock_args *ap) /*proto*/; int devfs_unlock( struct vop_unlock_args *ap) /*proto*/; int devfs_islocked(struct vop_islocked_args *ap) /*proto*/; int devfs_bmap(struct vop_bmap_args *ap) /*proto*/; int devfs_strategy(struct vop_strategy_args *ap) /*proto*/; int devfs_advlock(struct vop_advlock_args *ap) /*proto*/; int devfs_reclaim(struct vop_reclaim_args *ap) /*proto*/; int devfs_pathconf(struct vop_pathconf_args *ap) /*proto*/; int devfs_print(struct vop_print_args *ap) /*proto*/; int devfs_vfree(struct vop_vfree_args *ap) /*proto*/; int devfs_enotsupp(void *junk) /*proto*/; int devfs_badop(void *junk) /*proto*/; int devfs_nullop(void *junk) /*proto*/; void devfs_dropvnode(dn_p dnp) /*proto*/; /* THIS FILE PRODUCED AUTOMATICALLY */ /* DO NOT EDIT (see reproto.sh) */ Index: head/sys/miscfs/devfs/devfs_tree.c =================================================================== --- head/sys/miscfs/devfs/devfs_tree.c (revision 10597) +++ head/sys/miscfs/devfs/devfs_tree.c (revision 10598) @@ -1,901 +1,899 @@ /* * Written by Julian Elischer (julian@DIALix.oz.au) * - * $Header: /home/ncvs/src/sys/miscfs/devfs/devfs_tree.c,v 1.2 1995/09/06 09:29:16 julian Exp $ + * $Header: /home/ncvs/src/sys/miscfs/devfs/devfs_tree.c,v 1.3 1995/09/06 23:15:53 julian Exp $ */ #include "param.h" #include "systm.h" #include "types.h" #include "kernel.h" #include "file.h" /* define FWRITE ... */ #include "conf.h" #include "stat.h" #include "mount.h" #include "vnode.h" #include "malloc.h" #include "dir.h" /* defines dirent structure */ #include "devfsdefs.h" #include "sys/devfsext.h" SYSINIT(devfs, SI_SUB_DEVFS, SI_ORDER_FIRST, devfs_sinit, NULL) devnm_p dev_root; /* root of the backing tree */ struct mount *devfs_hidden_mount; int devfs_up_and_going; /* * Set up the root directory node in the backing plane * This is happenning before the vfs system has been * set up yet, so be careful about what we reference.. * Notice that the ops are by indirection.. as they haven't * been set up yet! */ void devfs_sinit(caddr_t junk) /*proto*/ { int retval; /* we will discard this */ devnm_p new; /* * call the right routine at the right time with the right args.... */ - retval = dev_add_node("root",NULL,NULL,DEV_DIR,NULL,&dev_root); + retval = dev_add_name("root",NULL,NULL,DEV_DIR,NULL,&dev_root); #ifdef PARANOID - if(retval) panic("devfs_sinit: dev_add_node failed "); + if(retval) panic("devfs_sinit: dev_add_name failed "); #endif devfs_hidden_mount = (struct mount *)malloc(sizeof(struct mount), M_MOUNT,M_NOWAIT); #ifdef PARANOID if(!devfs_hidden_mount) panic("devfs_sinit: malloc failed"); #endif bzero(devfs_hidden_mount,sizeof(struct mount)); devfs_mount(devfs_hidden_mount,"dummy",NULL,NULL,NULL); dev_root->dnp->dvm = (struct devfsmount *)devfs_hidden_mount->mnt_data; devfs_up_and_going = 1; printf("DEVFS: ready for devices\n"); } /***********************************************************************\ -* Routines used to add and remove nodes from the base tree * +************************************************************************* +* Routines used to find our way to a point in the tree * +************************************************************************* \***********************************************************************/ + + +/***************************************************************\ +* Search down the linked list off a dir to find "name" * +* return the dn_p for that node. +\***************************************************************/ +dn_p dev_findname(dn_p dir,char *name) /*proto*/ +{ + devnm_p newfp; + DBPRINT((" dev_findname(%s)\n",name)); + if(dir->type != DEV_DIR) return 0;/*XXX*/ /* printf?*/ + + if(name[0] == '.') + { + if(name[1] == 0) + { + return dir; + } + if((name[1] == '.') && (name[2] == 0)) + { + return dir->by.Dir.parent; /* for root, .. == . */ + } + } + newfp = dir->by.Dir.dirlist; + while(newfp) + { + if(!(strcmp(name,newfp->name))) + return newfp->dnp; + newfp = newfp->next; + } + return (dn_p)0; +} + /***********************************************************************\ * Given a starting node (0 for root) and a pathname, return the node * * for the end item on the path. It MUST BE A DIRECTORY. If the 'CREATE' * * option is true, then create any missing nodes in the path and create * * and return the final node as well. * * This is used to set up a directory, before making nodes in it.. * * * * Warning: This function is RECURSIVE. * * char *path, find this dir (err if not dir) * * dn_p dirnode, starting point (0 = root) * * int create, create path if not found * * dn_p *dn_pp) where to return the node of the dir * \***********************************************************************/ int dev_finddir(char *orig_path, dn_p dirnode, int create, dn_p *dn_pp) /*proto*/ { devnm_p devnmp; dn_p dnp; char pathbuf[DEVMAXPATHSIZE]; char *path; char *name; register char *cp; int retval; DBPRINT(("dev_finddir\n")); /***************************************\ * If no parent directory is given * * then start at the root of the tree * \***************************************/ if(!dirnode) dirnode = dev_root->dnp; /***************************************\ * Sanity Checks * \***************************************/ if(dirnode->type != DEV_DIR) return ENOTDIR; if(strlen(orig_path) > (DEVMAXPATHSIZE - 1)) return ENAMETOOLONG; path = pathbuf; strcpy(path,orig_path); while(*path == '/') path++; /* always absolute, skip leading / */ /***************************************\ * find the next segment of the name * \***************************************/ cp = name = path; while((*cp != '/') && (*cp != 0)) { cp++; } /***********************************************\ * Check to see if it's the last component * \***********************************************/ if(*cp) { path = cp + 1; /* path refers to the rest */ *cp = 0; /* name is now a separate string */ if(!(*path)) { path = (char *)0; /* was trailing slash */ } } else { path = (char *)0; /* no more to do */ } /***************************************\ * Start scanning along the linked list * \***************************************/ dnp = dev_findname(dirnode,name); if(dnp) { /* check it's a directory */ if(dnp->type != DEV_DIR) return ENOTDIR; } else { /***************************************\ * The required element does not exist * * So we will add it if asked to. * \***************************************/ if(!create) return ENOENT; - if(retval = dev_add_node(name, dirnode, NULL ,DEV_DIR, + if(retval = dev_add_name(name, dirnode, NULL ,DEV_DIR, NULL, &devnmp)) { return retval; } dnp = devnmp->dnp; } if(path) /* decide whether to recurse more or return */ { return (dev_finddir(path,dnp,create,dn_pp)); } else { *dn_pp = dnp; return 0; } } /***********************************************************************\ * Add a new element to the devfs backing structure. * * If we're creating a root node, then dirname is NULL * * If devnode is non zero, then we just want to create a link to it * * This implies that we are not at base level and it's a not a DIR * +* * +* Creates a name node, and (optionally) a new dev_node to go with it * \***********************************************************************/ -int dev_add_node(char *name, dn_p dirnode,devnm_p back, int entrytype, union typeinfo *by, devnm_p *devnm_pp) /*proto*/ +int dev_add_name(char *name, dn_p dirnode,devnm_p back, int entrytype, union typeinfo *by, devnm_p *devnm_pp) /*proto*/ { devnm_p devnmp; devnm_p realthing; /* needed to create an alias */ dn_p dnp; int retval; - DBPRINT(("dev_add_node\n")); + DBPRINT(("dev_add_name\n")); if(dirnode ) { if(dirnode->type != DEV_DIR) return(ENOTDIR); dnp = dev_findname(dirnode,name); if(dnp) /* if we actually found it.. */ return(EEXIST); } /* * make sure the name is legal * slightly misleading in the case of NULL */ if( !name || (strlen(name) > (DEVMAXNAMESIZE - 1))) return (ENAMETOOLONG); /* * Allocate and fill out a new directory entry */ if(!(devnmp = (devnm_p)malloc(sizeof(devnm_t), M_DEVFSNAME, M_NOWAIT))) { return ENOMEM; } bzero(devnmp,sizeof(devnm_t)); /* * If we don't already have one, * Allocate a devfs node.. * If we already have one, create a new link to it. * DIR types ALWAYS get a new node.. */ if (( entrytype == DEV_DIR) || (!back)) { if(!(dnp = (dn_p)malloc(sizeof(devnode_t), M_DEVFSNODE, M_NOWAIT))) { free(devnmp,M_DEVFSNAME); return ENOMEM; } bzero(dnp,sizeof(devnode_t)); /* * note the node type we are adding * and set the creation times to NOW * put in it's name */ dnp->type = entrytype; TIMEVAL_TO_TIMESPEC(&time,&(dnp->ctime)) dnp->mtime = dnp->ctime; dnp->atime = dnp->ctime; /* * fill out the dev node according to type */ switch(entrytype) { case DEV_DIR: /* * As it's a directory, make sure * it has a null entries list */ dnp->by.Dir.dirlast = &(dnp->by.Dir.dirlist); dnp->by.Dir.dirlist = (devnm_p)0; if ( dirnode ) { dnp->by.Dir.parent = (dn_p)dirnode; } else { /* root loops to self */ dnp->by.Dir.parent = dnp; } dnp->by.Dir.parent->links++; /* account for .. */ dnp->links++; /* for .*/ dnp->by.Dir.myname = devnmp; /* * make sure that the ops associated with it are the ops * that we use (by default) for directories */ dnp->ops = &devfs_vnodeop_p; dnp->mode |= 0555; /* default perms */ break; /*******************************************************\ * The rest of these can't happen except in the back plane* \*******************************************************/ case DEV_BDEV: /* * Make sure it has DEVICE type ops * and device specific fields are correct */ dnp->ops = &dev_spec_vnodeop_p; dnp->by.Bdev.bdevsw = by->Bdev.bdevsw; dnp->by.Bdev.dev = by->Bdev.dev; break; case DEV_CDEV: /* * Make sure it has DEVICE type ops * and device specific fields are correct */ dnp->ops = &dev_spec_vnodeop_p; dnp->by.Cdev.cdevsw = by->Cdev.cdevsw; dnp->by.Cdev.dev = by->Cdev.dev; break; case DEV_DDEV: /* * store the address of (the address of) the ops * and the magic cookie to use with them */ dnp->by.Ddev.arg = by->Ddev.arg; dnp->ops = by->Ddev.ops; break; case DEV_ALIAS: /* * point to the node we want to shadow * Also store the fact we exist so that aliases * can be deleted accuratly when the original node * is deleted.. (i.e. when device is removed) */ realthing = by->Alias.realthing; dnp->by.Alias.realthing = realthing; dnp->by.Alias.next = realthing->as.back.aliases; realthing->as.back.aliases = devnmp; break; } /* inherrit our parent's mount info */ if(dirnode) { dnp->dvm = dirnode->dvm; if(!dnp->dvm) printf("parent had null dvm "); } } else { dnp = back->dnp; if(!dnp->dvm) printf("node has null dvm "); } /* * Link the two together * include the implicit link in the count of links to the devnode.. * this stops it from being accidentally freed later. */ devnmp->dnp = dnp; dnp->links++ ; /* implicit from our own name-node */ /* * put in it's name */ strcpy(devnmp->name,name); /* * And set up the 'clones' list (empty if new node) */ if(back) { /*******************************************************\ * Put it in the appropriate back/front list too. * \*******************************************************/ devnmp->next_front = *back->prev_frontp; devnmp->prev_frontp = back->prev_frontp; *back->prev_frontp = devnmp; back->prev_frontp = &(devnmp->next_front); devnmp->as.front.realthing = back; } else { devnmp->prev_frontp = &(devnmp->next_front); devnmp->next_front = NULL; } /******************************************* * Check if we are not making a root node.. * (i.e. have parent) */ if(dirnode) { /* * Put it on the END of the linked list of directory entries */ devnmp->parent = dirnode; /* null for root */ devnmp->prevp = dirnode->by.Dir.dirlast; devnmp->next = *(devnmp->prevp); /* should be NULL */ /*right?*/ *(devnmp->prevp) = devnmp; dirnode->by.Dir.dirlast = &(devnmp->next); dirnode->by.Dir.entrycount++; dirnode->len += strlen(name) + 8;/*ok, ok?*/ } /* * If we have a parent, then maybe we should duplicate * ourselves onto any plane that the parent is on... * Though this may be better handled elsewhere as * it stops this routine from being used for front nodes */ if(dirnode && !back) { if(retval = devfs_add_fronts(dirnode->by.Dir.myname,devnmp)) { /*XXX*//* no idea what to do if it fails... */ return retval; } } *devnm_pp = devnmp; return 0 ; } - -/*********************************************************************** - * remove all fronts to this dev and also it's aliases, - * Then remove this node. - * For now only allow DEVICE nodes to go.. XXX - * directory nodes are more complicated and may need more work.. - ***********************************************************************/ -int dev_remove(devnm_p devnmp) /*proto*/ -{ - devnm_p alias; - DBPRINT(("dev_remove\n")); - /* - * Check the type of the node.. for now don't allow dirs - */ - switch(devnmp->dnp->type) - { - case DEV_BDEV: - case DEV_CDEV: - case DEV_DDEV: - case DEV_ALIAS: - case DEV_SLNK: - break; - case DEV_DIR: - default: - return(EINVAL); - } - /* - * Free each alias - * Remember, aliases can't have front nodes - */ - while ( alias = devnmp->as.back.aliases) - { - devnmp->as.back.aliases = alias->dnp->by.Alias.next; - devfs_dn_free(alias->dnp); - free (alias, M_DEVFSNAME); - } - /* - * Now remove front items of the Main node itself - */ - devfs_remove_fronts(devnmp); - - /* - * now we should free the main node - */ - devfs_dn_free(devnmp->dnp); - free (devnmp, M_DEVFSNAME); - return 0; -} - +/***************************************************************\ +* DEV_NODE reference count manipulations.. when a ref count * +* reaches 0, the node is to be deleted * +\***************************************************************/ int dev_touch(devnm_p key) /* update the node for this dev */ /*proto*/ { DBPRINT(("dev_touch\n")); TIMEVAL_TO_TIMESPEC(&time,&(key->dnp->mtime)) return 0; /*XXX*/ } void devfs_dn_free(dn_p dnp) /*proto*/ { if(dnp->links <= 0) { printf("devfs node reference count bogus\n"); Debugger("devfs_dn_free"); return; } if(--dnp->links == 0 ) { + /*probably need to do other cleanups XXX */ devfs_dropvnode(dnp); free (dnp, M_DEVFSNODE); } } /***********************************************************************\ -* UTILITY routine: * -* Return the major number for the cdevsw entry containing the given * -* address. * -\***********************************************************************/ -int get_cdev_major_num(caddr_t addr) /*proto*/ -{ - int index = 0; - - DBPRINT(("get_cdev_major_num\n")); - while (index < nchrdev) - { - if(((caddr_t)(cdevsw[index].d_open) == addr) - ||((caddr_t)(cdevsw[index].d_read) == addr) - ||((caddr_t)(cdevsw[index].d_ioctl) == addr)) - { - return index; - } - index++; - } - return -1; -} - -int get_bdev_major_num(caddr_t addr) /*proto*/ -{ - int index = 0; - - DBPRINT(("get_bdev_major_num\n")); - while (index < nblkdev) - { - if(((caddr_t)(bdevsw[index].d_open) == addr) - ||((caddr_t)(bdevsw[index].d_strategy) == addr) - ||((caddr_t)(bdevsw[index].d_ioctl) == addr)) - { - return index; - } - index++; - } - return -1; -} - -/***********************************************************************\ -* Add the named device entry into the given directory, and make it * -* The appropriate type... (called (sometimes indirectly) by drivers..) * -\***********************************************************************/ -void *dev_add(char *path, - char *name, - void *funct, - int minor, - int chrblk, - uid_t uid, - gid_t gid, - int perms) -{ - devnm_p new_dev; - dn_p dnp; /* devnode for parent directory */ - int retval; - int major ; - union typeinfo by; - - DBPRINT(("dev_add\n")); - retval = dev_finddir(path,NULL,1,&dnp); - if (retval) return 0; - switch(chrblk) - { - case DV_CHR: - major = get_cdev_major_num(funct); - by.Cdev.cdevsw = cdevsw + major; - by.Cdev.dev = makedev(major, minor); - if( dev_add_node(name, dnp, NULL, DEV_CDEV, - &by,&new_dev)) - return 0; - break; - case DV_BLK: - major = get_bdev_major_num(funct); - by.Bdev.bdevsw = bdevsw + major; - by.Bdev.dev = makedev(major, minor); - if( dev_add_node(name, dnp, NULL, DEV_BDEV, - &by, &new_dev)) - return 0; - break; - default: - return(0); - } - new_dev->dnp->gid = gid; - new_dev->dnp->uid = uid; - new_dev->dnp->mode |= perms; - return new_dev; -} - - -/***********************************************************************\ * Front Node Operations * +* Add or delete a chain of front nodes * \***********************************************************************/ /***********************************************************************\ * Given a directory backing node, and a child backing node, add the * * appropriate front nodes to the front nodes of the directory to * * represent the child node to the user * * * * on failure, front nodes will either be correct or not exist for each * * front dir, however dirs completed will not be stripped of completed * * frontnodes on failure of a later frontnode * * * +* This allows a new node to be propogated through all mounted planes * +* * \***********************************************************************/ int devfs_add_fronts(devnm_p parent,devnm_p child) /*proto*/ { devnm_p newnmp; devnm_p falias; int type = child->dnp->type; DBPRINT((" devfs_add_fronts\n")); /***********************************************\ * Find the frontnodes of the parent node * \***********************************************/ for (falias = parent->next_front; falias; falias = falias->next_front) { if(dev_findname(falias->dnp,child->name)) { printf("Device %s not created, already exists\n", child->name); continue; } - if (dev_add_node(child->name,parent->dnp,child, + if (dev_add_name(child->name,parent->dnp,child, type,NULL,&newnmp)) { printf("Device %s: allocation failed\n", child->name); continue; } } return(0); /* for now always succeed */ } + + + + +/*********************************************************************** + * remove all instances of this devicename [for backing nodes..] + * note.. if there is another link to the node (non dir nodes only) + * then the devfs_node will still exist as the ref count will be non-0 + * removing a directory node will remove all sup-nodes on all planes (ZAP) + * + * Used be device drivers to remove nodes that are no longer relevant + ***********************************************************************/ +void dev_remove_dev(devnm_p devnmp) /*proto*/ +{ + DBPRINT(("dev_remove_dev\n")); + /* + * Keep removing the next front node till no more exist + */ + while(devnmp->next_front) + { + dev_free_name(devnmp->next_front); + } + /* + * then free the main node + */ + dev_free_name(devnmp); + return ; +} -/***************************************************************\ -* Search down the linked list off a dir to find "name" * -* return the dn_p for that node. -\***************************************************************/ -dn_p dev_findname(dn_p dir,char *name) /*proto*/ +/*************************************************************** + * duplicate the backing tree into a tree of nodes hung off the + * mount point given as the argument. Do this by + * calling dev_dup_name which recurses all the way + * up the tree.. + * If we are the first plane, just return the base root + **************************************************************/ +int dev_dup_plane(struct devfsmount *devfs_mp_p) /*proto*/ { - devnm_p newfp; - DBPRINT((" dev_findname(%s)\n",name)); - if(dir->type != DEV_DIR) return 0;/*XXX*/ /* printf?*/ + devnm_p new; + int error = 0; - if(name[0] == '.') - { - if(name[1] == 0) - { - return dir; + DBPRINT((" dev_dup_plane\n")); + if(devfs_up_and_going) { + if(error = dev_dup_name(NULL, dev_root, &new, devfs_mp_p)) { + return error; } - if((name[1] == '.') && (name[2] == 0)) - { - return dir->by.Dir.parent; /* for root, .. == . */ - } + } else { /* we are doing the dummy mount during initialisation.. */ + new = dev_root; } - newfp = dir->by.Dir.dirlist; - while(newfp) - { - if(!(strcmp(name,newfp->name))) - return newfp->dnp; - newfp = newfp->next; - } - return (dn_p)0; + devfs_mp_p->plane_root = new; + + return error; } + + + +/***************************************************************\ +* Free a whole plane +\***************************************************************/ +void devfs_free_plane(struct devfsmount *devfs_mp_p) /*proto*/ +{ + devnm_p devnmp; + + DBPRINT((" devfs_free_plane\n")); + devnmp = devfs_mp_p->plane_root; + if(devnmp) dev_free_name(devnmp); + devfs_mp_p->plane_root = NULL; +} /***************************************************************\ * Create and link in a new front element.. * * Parent can be 0 for a root node * * Not presently usable to make a symlink XXX * -* Must teach this to handle where there is no back node * -* maybe split into two bits? * +* recursively will create subnodes corresponding to equivalent * +* child nodes in the base level * \***************************************************************/ -int dev_mk_front(dn_p parent, devnm_p back, devnm_p *dnm_pp, struct devfsmount *dvm) /*proto*/ +int dev_dup_name(dn_p parent, devnm_p back, devnm_p *dnm_pp, struct devfsmount *dvm) /*proto*/ { devnm_p newnmp; struct devfsmount *dmt; devnm_p newback; devnm_p newfront; int error; dn_p dnp = back->dnp; - DBPRINT((" dev_mk_front\n")); + DBPRINT((" dev_dup_name\n")); /* * go get the node made */ - error = dev_add_node(back->name,parent,back,dnp->type,NULL,&newnmp); + error = dev_add_name(back->name,parent,back,dnp->type,NULL,&newnmp); if ( error ) return error; /* * If we have just made the root, then insert the pointer to the * mount information */ if(dvm) { newnmp->dnp->dvm = dvm; } /* * If it is a directory, then recurse down all the other * subnodes in it.... * note that this time we don't pass on the mount info.. */ if ( newnmp->dnp->type == DEV_DIR) { for(newback = back->dnp->by.Dir.dirlist; newback; newback = newback->next) { - if(error = dev_mk_front(newnmp->dnp, + if(error = dev_dup_name(newnmp->dnp, newback, &newfront, NULL)) { break; /* back out with an error */ } } } *dnm_pp = newnmp; return error; } -/* - * duplicate the backing tree into a tree of nodes hung off the - * mount point given as the argument. Do this by - * calling dev_mk_front() which recurses all the way - * up the tree.. - */ -int devfs_make_plane(struct devfsmount *devfs_mp_p) /*proto*/ -{ - devnm_p new; - int error = 0; - - DBPRINT((" devfs_make_plane\n")); - if(devfs_up_and_going) { - if(error = dev_mk_front(NULL, dev_root, &new, devfs_mp_p)) { - return error; - } - } else { /* we are doing the dummy mount during initialisation.. */ - new = dev_root; - } - devfs_mp_p->plane_root = new; - - return error; -} - -void devfs_free_plane(struct devfsmount *devfs_mp_p) /*proto*/ -{ - devnm_p devnmp; - - DBPRINT((" devfs_free_plane\n")); - devnmp = devfs_mp_p->plane_root; - if(devnmp) dev_free_name(devnmp); - devfs_mp_p->plane_root = NULL; -} -/* - * Remove all the front nodes associated with a backing node - */ -void devfs_remove_fronts(devnm_p devnmp) /*proto*/ -{ - while(devnmp->next_front) - { - dev_free_name(devnmp->next_front); - } -} - /***************************************************************\ -* Free a front node (and any below it of it's a directory node) * +* Free a name node (and any below it of it's a directory node) * +* remember that if there are other names pointing to the * +* dev_node then it may not get freed yet * \***************************************************************/ void dev_free_name(devnm_p devnmp) /*proto*/ { dn_p parent = devnmp->parent; devnm_p back; DBPRINT((" dev_free_name\n")); if(devnmp->dnp->type == DEV_DIR) { while(devnmp->dnp->by.Dir.dirlist) { dev_free_name(devnmp->dnp->by.Dir.dirlist); } /* * drop the reference counts on our and our parent's * nodes for "." and ".." (root has ".." -> "." ) */ devfs_dn_free(devnmp->dnp); /* account for '.' */ devfs_dn_free(devnmp->dnp->by.Dir.parent); /* and '..' */ /* should only have one reference left (from name element) */ } /* * unlink ourselves from the directory on this plane */ if(parent) /* if not fs root */ { if( *devnmp->prevp = devnmp->next)/* yes, assign */ { devnmp->next->prevp = devnmp->prevp; } else { parent->by.Dir.dirlast = devnmp->prevp; } parent->by.Dir.entrycount--; parent->len -= strlen(devnmp->name) + 8; } /* * If the node has a backing pointer we need to free ourselves * from that.. * Remember that we may not HAVE a backing node. */ if (back = devnmp->as.front.realthing) /* yes an assign */ { if( *devnmp->prev_frontp = devnmp->next_front)/* yes, assign */ { devnmp->next_front->prev_frontp = devnmp->prev_frontp; } else { back->prev_frontp = devnmp->prev_frontp; } } /***************************************************************\ * If the front node has it's own devnode structure, * * then free it. * \***************************************************************/ devfs_dn_free(devnmp->dnp); free(devnmp,M_DEVFSNAME); return; } /*******************************************************\ +********************************************************* +* ROUTINES to control the connection between devfs * +* nodes and the system's vnodes * +********************************************************* +\*******************************************************/ + +/*******************************************************\ * Theoretically this could be called for any kind of * * vnode, however in practice it must be a DEVFS vnode * \*******************************************************/ int devfs_vntodn(struct vnode *vn_p, dn_p *dn_pp) /*proto*/ { DBPRINT((" vntodn ")); if(vn_p->v_tag != VT_DEVFS) { printf("bad-tag "); Debugger("bad-tag "); return(EINVAL); } if(vn_p->v_usecount == 0) { printf("not locked! "); } if((vn_p->v_type == VBAD) || (vn_p->v_type == VNON)) { printf("bad-type "); return(EINVAL); } *dn_pp = (dn_p)vn_p->v_data; return(0); } /***************************************************************\ * given a dev_node, find the appropriate vnode if one is already* * associated, or get a new one an associate it with the dev_node* * need to check about vnode references.. should we increment it?* \***************************************************************/ int devfs_dntovn(dn_p dnp, struct vnode **vn_pp) /*proto*/ { struct vnode *vn_p, *nvp; int error = 0; vn_p = dnp->vn; DBPRINT(("dntovn ")); if( vn_p) { if(vn_p->v_id != dnp->vn_id) { printf("bad-id "); goto skip; } if(vn_p->v_tag != VT_DEVFS) { printf("bad-tag "); goto skip; } if(vn_p->v_op != *(dnp->ops)) { printf("bad-ops "); goto skip; } if((dn_p)(vn_p->v_data) != dnp) { printf("bad-rev_link "); goto skip; } if(vn_p->v_type != VNON) { vget(vn_p,0/*lockflag ?*/); /*XXX*/ *vn_pp = vn_p; return(0); } else { printf("bad-type"); } skip: vn_p = (struct vnode *) 0; } if(!(error = getnewvnode(VT_DEVFS, dnp->dvm->mount, *(dnp->ops), &vn_p))) { dnp->vn = vn_p; dnp->vn_id = vn_p->v_id; *vn_pp = vn_p; DBPRINT(("(New vnode)")); switch(dnp->type) { case DEV_SLNK: break; case DEV_DIR: if(dnp->by.Dir.parent == dnp) { vn_p->v_flag |= VROOT; } vn_p->v_type = VDIR; break; case DEV_BDEV: vn_p->v_type = VBLK; if (nvp = checkalias(vn_p, dnp->by.Bdev.dev, (struct mount *)0)) { vput(vn_p); vn_p = nvp; } break; case DEV_CDEV: vn_p->v_type = VCHR; if (nvp = checkalias(vn_p, dnp->by.Cdev.dev, (struct mount *)0)) { vput(vn_p); vn_p = nvp; } break; case DEV_DDEV: break; } if ( vn_p) { vn_p->v_mount = dnp->dvm->mount;/* XXX Duplicated */ *vn_pp = vn_p; vn_p->v_data = (void *)dnp; } else { error = EINVAL; } } return error; } + +/***********************************************************************\ +* UTILITY routine: * +* Return the major number for the cdevsw entry containing the given * +* address. * +\***********************************************************************/ +int get_cdev_major_num(caddr_t addr) /*proto*/ +{ + int index = 0; + + DBPRINT(("get_cdev_major_num\n")); + while (index < nchrdev) + { + if(((caddr_t)(cdevsw[index].d_open) == addr) + ||((caddr_t)(cdevsw[index].d_read) == addr) + ||((caddr_t)(cdevsw[index].d_ioctl) == addr)) + { + return index; + } + index++; + } + return -1; +} + +int get_bdev_major_num(caddr_t addr) /*proto*/ +{ + int index = 0; + + DBPRINT(("get_bdev_major_num\n")); + while (index < nblkdev) + { + if(((caddr_t)(bdevsw[index].d_open) == addr) + ||((caddr_t)(bdevsw[index].d_strategy) == addr) + ||((caddr_t)(bdevsw[index].d_ioctl) == addr)) + { + return index; + } + index++; + } + return -1; +} + +/***********************************************************************\ +* Add the named device entry into the given directory, and make it * +* The appropriate type... (called (sometimes indirectly) by drivers..) * +\***********************************************************************/ +void *dev_add(char *path, + char *name, + void *funct, + int minor, + int chrblk, + uid_t uid, + gid_t gid, + int perms) +{ + devnm_p new_dev; + dn_p dnp; /* devnode for parent directory */ + int retval; + int major ; + union typeinfo by; + + DBPRINT(("dev_add\n")); + retval = dev_finddir(path,NULL,1,&dnp); + if (retval) return 0; + switch(chrblk) + { + case DV_CHR: + major = get_cdev_major_num(funct); + by.Cdev.cdevsw = cdevsw + major; + by.Cdev.dev = makedev(major, minor); + if( dev_add_name(name, dnp, NULL, DEV_CDEV, + &by,&new_dev)) + return 0; + break; + case DV_BLK: + major = get_bdev_major_num(funct); + by.Bdev.bdevsw = bdevsw + major; + by.Bdev.dev = makedev(major, minor); + if( dev_add_name(name, dnp, NULL, DEV_BDEV, + &by, &new_dev)) + return 0; + break; + default: + return(0); + } + new_dev->dnp->gid = gid; + new_dev->dnp->uid = uid; + new_dev->dnp->mode |= perms; + return new_dev; +} + Index: head/sys/miscfs/devfs/devfs_vfsops.c =================================================================== --- head/sys/miscfs/devfs/devfs_vfsops.c (revision 10597) +++ head/sys/miscfs/devfs/devfs_vfsops.c (revision 10598) @@ -1,235 +1,235 @@ /* * Written by Julian Elischer (julian@DIALix.oz.au) * - * $Header: /home/ncvs/src/sys/miscfs/devfs/devfs_vfsops.c,v 1.4 1995/09/03 05:43:42 julian Exp $ + * $Header: /home/ncvs/src/sys/miscfs/devfs/devfs_vfsops.c,v 1.5 1995/09/06 09:29:17 julian Exp $ * * */ #include "param.h" #include "systm.h" #include "namei.h" #include "proc.h" #include "kernel.h" #include "vnode.h" #include "miscfs/specfs/specdev.h" /* defines v_rdev */ #include "mount.h" #include "buf.h" #include "file.h" #include "malloc.h" #include "devfsdefs.h" int devfs_init(void) /*proto*/ { printf("devfs ready to run\n"); return 0; /*XXX*/ } /* * mp - pointer to 'mount' structure * path - addr in user space of mount point (ie /usr or whatever) * data - addr in user space of mount params including the * name of the block special file to treat as a filesystem. * ndp - namei data pointer * p - proc pointer * devfs is special in that it doesn't require any device to be mounted.. * It makes up it's data as it goes along. * it must be mounted during single user.. until it is, only std{in/out/err} * and the root filesystem are available. */ int devfs_mount( struct mount *mp, char *path, caddr_t data, struct nameidata *ndp, struct proc *p) /*proto*/ { struct devfsmount *devfs_mp_p; /* devfs specific mount control block */ int error; u_int size; DBPRINT(("mount ")); /* * If they just want to update, we don't need to do anything. */ if (mp->mnt_flag & MNT_UPDATE) { return 0; } /* * Well, it's not an update, it's a real mount request. * Time to get dirty. * HERE we should check to see if we are already mounted here. */ if(error = mountdevfs( mp, p)) return (error); /* * Copy in the name of the directory the filesystem * is to be mounted on. * And we clear the remainder of the character strings * to be tidy. * Then, we try to fill in the filesystem stats structure * as best we can with whatever we can think of at the time */ devfs_mp_p = (struct devfsmount *)mp->mnt_data; if(devfs_up_and_going) { copyinstr(path, (caddr_t)mp->mnt_stat.f_mntonname, sizeof(mp->mnt_stat.f_mntonname)-1, &size); bzero(mp->mnt_stat.f_mntonname + size, sizeof(mp->mnt_stat.f_mntonname) - size); } else { bcopy("dummy_mount", (caddr_t)mp->mnt_stat.f_mntonname,12); } bzero(mp->mnt_stat.f_mntfromname , MNAMELEN ); bcopy("devfs",mp->mnt_stat.f_mntfromname, 5); (void)devfs_statfs(mp, &mp->mnt_stat, p); return 0; } int mountdevfs( struct mount *mp, struct proc *p) /*proto*/ { int error = 0; int ronly = (mp->mnt_flag & MNT_RDONLY) != 0; struct devfsmount *devfs_mp_p; devfs_mp_p = (struct devfsmount *)malloc(sizeof *devfs_mp_p, M_DEVFSMNT, M_WAITOK); bzero(devfs_mp_p,sizeof(*devfs_mp_p)); devfs_mp_p->mount = mp; /* * Fill out some fields */ mp->mnt_data = (qaddr_t)devfs_mp_p; mp->mnt_stat.f_type = MOUNT_DEVFS; mp->mnt_stat.f_fsid.val[0] = (long)devfs_mp_p; mp->mnt_stat.f_fsid.val[1] = MOUNT_DEVFS; mp->mnt_flag |= MNT_LOCAL; - if(error = devfs_make_plane(devfs_mp_p)) + if(error = dev_dup_plane(devfs_mp_p)) { mp->mnt_data = (qaddr_t)0; free((caddr_t)devfs_mp_p, M_DEVFSMNT); } return error; } int devfs_start(struct mount *mp, int flags, struct proc *p) /*proto*/ { DBPRINT(("start ")); return 0; } /* * Unmount the filesystem described by mp. * Note: vnodes from this FS may hang around if being used.. * This should not be a problem, they should be self contained. */ int devfs_unmount( struct mount *mp, int mntflags, struct proc *p) /*proto*/ { int flags = 0; int error = 0; struct devfsmount *devfs_mp_p = (struct devfsmount *)mp->mnt_data; DBPRINT(("unmount ")); devfs_free_plane(devfs_mp_p); free((caddr_t)devfs_mp_p, M_DEVFSMNT); mp->mnt_data = (qaddr_t)0; mp->mnt_flag &= ~MNT_LOCAL; return error; } /* return the address of the root vnode in *vpp */ int devfs_root(struct mount *mp, struct vnode **vpp) /*proto*/ { struct devfsmount *devfs_mp_p = (struct devfsmount *)(mp->mnt_data); DBPRINT(("root ")); devfs_dntovn(devfs_mp_p->plane_root->dnp,vpp); return 0; } int devfs_quotactl( struct mount *mp, int cmds, uid_t uid, caddr_t arg, struct proc *p) /*proto*/ { DBPRINT(("quotactl ")); return EOPNOTSUPP; } int devfs_statfs( struct mount *mp, struct statfs *sbp, struct proc *p) /*proto*/ { struct devfsmount *devfs_mp_p = (struct devfsmount *)mp->mnt_data; /* * Fill in the stat block. */ DBPRINT(("statfs ")); sbp->f_type = MOUNT_DEVFS; sbp->f_flags = 0; /* XXX */ sbp->f_bsize = 128; sbp->f_iosize = 1024; /* XXX*/ sbp->f_blocks = 128; sbp->f_bfree = 0; sbp->f_bavail = 0; sbp->f_files = 128; sbp->f_ffree = 0; /* what to put in here? */ sbp->f_fsid.val[0] = (long)devfs_mp_p; sbp->f_fsid.val[1] = MOUNT_DEVFS; /* * Copy the mounted on and mounted from names into * the passed in stat block, if it is not the one * in the mount structure. */ if (sbp != &mp->mnt_stat) { bcopy((caddr_t)mp->mnt_stat.f_mntonname, (caddr_t)&sbp->f_mntonname[0], MNAMELEN); bcopy((caddr_t)mp->mnt_stat.f_mntfromname, (caddr_t)&sbp->f_mntfromname[0], MNAMELEN); } return 0; } int devfs_sync(struct mount *mp, int waitfor,struct ucred *cred,struct proc *p) /*proto*/ { DBPRINT(("sync ")); return 0; } int devfs_vget(struct mount *mp, ino_t ino,struct vnode **vpp) /*proto*/ { DBPRINT(("vget ")); return EOPNOTSUPP; } /************************************************************* * The concept of exporting a kernel generated devfs is stupid * So don't handle filehandles */ int devfs_fhtovp (struct mount *mp, struct fid *fhp, struct mbuf *nam, struct vnode **vpp, int *exflagsp, struct ucred **credanonp) /*proto*/ { DBPRINT(("fhtovp ")); return (EINVAL); } int devfs_vptofh (struct vnode *vp, struct fid *fhp) /*proto*/ { DBPRINT(("vptofh ")); return (EINVAL); } struct vfsops devfs_vfsops = { devfs_mount, devfs_start, devfs_unmount, devfs_root, devfs_quotactl, devfs_statfs, devfs_sync, devfs_vget, devfs_fhtovp, devfs_vptofh, devfs_init }; VFS_SET(devfs_vfsops, devfs, MOUNT_DEVFS, 0); Index: head/sys/miscfs/devfs/devfs_vnops.c =================================================================== --- head/sys/miscfs/devfs/devfs_vnops.c (revision 10597) +++ head/sys/miscfs/devfs/devfs_vnops.c (revision 10598) @@ -1,1394 +1,1396 @@ /* * Written by Julian Elischer (julian@DIALix.oz.au) * - * $Header: /home/ncvs/src/sys/miscfs/devfs/devfs_vnops.c,v 1.9 1995/09/06 09:29:18 julian Exp $ + * $Header: /home/ncvs/src/sys/miscfs/devfs/devfs_vnops.c,v 1.10 1995/09/06 23:15:54 julian Exp $ * * symlinks can wait 'til later. */ #include #include #include #include /* defines plimit structure in proc struct */ #include #include /* define FWRITE ... */ #include #include #include #include #include #include /* definitions of spec functions we use */ #include #include /* defines dirent structure */ /*#include "vnode_if.h"*/ /* must be included elsewhere (vnode.h?)*/ #include "devfsdefs.h" /* * Insert description here */ /* * Convert a component of a pathname into a pointer to a locked devfs_front. * This is a very central and rather complicated routine. * If the file system is not maintained in a strict tree hierarchy, * this can result in a deadlock situation (see comments in code below). * * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on * whether the name is to be looked up, created, renamed, or deleted. * When CREATE, RENAME, or DELETE is specified, information usable in * creating, renaming, or deleting a directory entry may be calculated. * If flag has LOCKPARENT or'ed into it and the target of the pathname * exists, lookup returns both the target and its parent directory locked. * When creating or renaming and LOCKPARENT is specified, the target may * not be ".". When deleting and LOCKPARENT is specified, the target may * be "."., but the caller must check to ensure it does an vrele and DNUNLOCK * instead of two DNUNLOCKs. * * Overall outline of devfs_lookup: * * check accessibility of directory * null terminate the component (lookup leaves the whole string alone) * look for name in cache, if found, then if at end of path * and deleting or creating, drop it, else return name * search for name in directory, to found or notfound * notfound: * if creating, return locked directory, * else return error * found: * if at end of path and deleting, return information to allow delete * if at end of path and rewriting (RENAME and LOCKPARENT), lock target * devfs_front and return info to allow rewrite * if not at end, add name to cache; if at end and neither creating * nor deleting, add name to cache * On return to lookup, remove the null termination we put in at the start. * * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent devfs_front unlocked. */ int devfs_lookup(struct vop_lookup_args *ap) /*proto*/ /*struct vop_lookup_args { struct vnode * a_dvp; directory vnode ptr struct vnode ** a_vpp; where to put the result struct componentname * a_cnp; the name we want };*/ { struct componentname *cnp = ap->a_cnp; struct vnode *dir_vnode = ap->a_dvp; struct vnode **result_vnode = ap->a_vpp; dn_p dir_node; /* the directory we are searching */ dn_p new_node; /* the node we are searching for */ int flags = cnp->cn_flags; int op = cnp->cn_nameiop; /* LOOKUP, CREATE, RENAME, or DELETE */ int lockparent = flags & LOCKPARENT; int wantparent = flags & (LOCKPARENT|WANTPARENT); int error = 0; struct proc *p = cnp->cn_proc; char heldchar; /* the char at the end of the name componet */ *result_vnode = NULL; /* safe not sorry */ /*XXX*/ DBPRINT(("lookup\n")); if(devfs_vntodn(dir_vnode,&dir_node)) { printf("vnode has changed?\n"); vprint("=",dir_vnode); return(EINVAL); } /* * Check accessiblity of directory. */ if (dir_node->type != DEV_DIR) { return (ENOTDIR); } if (error = VOP_ACCESS(dir_vnode, VEXEC, cnp->cn_cred, cnp->cn_proc)) { return (error); } /* * We now have a segment name to search for, and a directory to search. * * Before tediously performing a linear scan of the directory, * check the name cache to see if the directory/name pair * we are looking for is known already. */ #ifdef NOT_AT_THE_MOMENT if (error = cache_lookup(dir_vnode, result_vnode, cnp)) { int vpid; /* capability number of vnode */ if (error == ENOENT) return (error); DBPRINT(("cached ")); /* * Claim the next vnode in the path. * See comment below starting `Step through' for * an explaination of the locking protocol. */ if(devfs_vntodn(*result_vnode,&new_node)) { printf("vnode has changed!?\n"); vprint("=",*result_vnode); return(EINVAL); } vpid = (*result_vnode)->v_id; if (dir_node == new_node) { /* is "." */ VREF(*result_vnode); /* not a full vget() */ error = 0; } else if (flags & ISDOTDOT) {/* do a locking dance */ VOP_UNLOCK(dir_vnode); error = vget(*result_vnode,1); if (!error && lockparent && (flags & ISLASTCN)) VOP_LOCK(dir_vnode); } else { error = vget(*result_vnode,1); if (!lockparent || error || !(flags & ISLASTCN)) VOP_UNLOCK(dir_vnode); } /* * Check that the capability number did not change * while we were waiting for the lock. */ if (!error) { if (vpid == (*result_vnode)->v_id) return (0); /* SUCCCESS, return! */ vput((*result_vnode)); /* pretend we failed */ if (lockparent && (dir_node != new_node) && (flags & ISLASTCN)) VOP_UNLOCK(dir_vnode); } if( error = VOP_LOCK(dir_vnode)) return error; *result_vnode = NULL; /* safe not sorry */ DBPRINT(("errr, maybe not cached ")); } #endif /***********************************************************************\ * SEARCH FOR NAME * * while making sure the component is null terminated for the strcmp * \***********************************************************************/ heldchar = cnp->cn_nameptr[cnp->cn_namelen]; cnp->cn_nameptr[cnp->cn_namelen] = '\0'; new_node = dev_findname(dir_node,cnp->cn_nameptr); cnp->cn_nameptr[cnp->cn_namelen] = heldchar; if(new_node) { goto found; } /***********************************************************************\ * Failed to find it.. (That may be good) * \***********************************************************************/ /* notfound: */ /*XXX*/ /* possibly release some resources here */ /* * If creating, and at end of pathname * then can consider * allowing file to be created. * XXX original code (ufs_lookup) checked for . being deleted */ if ((op == CREATE || op == RENAME) && (flags & ISLASTCN)) { /* * Access for write is interpreted as allowing * creation of files in the directory. */ if (error = VOP_ACCESS(dir_vnode, VWRITE, cnp->cn_cred, cnp->cn_proc)) { DBPRINT(("MKACCESS ")); return (error); } dir_node->flags |= IUPD|ICHG;/*XXX*/ /* * We return with the directory locked, so that * the parameters we set up above will still be * valid if we actually decide to do a direnter(). * We return ni_vp == NULL to indicate that the entry * does not currently exist; we leave a pointer to * the (locked) directory devfs_front in namei_data->ni_dvp. * The pathname buffer is saved so that the name * can be obtained later. * * NB - if the directory is unlocked, then this * information cannot be used. */ cnp->cn_flags |= SAVENAME; if (!lockparent) VOP_UNLOCK(dir_vnode); /* DON't make a cache entry... status changing */ return (EJUSTRETURN); } /* * Insert name into cache (as non-existent) if appropriate. */ if ((cnp->cn_flags & MAKEENTRY) && op != CREATE) cache_enter(dir_vnode, *result_vnode, cnp); DBPRINT(("NOT\n")); return (ENOENT); /***********************************************************************\ * Found it.. this is not always a good thing.. * \***********************************************************************/ found: /*XXX*/ /* possibly release some resources here */ /* * If deleting, and at end of pathname, return * parameters which can be used to remove file. * If the wantparent flag isn't set, we return only * the directory (in namei_data->ni_dvp), otherwise we go * on and lock the devfs_front, being careful with ".". */ if (op == DELETE && (flags & ISLASTCN)) { /* * Write access to directory required to delete files. */ if (error = VOP_ACCESS(dir_vnode, VWRITE, cnp->cn_cred, cnp->cn_proc)) return (error); /* */ if (dir_node == new_node) { VREF(dir_vnode); *result_vnode = dir_vnode; return (0); } /* * If directory is "sticky", then user must own * the directory, or the file in it, else she * may not delete it (unless she's root). This * implements append-only directories. */ devfs_dntovn(new_node,result_vnode); VOP_LOCK((*result_vnode)); #ifdef NOTYET if ((dir_node->mode & ISVTX) && cnp->cn_cred->cr_uid != 0 && cnp->cn_cred->cr_uid != dir_node->uid && new_node->uid != cnp->cn_cred->cr_uid) { VOP_UNLOCK((*result_vnode)); return (EPERM); } #endif if (!lockparent) VOP_UNLOCK(dir_vnode); return (0); } /* * If rewriting (RENAME), return the devfs_front and the * information required to rewrite the present directory * Must get devfs_front of directory entry to verify it's a * regular file, or empty directory. */ if (op == RENAME && wantparent && (flags & ISLASTCN)) { if (error = VOP_ACCESS(dir_vnode, VWRITE, cnp->cn_cred, cnp->cn_proc)) return (error); /* * Careful about locking second devfs_front. * This can only occur if the target is ".". */ if (dir_node == new_node) return (EISDIR); devfs_dntovn(new_node,result_vnode); VOP_LOCK(*result_vnode); cnp->cn_flags |= SAVENAME; if (!lockparent) VOP_UNLOCK(dir_vnode); return (0); } /* * Step through the translation in the name. We do not `DNUNLOCK' the * directory because we may need it again if a symbolic link * is relative to the current directory. Instead we save it * unlocked as "saved_dir_node" XXX. We must get the target * devfs_front before unlocking * the directory to insure that the devfs_front will not be removed * before we get it. We prevent deadlock by always fetching * devfs_fronts from the root, moving down the directory tree. Thus * when following backward pointers ".." we must unlock the * parent directory before getting the requested directory. * There is a potential race condition here if both the current * and parent directories are removed before the `DNLOCK' for the * devfs_front associated with ".." returns. We hope that this occurs * infrequently since we cannot avoid this race condition without * implementing a sophisticated deadlock detection algorithm. * Note also that this simple deadlock detection scheme will not * work if the file system has any hard links other than ".." * that point backwards in the directory structure. */ if (flags & ISDOTDOT) { VOP_UNLOCK(dir_vnode); /* race to get the devfs_front */ devfs_dntovn(new_node,result_vnode); VOP_LOCK(*result_vnode); if (lockparent && (flags & ISLASTCN)) VOP_LOCK(dir_vnode); } else if (dir_node == new_node) { VREF(dir_vnode); /* we want ourself, ie "." */ *result_vnode = dir_vnode; } else { devfs_dntovn(new_node,result_vnode); VOP_LOCK(*result_vnode); if (!lockparent || (flags & ISLASTCN)) VOP_UNLOCK(dir_vnode); } /* * Insert name into cache if appropriate. */ if (cnp->cn_flags & MAKEENTRY) cache_enter(dir_vnode, *result_vnode, cnp); DBPRINT(("GOT\n")); return (0); } /* * Create a regular file. * We must also free the pathname buffer pointed at * by ndp->ni_pnbuf, always on error, or only if the * SAVESTART bit in ni_nameiop is clear on success. * * * Always error... no such thing in this FS */ int devfs_create(struct vop_mknod_args *ap) /*proto*/ /*struct vop_mknod_args { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ { DBPRINT(("create\n")); return EINVAL; } int devfs_mknod( struct vop_mknod_args *ap) /*proto*/ /*struct vop_mknod_args { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ { int error; DBPRINT(("mknod\n")); switch (ap->a_vap->va_type) { case VDIR: #ifdef VNSLEAZE return devfs_mkdir(ap); /*XXX check for WILLRELE settings (different)*/ #else error = VOP_MKDIR(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap); #endif break; /* * devfs_create() sets ndp->ni_vp. */ case VREG: #ifdef VNSLEAZE return devfs_create(ap); /*XXX check for WILLRELE settings (different)*/ #else error = VOP_CREATE(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap); #endif break; default: return EINVAL; break; } return error; } int devfs_open(struct vop_open_args *ap) /*proto*/ /*struct vop_open_args { struct vnode *a_vp; int a_mode; struct ucred *a_cred; struct proc *a_p; } */ { DBPRINT(("open\n")); return 0; } int devfs_close( struct vop_close_args *ap) /*proto*/ /*struct vop_close_args { struct vnode *a_vp; int a_fflag; struct ucred *a_cred; struct proc *a_p; } */ { DBPRINT(("close\n")); return 0; } int devfs_access(struct vop_access_args *ap) /*proto*/ /*struct vop_access_args { struct vnode *a_vp; int a_mode; struct ucred *a_cred; struct proc *a_p; } */ { /* * mode is filled with a combination of VREAD, VWRITE, * and/or VEXEC bits turned on. In an octal number these * are the Y in 0Y00. */ struct vnode *vp = ap->a_vp; int mode = ap->a_mode; struct ucred *cred = ap->a_cred; struct proc *p = ap->a_p; dn_p file_node; int error; gid_t *gp; int i; DBPRINT(("access\n")); if (error = devfs_vntodn(vp,&file_node)) { printf("devfs_vntodn returned %d ",error); return error; } /* * Root gets to do anything. */ if (cred->cr_uid == 0) return 0; /* * Access check is based on only one of owner, group, public. * If not owner, then check group. If not a member of the * group, then check public access. */ if (cred->cr_uid != file_node->uid) { /* failing that.. try groups */ mode >>= 3; gp = cred->cr_groups; for (i = 0; i < cred->cr_ngroups; i++, gp++) { if (file_node->gid == *gp) { goto found; } } /* failing that.. try general access */ mode >>= 3; found: ; } if ((file_node->mode & mode) == mode) return (0); return (EACCES); } int devfs_getattr(struct vop_getattr_args *ap) /*proto*/ /*struct vop_getattr_args { struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; struct proc *a_p; } */ { struct vnode *vp = ap->a_vp; struct vattr *vap = ap->a_vap; struct ucred *cred = ap->a_cred; struct proc *p = ap->a_p; dn_p file_node; int error; DBPRINT(("getattr\n")); if (error = devfs_vntodn(vp,&file_node)) { printf("devfs_vntodn returned %d ",error); return error; } vap->va_rdev = 0;/* default value only */ vap->va_mode = file_node->mode; switch (file_node->type) { case DEV_DIR: vap->va_rdev = (dev_t)file_node->dvm; vap->va_mode |= (S_IFDIR); break; case DEV_CDEV: vap->va_rdev = file_node->by.Cdev.dev; vap->va_mode |= (S_IFCHR); break; case DEV_BDEV: vap->va_rdev = file_node->by.Bdev.dev; vap->va_mode |= (S_IFBLK); break; case DEV_SLNK: break; } vap->va_type = vp->v_type; vap->va_nlink = file_node->links; vap->va_uid = file_node->uid; vap->va_gid = file_node->gid; vap->va_fsid = (long)file_node->dvm; vap->va_fileid = (long)file_node; vap->va_size = file_node->len; /* now a u_quad_t */ vap->va_blocksize = 512; if(file_node->ctime.ts_sec) { vap->va_ctime = file_node->ctime; } else { TIMEVAL_TO_TIMESPEC(&boottime,&(vap->va_ctime)); } if(file_node->mtime.ts_sec) { vap->va_mtime = file_node->mtime; } else { TIMEVAL_TO_TIMESPEC(&boottime,&(vap->va_mtime)); } if(file_node->atime.ts_sec) { vap->va_atime = file_node->atime; } else { TIMEVAL_TO_TIMESPEC(&boottime,&(vap->va_atime)); } vap->va_gen = 0; vap->va_flags = 0; vap->va_bytes = file_node->len; /* u_quad_t */ vap->va_filerev = 0; /* XXX */ /* u_quad_t */ vap->va_vaflags = 0; /* XXX */ return 0; } int devfs_setattr(struct vop_setattr_args *ap) /*proto*/ /*struct vop_setattr_args { struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; struct proc *a_p; } */ { struct vnode *vp = ap->a_vp; struct vattr *vap = ap->a_vap; struct ucred *cred = ap->a_cred; struct proc *p = ap->a_p; int error = 0; dn_p file_node; if (error = devfs_vntodn(vp,&file_node)) { printf("devfs_vntodn returned %d ",error); return error; } DBPRINT(("setattr\n")); if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || (vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL) || (vap->va_atime.ts_sec != VNOVAL)) { return EINVAL; } if (vap->va_size != VNOVAL) { return error; /*XXX (?) */ } if (vap->va_atime.ts_sec != VNOVAL) { file_node->atime = vap->va_atime; } if (vap->va_mtime.ts_sec != VNOVAL) { file_node->mtime = vap->va_mtime; } if (vap->va_ctime.ts_sec != VNOVAL) { file_node->ctime = vap->va_ctime; } if (vap->va_mode != (u_short)VNOVAL) { /* set drwxwxrwx stuff */ file_node->mode &= ~07777; file_node->mode |= vap->va_mode & 07777; } if (vap->va_uid != (uid_t)VNOVAL) { file_node->uid = vap->va_uid; } if (vap->va_gid != (gid_t)VNOVAL) { file_node->gid = vap->va_gid; } if (vap->va_flags != VNOVAL) { if (error = suser(cred, &p->p_acflag)) return error; if (cred->cr_uid == 0) ; else { } } return error; } int devfs_read(struct vop_read_args *ap) /*proto*/ /*struct vop_read_args { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; struct ucred *a_cred; } */ { int eof; int error = 0; dn_p file_node; DBPRINT(("read\n")); if (error = devfs_vntodn(ap->a_vp,&file_node)) { printf("devfs_vntodn returned %d ",error); return error; } switch (ap->a_vp->v_type) { case VREG: return(EINVAL); case VDIR: - return VOP_READDIR(ap->a_vp,ap->a_uio,ap->a_cred); + return VOP_READDIR(ap->a_vp,ap->a_uio,ap->a_cred, + NULL,NULL,NULL); case VCHR: case VBLK: error = spec_read(ap); TIMEVAL_TO_TIMESPEC(&time,&(file_node->atime)) return(error); default: panic("devfs_read(): bad file type"); break; } } /* * Write data to a file or directory. */ int devfs_write(struct vop_write_args *ap) /*proto*/ /*struct vop_write_args { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; struct ucred *a_cred; } */ { dn_p file_node; int error; if (error = devfs_vntodn(ap->a_vp,&file_node)) { printf("devfs_vntodn returned %d ",error); return error; } DBPRINT(("write\n")); switch (ap->a_vp->v_type) { case VREG: return(EINVAL); case VDIR: return(EISDIR); case VCHR: case VBLK: error = spec_write(ap); TIMEVAL_TO_TIMESPEC(&time,&(file_node->mtime)) return(error); default: panic("devfs_write(): bad file type"); break; } } int devfs_ioctl(struct vop_ioctl_args *ap) /*proto*/ /*struct vop_ioctl_args { struct vnode *a_vp; int a_command; caddr_t a_data; int a_fflag; struct ucred *a_cred; struct proc *a_p; } */ { DBPRINT(("ioctl\n")); return ENOTTY; } int devfs_select(struct vop_select_args *ap) /*proto*/ /*struct vop_select_args { struct vnode *a_vp; int a_which; int a_fflags; struct ucred *a_cred; struct proc *a_p; } */ { DBPRINT(("select\n")); return 1; /* DOS filesystems never block? */ } int devfs_mmap(struct vop_mmap_args *ap) /*proto*/ /*struct vop_mmap_args { struct vnode *a_vp; int a_fflags; struct ucred *a_cred; struct proc *a_p; } */ { DBPRINT(("mmap\n")); return EINVAL; } /* * Flush the blocks of a file to disk. */ int devfs_fsync(struct vop_fsync_args *ap) /*proto*/ /*struct vop_fsync_args { struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; struct proc *a_p; } */ { DBPRINT(("fsync\n")); return(0); } int devfs_seek(struct vop_seek_args *ap) /*proto*/ /*struct vop_seek_args { struct vnode *a_vp; off_t a_oldoff; off_t a_newoff; struct ucred *a_cred; } */ { int error = 0; DBPRINT(("seek\n")); return 0; } int devfs_remove(struct vop_remove_args *ap) /*proto*/ /*struct vop_remove_args { struct vnode *a_dvp; struct vnode *a_vp; struct componentname *a_cnp; } */ { int error = 0; /*vrele(DETOV(dep));*/ DBPRINT(("remove\n")); return error; } /* */ int devfs_link(struct vop_link_args *ap) /*proto*/ /*struct vop_link_args { struct vnode *a_tdvp; struct vnode *a_vp; struct componentname *a_cnp; } */ { DBPRINT(("link\n")); return 0; } int devfs_rename(struct vop_rename_args *ap) /*proto*/ /*struct vop_rename_args { struct vnode *a_fdvp; struct vnode *a_fvp; struct componentname *a_fcnp; struct vnode *a_tdvp; struct vnode *a_tvp; struct componentname *a_tcnp; } */ { DBPRINT(("rename\n")); return 0; } int devfs_mkdir(struct vop_mkdir_args *ap) /*proto*/ /*struct vop_mkdir_args { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ { DBPRINT(("mkdir\n")); return EINVAL; } int devfs_rmdir(struct vop_rmdir_args *ap) /*proto*/ /*struct vop_rmdir_args { struct vnode *a_dvp; struct vnode *a_vp; struct componentname *a_cnp; } */ { DBPRINT(("rmdir\n")); return 0; } int devfs_symlink(struct vop_symlink_args *ap) /*proto*/ /*struct vop_symlink_args { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; char *a_target; } */ { return EINVAL; DBPRINT(("symlink\n")); } /* * Vnode op for readdir */ int devfs_readdir(struct vop_readdir_args *ap) /*proto*/ /*struct vop_readdir_args { struct vnode *a_vp; struct uio *a_uio; struct ucred *a_cred; + int *eofflag; + int *ncookies; + u_int **cookies; } */ { struct vnode *vp = ap->a_vp; struct uio *uio = ap->a_uio; struct ucred *cred = ap->a_cred; struct dirent dirent; dn_p dir_node; devnm_p name_node; char *name; int error = 0; int reclen; int nodenumber; int startpos,pos; DBPRINT(("readdir\n")); /* set up refs to dir */ if (error = devfs_vntodn(vp,&dir_node)) return error; if(dir_node->type != DEV_DIR) return(ENOTDIR); pos = 0; startpos = uio->uio_offset; name_node = dir_node->by.Dir.dirlist; nodenumber = 0; TIMEVAL_TO_TIMESPEC(&time,&(dir_node->atime)) while ((name_node || (nodenumber < 2)) && (uio->uio_resid > 0)) { switch(nodenumber) { case 0: dirent.d_fileno = (unsigned long int)dir_node; name = "."; dirent.d_namlen = 1; dirent.d_type = DT_DIR; break; case 1: if(dir_node->by.Dir.parent) dirent.d_fileno = (unsigned long int)dir_node->by.Dir.parent; else dirent.d_fileno = (unsigned long int)dir_node; name = ".."; dirent.d_namlen = 2; dirent.d_type = DT_DIR; break; default: dirent.d_fileno = (unsigned long int)name_node->dnp; dirent.d_namlen = strlen(name_node->name); name = name_node->name; switch(name_node->dnp->type) { case DEV_BDEV: dirent.d_type = DT_BLK; break; case DEV_CDEV: dirent.d_type = DT_CHR; break; case DEV_DDEV: dirent.d_type = DT_SOCK; /*XXX*/ break; case DEV_DIR: dirent.d_type = DT_DIR; break; case DEV_SLNK: dirent.d_type = DT_LNK; break; default: dirent.d_type = DT_UNKNOWN; } } reclen = dirent.d_reclen = DIRSIZ (&dirent); if(pos >= startpos) /* made it to the offset yet? */ { if (uio->uio_resid < reclen) /* will it fit? */ break; strcpy( dirent.d_name,name); if (error = uiomove ((caddr_t)&dirent, dirent.d_reclen, uio)) break; } pos += reclen; if((nodenumber >1) && name_node) name_node = name_node->next; nodenumber++; } uio->uio_offset = pos; return (error); } /* */ int devfs_readlink(struct vop_readlink_args *ap) /*proto*/ /*struct vop_readlink_args { struct vnode *a_vp; struct uio *a_uio; struct ucred *a_cred; } */ { DBPRINT(("readlink\n")); return 0; } int devfs_abortop(struct vop_abortop_args *ap) /*proto*/ /*struct vop_abortop_args { struct vnode *a_dvp; struct componentname *a_cnp; } */ { DBPRINT(("abortop\n")); return 0; } int devfs_inactive(struct vop_inactive_args *ap) /*proto*/ /*struct vop_inactive_args { struct vnode *a_vp; } */ { DBPRINT(("inactive\n")); return 0; } int devfs_lock(struct vop_lock_args *ap) /*proto*/ { DBPRINT(("lock\n")); return 0; } int devfs_unlock( struct vop_unlock_args *ap) /*proto*/ { DBPRINT(("unlock\n")); return 0; } int devfs_islocked(struct vop_islocked_args *ap) /*proto*/ /*struct vop_islocked_args { struct vnode *a_vp; } */ { DBPRINT(("islocked\n")); return 0; } int devfs_bmap(struct vop_bmap_args *ap) /*proto*/ /*struct vop_bmap_args { struct vnode *a_vp; daddr_t a_bn; struct vnode **a_vpp; daddr_t *a_bnp; int *a_runp; int *a_runb; } */ { DBPRINT(("bmap\n")); return 0; } int devfs_strategy(struct vop_strategy_args *ap) /*proto*/ /*struct vop_strategy_args { struct buf *a_bp; } */ { struct vnode *vp; int error; DBPRINT(("strategy\n")); if (ap->a_bp->b_vp->v_type == VBLK || ap->a_bp->b_vp->v_type == VCHR) printf("devfs_strategy: spec"); return 0; } int devfs_advlock(struct vop_advlock_args *ap) /*proto*/ /*struct vop_advlock_args { struct vnode *a_vp; caddr_t a_id; int a_op; struct flock *a_fl; int a_flags; } */ { DBPRINT(("advlock\n")); return EINVAL; /* we don't do locking yet */ } int devfs_reclaim(struct vop_reclaim_args *ap) /*proto*/ /*struct vop_reclaim_args { struct vnode *a_vp; } */ { dn_p file_node; int error; DBPRINT(("reclaim\n")); if (error = devfs_vntodn(ap->a_vp,&file_node)) { printf("devfs_vntodn returned %d ",error); return error; } file_node->vn = 0; file_node->vn_id = 0; return(0); } /* * Return POSIX pathconf information applicable to special devices. */ int devfs_pathconf(struct vop_pathconf_args *ap) /*proto*/ /*struct vop_pathconf_args { struct vnode *a_vp; int a_name; int *a_retval; } */ { switch (ap->a_name) { case _PC_LINK_MAX: *ap->a_retval = LINK_MAX; return (0); case _PC_MAX_CANON: *ap->a_retval = MAX_CANON; return (0); case _PC_MAX_INPUT: *ap->a_retval = MAX_INPUT; return (0); case _PC_PIPE_BUF: *ap->a_retval = PIPE_BUF; return (0); case _PC_CHOWN_RESTRICTED: *ap->a_retval = 1; return (0); case _PC_VDISABLE: *ap->a_retval = _POSIX_VDISABLE; return (0); default: return (EINVAL); } /* NOTREACHED */ } /* * Print out the contents of a /devfs vnode. */ /* ARGSUSED */ int devfs_print(struct vop_print_args *ap) /*proto*/ /*struct vop_print_args { struct vnode *a_vp; } */ { printf("tag VT_DEVFS, devfs vnode\n"); return (0); } int devfs_vfree(struct vop_vfree_args *ap) /*proto*/ /*struct vop_vfree_args { struct vnode *a_pvp; ino_t a_ino; int a_mode; } */ { return (0); } /**************************************************************************\ * pseudo ops * \**************************************************************************/ /* * /devfs vnode unsupported operation */ int devfs_enotsupp(void *junk) /*proto*/ { return (EOPNOTSUPP); } /* * /devfs "should never get here" operation */ int devfs_badop(void *junk) /*proto*/ { panic("devfs: bad op"); /* NOTREACHED */ } /* * devfs vnode null operation */ int devfs_nullop(void *junk) /*proto*/ { return (0); } void devfs_dropvnode(dn_p dnp) /*proto*/ { struct vnode *vn_p; +#ifdef PARANOID if(!dnp) { printf("devfs: dn count dropped too early\n"); } +#endif vn_p = dnp->vn; - if(!vn_p) - { - printf("devfs: vn count dropped too early\n"); - } /* * check if we have a vnode....... */ if((vn_p) && ( dnp->vn_id == vn_p->v_id) && (dnp == (dn_p)vn_p->v_data)) { vgoneall(vn_p); } dnp->vn = NULL; /* be pedantic about this */ } #define devfs_create ((int (*) __P((struct vop_create_args *)))devfs_enotsupp) #define devfs_mknod ((int (*) __P((struct vop_mknod_args *)))devfs_enotsupp) #define devfs_close ((int (*) __P((struct vop_close_args *)))nullop) #define devfs_ioctl ((int (*) __P((struct vop_ioctl_args *)))devfs_enotsupp) #define devfs_select ((int (*) __P((struct vop_select_args *)))devfs_enotsupp) #define devfs_mmap ((int (*) __P((struct vop_mmap_args *)))devfs_enotsupp) #define devfs_fsync ((int (*) __P((struct vop_fsync_args *)))nullop) #define devfs_seek ((int (*) __P((struct vop_seek_args *)))nullop) #define devfs_remove ((int (*) __P((struct vop_remove_args *)))devfs_enotsupp) #define devfs_link ((int (*) __P((struct vop_link_args *)))devfs_enotsupp) #define devfs_rename ((int (*) __P((struct vop_rename_args *)))devfs_enotsupp) #define devfs_mkdir ((int (*) __P((struct vop_mkdir_args *)))devfs_enotsupp) #define devfs_rmdir ((int (*) __P((struct vop_rmdir_args *)))devfs_enotsupp) #define devfs_symlink ((int (*) __P((struct vop_symlink_args *)))devfs_enotsupp) #define devfs_readlink \ ((int (*) __P((struct vop_readlink_args *)))devfs_enotsupp) #define devfs_abortop ((int (*) __P((struct vop_abortop_args *)))nullop) #define devfs_lock ((int (*) __P((struct vop_lock_args *)))nullop) #define devfs_unlock ((int (*) __P((struct vop_unlock_args *)))nullop) #define devfs_bmap ((int (*) __P((struct vop_bmap_args *)))devfs_badop) #define devfs_strategy ((int (*) __P((struct vop_strategy_args *)))devfs_badop) #define devfs_islocked ((int (*) __P((struct vop_islocked_args *)))nullop) #define devfs_advlock ((int (*) __P((struct vop_advlock_args *)))devfs_enotsupp) #define devfs_blkatoff \ ((int (*) __P((struct vop_blkatoff_args *)))devfs_enotsupp) #define devfs_valloc ((int(*) __P(( \ struct vnode *pvp, \ int mode, \ struct ucred *cred, \ struct vnode **vpp))) devfs_enotsupp) #define devfs_truncate \ ((int (*) __P((struct vop_truncate_args *)))devfs_enotsupp) #define devfs_update ((int (*) __P((struct vop_update_args *)))devfs_enotsupp) #define devfs_bwrite ((int (*) __P((struct vop_bwrite_args *)))devfs_enotsupp) /* These are the operations used by directories etc in a devfs */ int (**devfs_vnodeop_p)(void *); struct vnodeopv_entry_desc devfs_vnodeop_entries[] = { { &vop_default_desc, vn_default_error }, { &vop_lookup_desc, devfs_lookup }, /* lookup */ { &vop_create_desc, devfs_create }, /* create */ { &vop_mknod_desc, devfs_mknod }, /* mknod */ { &vop_open_desc, devfs_open }, /* open */ { &vop_close_desc, devfs_close }, /* close */ { &vop_access_desc, devfs_access }, /* access */ { &vop_getattr_desc, devfs_getattr }, /* getattr */ { &vop_setattr_desc, devfs_setattr }, /* setattr */ { &vop_read_desc, devfs_read }, /* read */ { &vop_write_desc, devfs_write }, /* write */ { &vop_ioctl_desc, devfs_ioctl }, /* ioctl */ { &vop_select_desc, devfs_select }, /* select */ { &vop_mmap_desc, devfs_mmap }, /* mmap */ { &vop_fsync_desc, devfs_fsync }, /* fsync */ { &vop_seek_desc, devfs_seek }, /* seek */ { &vop_remove_desc, devfs_remove }, /* remove */ { &vop_link_desc, devfs_link }, /* link */ { &vop_rename_desc, devfs_rename }, /* rename */ { &vop_mkdir_desc, devfs_mkdir }, /* mkdir */ { &vop_rmdir_desc, devfs_rmdir }, /* rmdir */ { &vop_symlink_desc, devfs_symlink }, /* symlink */ { &vop_readdir_desc, devfs_readdir }, /* readdir */ { &vop_readlink_desc, devfs_readlink }, /* readlink */ { &vop_abortop_desc, devfs_abortop }, /* abortop */ { &vop_inactive_desc, devfs_inactive }, /* inactive */ { &vop_reclaim_desc, devfs_reclaim }, /* reclaim */ { &vop_lock_desc, devfs_lock }, /* lock */ { &vop_unlock_desc, devfs_unlock }, /* unlock */ { &vop_bmap_desc, devfs_bmap }, /* bmap */ { &vop_strategy_desc, devfs_strategy }, /* strategy */ { &vop_print_desc, devfs_print }, /* print */ { &vop_islocked_desc, devfs_islocked }, /* islocked */ { &vop_pathconf_desc, devfs_pathconf }, /* pathconf */ { &vop_advlock_desc, devfs_advlock }, /* advlock */ { &vop_blkatoff_desc, devfs_blkatoff }, /* blkatoff */ { &vop_valloc_desc, devfs_valloc }, /* valloc */ { &vop_vfree_desc, devfs_vfree }, /* vfree */ { &vop_truncate_desc, devfs_truncate }, /* truncate */ { &vop_update_desc, devfs_update }, /* update */ { &vop_bwrite_desc, devfs_bwrite }, /* bwrite */ { (struct vnodeop_desc*)NULL, (int(*)(void *))NULL } }; struct vnodeopv_desc devfs_vnodeop_opv_desc = { &devfs_vnodeop_p, devfs_vnodeop_entries }; VNODEOP_SET(devfs_vnodeop_opv_desc); /*copied in from specfs/spec_vnops.c.. (spot the changes )*/ /* These are the operations used by special devices in a devfs */ /* * Copyright (c) 1989, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)spec_vnops.c 8.6 (Berkeley) 4/9/94 * spec_vnops.c,v 1.9 1994/11/14 13:22:52 bde Exp */ int (**dev_spec_vnodeop_p)(void *); struct vnodeopv_entry_desc dev_spec_vnodeop_entries[] = { { &vop_default_desc, vn_default_error }, { &vop_lookup_desc, spec_lookup }, /* lookup */ { &vop_create_desc, spec_create }, /* create */ { &vop_mknod_desc, spec_mknod }, /* mknod */ { &vop_open_desc, spec_open }, /* open */ { &vop_close_desc, spec_close }, /* close */ { &vop_access_desc, devfs_access }, /* access */ { &vop_getattr_desc, devfs_getattr }, /* getattr */ { &vop_setattr_desc, devfs_setattr }, /* setattr */ { &vop_read_desc, spec_read }, /* read */ { &vop_write_desc, spec_write }, /* write */ { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ { &vop_select_desc, spec_select }, /* select */ { &vop_mmap_desc, spec_mmap }, /* mmap */ { &vop_fsync_desc, spec_fsync }, /* fsync */ { &vop_seek_desc, spec_seek }, /* seek */ { &vop_remove_desc, spec_remove }, /* remove */ { &vop_link_desc, spec_link }, /* link */ { &vop_rename_desc, spec_rename }, /* rename */ { &vop_mkdir_desc, spec_mkdir }, /* mkdir */ { &vop_rmdir_desc, spec_rmdir }, /* rmdir */ { &vop_symlink_desc, spec_symlink }, /* symlink */ { &vop_readdir_desc, spec_readdir }, /* readdir */ { &vop_readlink_desc, spec_readlink }, /* readlink */ { &vop_abortop_desc, spec_abortop }, /* abortop */ { &vop_inactive_desc, spec_inactive }, /* inactive */ { &vop_reclaim_desc, spec_reclaim }, /* reclaim */ { &vop_lock_desc, spec_lock }, /* lock */ { &vop_unlock_desc, spec_unlock }, /* unlock */ { &vop_bmap_desc, spec_bmap }, /* bmap */ { &vop_strategy_desc, spec_strategy }, /* strategy */ { &vop_print_desc, spec_print }, /* print */ { &vop_islocked_desc, spec_islocked }, /* islocked */ { &vop_pathconf_desc, spec_pathconf }, /* pathconf */ { &vop_advlock_desc, spec_advlock }, /* advlock */ { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */ { &vop_valloc_desc, spec_valloc }, /* valloc */ { &vop_vfree_desc, spec_vfree }, /* vfree */ { &vop_truncate_desc, spec_truncate }, /* truncate */ { &vop_update_desc, spec_update }, /* update */ { &vop_bwrite_desc, spec_bwrite }, /* bwrite */ { (struct vnodeop_desc*)NULL, (int(*)(void *))NULL } }; struct vnodeopv_desc dev_spec_vnodeop_opv_desc = { &dev_spec_vnodeop_p, dev_spec_vnodeop_entries }; VNODEOP_SET(dev_spec_vnodeop_opv_desc);