diff options
Diffstat (limited to 'sys')
| -rw-r--r-- | sys/miscfs/devfs/devfs_back.c | 500 | ||||
| -rw-r--r-- | sys/miscfs/devfs/devfs_front.c | 481 | ||||
| -rw-r--r-- | sys/miscfs/devfs/devfs_proto.h | 31 | ||||
| -rw-r--r-- | sys/miscfs/devfs/devfs_vfsops.c | 234 | ||||
| -rw-r--r-- | sys/miscfs/devfs/devfs_vnops.c | 1362 | ||||
| -rw-r--r-- | sys/miscfs/devfs/devfsdefs.h | 195 | ||||
| -rw-r--r-- | sys/miscfs/devfs/reproto.sh | 2 |
7 files changed, 2805 insertions, 0 deletions
diff --git a/sys/miscfs/devfs/devfs_back.c b/sys/miscfs/devfs/devfs_back.c new file mode 100644 index 0000000..718f740 --- /dev/null +++ b/sys/miscfs/devfs/devfs_back.c @@ -0,0 +1,500 @@ + +/* + * Written by Julian Elischer (julian@DIALix.oz.au) + * + * $Header: /sys/miscfs/devfs/RCS/devfs_back.c,v 1.3 1995/01/07 04:20:25 root Exp root $ + */ + +#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" + + + +devb_p dev_root; /* root of the backing tree */ +int devfs_set_up = 0; /* note tha we HAVE set up the backing tree */ + +/* + * 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_back_init() /*proto*/ +{ + + devb_p devbp; + dn_p dnp; + /* + * This may be called several times.. only do it if it needs + * to be done. + */ + if(!devfs_set_up) + { + /* + * Allocate and fill out a new backing node + */ + if(!(devbp = (devb_p)malloc(sizeof(devb_t), + M_DEVFSBACK, M_NOWAIT))) + { + return ; + } + bzero(devbp,sizeof(devb_t)); + /* + * And the devnode associated with it + */ + if(!(dnp = (dn_p)malloc(sizeof(devnode_t), + M_DEVFSNODE, M_NOWAIT))) + { + free(devbp,M_DEVFSBACK); + return ; + } + bzero(dnp,sizeof(devnode_t)); + /* + * Link the two together + */ + devbp->dnp = dnp; + dnp->links = 1; + /* + * set up the directory node for the root + * and put in all the usual entries for a directory node + */ + dnp->type = DEV_DIR; + dnp->links++; /* for .*/ + /* root loops to self */ + dnp->by.BackDir.parent = dnp; + dnp->links++; /* for ..*/ + /* + * set up the list of children (none so far) + */ + dnp->by.BackDir.dirlist = (devb_p)0; + dnp->by.BackDir.dirlast = + &dnp->by.BackDir.dirlist; + dnp->by.BackDir.myname = devbp; + /* + * set up a pointer to directory type ops + */ + dnp->ops = &devfs_vnodeop_p; + dnp->mode |= 0555; /* default perms */ + /* + * note creation times etc, as now (boot time) + */ + TIMEVAL_TO_TIMESPEC(&time,&(dnp->ctime)) + dnp->mtime = dnp->ctime; + dnp->atime = dnp->ctime; + + /* + * and the list of layers + */ + devbp->fronts = NULL; + devbp->lastfront = &(devbp->fronts); + + + /* + * next time, we don't need to do all this + */ + dev_root = devbp; + devfs_set_up = 1; + } +} + +/***********************************************************************\ +* 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. * +* Generally, this MUST be the first function called by any module * +* as it also calls the initial setup code, in case it has never been * +* done yet. * +* 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*/ +{ + devb_p devbp; + char pathbuf[DEVMAXPATHSIZE]; + char *path; + char *name; + register char *cp; + int retval; + + + DBPRINT(("dev_finddir\n")); + devfs_back_init(); /* in case we are the first */ + if(!dirnode) dirnode = dev_root->dnp; + 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 * + \***************************************/ + devbp = dirnode->by.BackDir.dirlist; + while(devbp && strcmp(devbp->name,name)) + { + devbp = devbp->next; + } + if(devbp) + { /* check it's a directory */ + if(devbp->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 ,DEV_DIR, + NULL, &devbp)) + { + return retval; + } + } + if(path) /* decide whether to recurse more or return */ + { + return (dev_finddir(path,devbp->dnp,create,dn_pp)); + } + else + { + *dn_pp = devbp->dnp; + return 0; + } +} + +/***********************************************************************\ +* Add a new element to the devfs backing structure. * +\***********************************************************************/ +int dev_add_node(char *name, dn_p dirnode, int entrytype, union typeinfo *by, devb_p *devb_pp) /*proto*/ +{ + devb_p devbp; + devb_p realthing; /* needed to create an alias */ + dn_p dnp; + int retval; + + DBPRINT(("dev_add_node\n")); + if(dirnode->type != DEV_DIR) return(ENOTDIR); + if(strlen(name) > (DEVMAXNAMESIZE - 1)) return (ENAMETOOLONG); + + retval = dev_finddir(name,dirnode,0,&dnp); /*don't create!*/ + dnp = NULL; /*just want the return code..*/ + if(retval != ENOENT) /* only acceptable answer */ + return(EEXIST); + /* + * Allocate and fill out a new backing node + */ + if(!(devbp = (devb_p)malloc(sizeof(devb_t), + M_DEVFSBACK, M_NOWAIT))) + { + return ENOMEM; + } + bzero(devbp,sizeof(devb_t)); + if(!(dnp = (dn_p)malloc(sizeof(devnode_t), + M_DEVFSNODE, M_NOWAIT))) + { + free(devbp,M_DEVFSBACK); + return ENOMEM; + } + bzero(dnp,sizeof(devnode_t)); + devbp->dnp = dnp; + dnp->links = 1; /* implicit from our own name-node */ + + /* + * note the node type we are adding + * and set the creation times to NOW + * put in it's name + * include the implicit link in the count of links to the devnode.. + * this stops it from being accidentally freed later. + */ + strcpy(devbp->name,name); + dnp->type = entrytype; + TIMEVAL_TO_TIMESPEC(&time,&(dnp->ctime)) + dnp->mtime = dnp->ctime; + dnp->atime = dnp->ctime; + + /* + * And set up a new 'clones' list (empty) + */ + devbp->lastfront = &(devbp->fronts); + + /* + * Put it on the END of the linked list of directory entries + */ + devbp->parent = dirnode; + devbp->prevp = dirnode->by.BackDir.dirlast; + devbp->next = *(devbp->prevp); /* should be NULL */ /*right?*/ + *(devbp->prevp) = devbp; + dirnode->by.BackDir.dirlast = &(devbp->next); + dirnode->by.BackDir.entrycount++; + + /* + * return the answer + */ + switch(entrytype) { + case DEV_DIR: + /* + * As it's a directory, make sure it has a null entries list + */ + dnp->by.BackDir.dirlast = + &(dnp->by.BackDir.dirlist); + dnp->by.BackDir.dirlist = (devb_p)0; + dnp->by.BackDir.parent = (dn_p)dirnode; + dnp->by.BackDir.myname = devbp; + /* + * 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; + 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->aliases; + realthing->aliases = devbp; + realthing->alias_count++; + break; + } + + if(retval = devfs_add_fronts(dirnode->by.BackDir.myname/*XXX*/,devbp)) + { + /*XXX*//* no idea what to do if it fails... */ + return retval; + } + + *devb_pp = devbp; + 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(devb_p devbp) /*proto*/ +{ + devb_p alias; + + DBPRINT(("dev_remove\n")); + /* + * Check the type of the node.. for now don't allow dirs + */ + switch(devbp->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 + */ + while ( devbp->alias_count) + { + alias = devbp->aliases; + devbp->aliases = alias->dnp->by.Alias.next; + devbp->alias_count--; + devfs_dn_free(alias->dnp); + free (alias, M_DEVFSBACK); + } + /* + * Now remove front items of the Main node itself + */ + devfs_remove_fronts(devbp); + + /* + * now we should free the main node + */ + devfs_dn_free(devbp->dnp); + free (devbp, M_DEVFSBACK); + return 0; +} + +int dev_touch(devb_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 ) + { + 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..) * +\***********************************************************************/ +devb_p dev_add(char *path,char *name,caddr_t funct,int minor,int chrblk,uid_t uid,gid_t gid, int perms) /*proto*/ +{ + devb_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 0: + major = get_cdev_major_num(funct); + by.Cdev.cdevsw = cdevsw + major; + by.Cdev.dev = makedev(major, minor); + if( dev_add_node(name, dnp, DEV_CDEV, + &by,&new_dev)) + return 0; + break; + case 1: + major = get_bdev_major_num(funct); + by.Bdev.bdevsw = bdevsw + major; + by.Bdev.dev = makedev(major, minor); + if( dev_add_node(name, dnp, 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; +} + + + diff --git a/sys/miscfs/devfs/devfs_front.c b/sys/miscfs/devfs/devfs_front.c new file mode 100644 index 0000000..ce2f7d7 --- /dev/null +++ b/sys/miscfs/devfs/devfs_front.c @@ -0,0 +1,481 @@ +/* + * Written by Julian Elischer (julian@DIALix.oz.au) + * + * $Header: /sys/miscfs/devfs/RCS/devfs_front.c,v 1.3 1995/01/07 04:20:25 root Exp root $ + * + */ + +#include "param.h" +#include "systm.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" + + + +/***********************************************************************\ +* 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 parent frontnode * +* * +\***********************************************************************/ +int devfs_add_fronts(devb_p parent,devb_p child) /*proto*/ +{ + devf_p newfp; + devf_p falias; + + DBPRINT((" devfs_add_fronts\n")); + /***********************************************\ + * Find the frontnodes of the parent node * + \***********************************************/ + for (falias = parent->fronts; falias; falias = falias->next_front) + { + if(dev_findfront(falias->dnp,child->name)) + { + printf("Device %s not created, already exists\n", + child->name); + continue; + } + if( dev_mk_front(falias->dnp,child,&newfp,NULL)) + { + printf("Device %s: allocation failed\n", + child->name); + continue; + } + + } + return(0); /* for now always succeed */ +} + +/***************************************************************\ +* Search down the linked list off a front dir to find "name" * +* return the dn_p for that node. +\***************************************************************/ +dn_p dev_findfront(dn_p dir,char *name) /*proto*/ +{ + devf_p newfp; + DBPRINT((" dev_findfront(%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)) + { + if(dir->by.Dir.parent == dir) /* root? */ + return dir; + else + return dir->by.Dir.parent; + } + } + newfp = dir->by.Dir.dirlist; + while(newfp) + { + if(!(strcmp(name,newfp->name))) + break; + newfp = newfp->next; + } + if(newfp) + return newfp->dnp; + else + return (dn_p)0; +} + +/***************************************************************\ +* 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? * +\***************************************************************/ +int dev_mk_front(dn_p parent,devb_p back,devf_p *devf_pp , struct devfsmount *dvm) /*proto*/ +{ + devf_p newfp; + struct devfsmount *dmt; + devb_p newback; + devf_p newfront; + int error; + + DBPRINT((" dev_mk_front\n")); + if(parent && (parent->type != DEV_DIR)) return EINVAL; + /*XXX*/ /* printf?*/ + if(!(newfp = malloc(sizeof(*newfp),M_DEVFSFRONT,M_NOWAIT))) + { + return(ENOMEM); + } + bzero(newfp,sizeof(*newfp)); + strcpy(newfp->name,back->name); + + /*******************************************************\ + * If we are creating an alias, Then we need to find the * + * real object's file_node. (It must pre-exist) * + * this means that aliases have no front nodes... * + * In effect ALIAS back nodes are just place markers * + * Check the removal code for this! XXX * + \*******************************************************/ + if(back->dnp->type == DEV_ALIAS) + { + back = back->dnp->by.Alias.realthing; + } + + /* + * either use the existing devnode or make our own, + * depending on if we are a dev or a dir. + */ + switch(back->dnp->type) { + case DEV_BDEV: + case DEV_CDEV: + case DEV_DDEV: + newfp->dnp = back->dnp; + newfp->dnp->links++; /* wherever it is.....*/ + break; + case DEV_DIR: + newfp->dnp = malloc(sizeof(devnode_t), + M_DEVFSNODE,M_NOWAIT); + if(!(newfp->dnp)) + { + free(newfp,M_DEVFSFRONT); + return ENOMEM; + } + /* + * we have two options.. bcopy and reset some items, + * or bzero and reset or copy some items... + */ + bcopy(back->dnp,newfp->dnp,sizeof(devnode_t)); + newfp->dnp->links = 1; /* EXTRA from '.' */ + newfp->dnp->links++; /* wherever it is.....*/ + newfp->dnp->by.Dir.dirlast = + &newfp->dnp->by.Dir.dirlist; + newfp->dnp->by.Dir.dirlist = NULL; + newfp->dnp->by.Dir.entrycount = 0; + newfp->dnp->vn = NULL; + newfp->dnp->vn_id = 0; + break; + case DEV_SLNK: /* should never happen */ + default: + printf("unknown DEV type\n"); + return EINVAL; + } + /*******************************************************\ + * Put it in the parent's directory list (at the end). * + \*******************************************************/ + if(parent) + { + newfp->next = *parent->by.Dir.dirlast; + newfp->prevp = parent->by.Dir.dirlast; + *parent->by.Dir.dirlast = newfp; + parent->by.Dir.dirlast = &newfp->next; + parent->by.Dir.entrycount++; + newfp->dnp->dvm = parent->dvm; /* XXX bad for devs */ + if(back->dnp->type == DEV_DIR) + { + newfp->dnp->by.Dir.parent + = parent; + parent->links++; /* only dirs have '..'*/ + } + parent->len += strlen(newfp->name) + 8;/*ok, ok?*/ + } else { + /* + * it's the root node, put in the dvm + * and link it to itself... + */ + newfp->dnp->by.Dir.parent = newfp->dnp; + newfp->dnp->links++; /* extra for '..'*/ + newfp->dnp->dvm = dvm; + } + + /* + * not accounted for in the link counts.. + * only used to get from the front name entries + * to the total length of the names + * which is stored in the parent's devnode + */ + newfp->parent = parent; /* is NULL for root */ + /*******************************************************\ + * Put it in the appropriate back/front list too. * + \*******************************************************/ + newfp->next_front = *back->lastfront; + newfp->prev_frontp = back->lastfront; + *back->lastfront = newfp; + back->lastfront = &(newfp->next_front); + back->frontcount++; + newfp->realthing = back; + + /* + * If it is a directory, then recurse down all the other + * subnodes in it.... + */ + if ( newfp->dnp->type == DEV_DIR) + { + for(newback = back->dnp->by.BackDir.dirlist; + newback; newback = newback->next) + { + if(error = dev_mk_front(newfp->dnp, + newback, &newfront, NULL)) + { + return error; + } + } + } + *devf_pp = newfp; + return(0); +} + +/* + * 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*/ +{ + devf_p parent; + devf_p new; + devb_p realthing; + int error; + + DBPRINT((" devfs_make_plane\n")); + realthing = dev_root; + if(error = dev_mk_front(0, realthing,&new, devfs_mp_p)) + { + return error; + } + devfs_mp_p->plane_root = new; + + return error; +} + +void devfs_free_plane(struct devfsmount *devfs_mp_p) /*proto*/ +{ + devf_p devfp; + + DBPRINT((" devfs_free_plane\n")); + devfp = devfs_mp_p->plane_root; + if(devfp) dev_free_front(devfp); +} + +/* + * Remove all the front nodes associated with a backing node + */ +void devfs_remove_fronts(devb_p devbp) /*proto*/ +{ + while(devbp->fronts) + { + dev_free_front(devbp->fronts); + } +} +/***************************************************************\ +* Free a front node (and any below it of it's a directory node) * +\***************************************************************/ +void dev_free_front(devf_p devfp) /*proto*/ +{ + dn_p parent = devfp->parent; + devb_p back; + + DBPRINT((" dev_free_front\n")); + if(devfp->dnp->type == DEV_DIR) + { + while(devfp->dnp->by.Dir.dirlist) + { + dev_free_front(devfp->dnp->by.Dir.dirlist); + } + /* + * drop the reference counts on our and our parent's + * nodes for "." and ".." (root has ".." -> "." ) + */ + devfs_dn_free(devfp->dnp); /* account for '.' */ + devfs_dn_free(devfp->dnp->by.Dir.parent); /* and '..' */ + } + /* + * unlink ourselves from the directory on this plane + */ + if(parent) /* if not fs root */ + { + if( *devfp->prevp = devfp->next)/* yes, assign */ + { + devfp->next->prevp = devfp->prevp; + } + else + { + parent->by.Dir.dirlast + = devfp->prevp; + } + parent->by.Dir.entrycount--; + parent->len -= strlen(devfp->name); + } + /* + * 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 = devfp->realthing) /* yes an assign */ + { + if( *devfp->prev_frontp = devfp->next_front)/* yes, assign */ + { + devfp->next_front->prev_frontp = devfp->prev_frontp; + } + else + { + back->lastfront = devfp->prev_frontp; + } + back->frontcount--; + } + /***************************************************************\ + * If the front node has it's own devnode structure, * + * then free it. * + \***************************************************************/ + devfs_dn_free(devfp->dnp); + free(devfp,M_DEVFSFRONT); + return; +} + +/*******************************************************\ +* 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); +} + +/***************************************************************\ +* Think about this: * +* Though this routine uses a front node, it also uses a backing * +* node indirectly, via the 'realthing' link. This may prove bad * +* in the case of a user-added slink, where there migh not be a * +* backing node. (e.g. if a slink points out of the fs it CAN'T * +* have a backing node, unlike a hardlink which does..) * +* we are going to have to think very carefully about slinks.. * +\***************************************************************/ +int devfs_dntovn(dn_p front, struct vnode **vn_pp) /*proto*/ +{ + struct vnode *vn_p, *nvp; + int error = 0; + + vn_p = front->vn; +DBPRINT(("dntovn ")); + if( vn_p) + { + if(vn_p->v_id != front->vn_id) + { + printf("bad-id "); + goto skip; + } + if(vn_p->v_tag != VT_DEVFS) + { + printf("bad-tag "); + goto skip; + } + if(vn_p->v_op != *(front->ops)) + { + printf("bad-ops "); + goto skip; + } + if((dn_p)(vn_p->v_data) != front) + { + 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, + front->dvm->mount, + *(front->ops), + &vn_p))) + { + front->vn = vn_p; + front->vn_id = vn_p->v_id; + *vn_pp = vn_p; +DBPRINT(("(New vnode)")); + switch(front->type) + { + case DEV_SLNK: + break; + case DEV_DIR: + if(front->by.Dir.parent == front) + { + vn_p->v_flag |= VROOT; + } + vn_p->v_type = VDIR; + break; + case DEV_BDEV: + vn_p->v_type = VBLK; + if (nvp = checkalias(vn_p, + front->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, + front->by.Cdev.dev, + (struct mount *)0)) + { + vput(vn_p); + vn_p = nvp; + } + break; + case DEV_DDEV: + break; + } + if ( vn_p) + { + vn_p->v_mount = front->dvm->mount;/* Duplicated */ + *vn_pp = vn_p; + vn_p->v_data = (void *)front; +/*XXX*/ /* maybe not.. I mean what if it's a dev... (vnode at back)*/ + } + else + { + error = EINVAL; + } + } + return(error); +} + diff --git a/sys/miscfs/devfs/devfs_proto.h b/sys/miscfs/devfs/devfs_proto.h new file mode 100644 index 0000000..6a08657 --- /dev/null +++ b/sys/miscfs/devfs/devfs_proto.h @@ -0,0 +1,31 @@ +void devfs_back_init() /*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, int entrytype, union typeinfo *by, devb_p *devb_pp) /*proto*/; +int dev_remove(devb_p devbp) /*proto*/; +int dev_touch(devb_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*/; +devb_p dev_add(char *path,char *name,caddr_t funct,int minor,int chrblk,uid_t uid,gid_t gid, int perms) /*proto*/; +int devfs_add_fronts(devb_p parent,devb_p child) /*proto*/; +dn_p dev_findfront(dn_p dir,char *name) /*proto*/; +int dev_mk_front(dn_p parent,devb_p back,devf_p *devf_pp , struct devfsmount *dvm) /*proto*/; +int devfs_make_plane(struct devfsmount *devfs_mp_p) /*proto*/; +void devfs_free_plane(struct devfsmount *devfs_mp_p) /*proto*/; +void devfs_remove_fronts(devb_p devbp) /*proto*/; +void dev_free_front(devf_p devfp) /*proto*/; +int devfs_vntodn(struct vnode *vn_p, dn_p *dn_pp) /*proto*/; +int devfs_dntovn(dn_p front, struct vnode **vn_pp) /*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*/; +void devfs_dropvnode(dn_p dnp) /*proto*/; diff --git a/sys/miscfs/devfs/devfs_vfsops.c b/sys/miscfs/devfs/devfs_vfsops.c new file mode 100644 index 0000000..96c34f44 --- /dev/null +++ b/sys/miscfs/devfs/devfs_vfsops.c @@ -0,0 +1,234 @@ +/* + * Written by Julian Elischer (julian@DIALix.oz.au) + * + * $Header: /sys/miscfs/devfs/RCS/devfs_vfsops.c,v 1.4 1995/01/07 04:20:25 root Exp root $ + * + * + */ + +#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 initialised\n"); + devfs_back_init(); + /* devfs_front_init();*/ /* nothing to do at the moment */ + 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; + 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); + 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)) + { + 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 denode *ndep; + 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); diff --git a/sys/miscfs/devfs/devfs_vnops.c b/sys/miscfs/devfs/devfs_vnops.c new file mode 100644 index 0000000..4fd330d6 --- /dev/null +++ b/sys/miscfs/devfs/devfs_vnops.c @@ -0,0 +1,1362 @@ +/* + * Written by Julian Elischer (julian@DIALix.oz.au) + * + * $Header: /sys/miscfs/devfs/RCS/devfs_vnops.c,v 1.3 1995/01/07 04:20:25 root Exp root $ + * + * symlinks can wait 'til later. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/resourcevar.h> /* defines plimit structure in proc struct */ +#include <sys/kernel.h> +#include <sys/file.h> /* define FWRITE ... */ +#include <sys/stat.h> +#include <sys/buf.h> +#include <sys/proc.h> +#include <sys/mount.h> +#include <sys/vnode.h> +/*#include <miscfs/specfs/specdev.h>*/ /* plimit structure in the proc struct */ +#include <sys/malloc.h> +#include <sys/dir.h> /* defines dirent structure */ +/*#include "vnode_if.h"*/ /* must be included elsewhere (vnode.h?)*/ +#include "devfsdefs.h" + +/*extern struct timeval time,boottime;*/ +/* + * 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(ap) + 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 + } */ *ap; +{ + 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_findfront(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. + * <still true in 4.4?> + * + * Always error... no such thing in this FS + */ +int devfs_create(ap) + struct vop_mknod_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ +DBPRINT(("create\n")); + return EINVAL; +} + +int devfs_mknod(ap) + struct vop_mknod_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ + 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(ap) + struct vop_open_args /* { + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ +DBPRINT(("open\n")); + return 0; +} + +int devfs_close(ap) + struct vop_close_args /* { + struct vnode *a_vp; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ +DBPRINT(("close\n")); + return 0; +} + +int devfs_access(ap) + struct vop_access_args /* { + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + /* + * 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(ap) + struct vop_getattr_args /* { + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + 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; + vap->va_atime = file_node->atime; + vap->va_mtime = file_node->mtime; + vap->va_ctime = file_node->ctime; + 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(ap) + struct vop_setattr_args /* { + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + 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(ap) + struct vop_read_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; +{ + 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); + 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(ap) + struct vop_write_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; +{ + 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(ap) + 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; + } */ *ap; +{ +DBPRINT(("ioctl\n")); + return ENOTTY; +} + +int devfs_select(ap) + struct vop_select_args /* { + struct vnode *a_vp; + int a_which; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ +DBPRINT(("select\n")); + return 1; /* DOS filesystems never block? */ +} + +int devfs_mmap(ap) + struct vop_mmap_args /* { + struct vnode *a_vp; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ +DBPRINT(("mmap\n")); + return EINVAL; +} + +/* + * Flush the blocks of a file to disk. + */ +int devfs_fsync(ap) + struct vop_fsync_args /* { + struct vnode *a_vp; + struct ucred *a_cred; + int a_waitfor; + struct proc *a_p; + } */ *ap; +{ +DBPRINT(("fsync\n")); + return(0); +} + +int devfs_seek(ap) + struct vop_seek_args /* { + struct vnode *a_vp; + off_t a_oldoff; + off_t a_newoff; + struct ucred *a_cred; + } */ *ap; +{ + int error = 0; +DBPRINT(("seek\n")); + return 0; +} + +int devfs_remove(ap) + struct vop_remove_args /* { + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; + } */ *ap; +{ + int error = 0; + /*vrele(DETOV(dep));*/ +DBPRINT(("remove\n")); + return error; +} + +/* + */ +int devfs_link(ap) + struct vop_link_args /* { + struct vnode *a_vp; + struct vnode *a_tdvp; + struct componentname *a_cnp; + } */ *ap; +{ +DBPRINT(("link\n")); + return 0; +} + +int devfs_rename(ap) + 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; + } */ *ap; +{ +DBPRINT(("rename\n")); + return 0; +} + + +int devfs_mkdir(ap) + struct vop_mkdir_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ +DBPRINT(("mkdir\n")); + return EINVAL; +} + +int devfs_rmdir(ap) + struct vop_rmdir_args /* { + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; + } */ *ap; +{ +DBPRINT(("rmdir\n")); + return 0; +} + +int devfs_symlink(ap) + struct vop_symlink_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + char *a_target; + } */ *ap; +{ + return EINVAL; +DBPRINT(("symlink\n")); +} + +/* + * Vnode op for readdir + */ +int devfs_readdir(ap) + struct vop_readdir_args /* { + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + } */ *ap; +{ + 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; + devf_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; + 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; + break; + default: + dirent.d_fileno = + (unsigned long int)name_node->dnp; + dirent.d_namlen = strlen(name_node->name); + name = name_node->name; + } + + 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(ap) + struct vop_readlink_args /* { + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + } */ *ap; +{ +DBPRINT(("readlink\n")); + return 0; +} + +int devfs_abortop(ap) + struct vop_abortop_args /* { + struct vnode *a_dvp; + struct componentname *a_cnp; + } */ *ap; +{ +DBPRINT(("abortop\n")); + return 0; +} + +int devfs_inactive(ap) + struct vop_inactive_args /* { + struct vnode *a_vp; + } */ *ap; +{ +DBPRINT(("inactive\n")); + return 0; +} +int devfs_lock(ap) + struct vop_lock_args *ap; +{ +DBPRINT(("lock\n")); + return 0; +} + +int devfs_unlock(ap) + struct vop_unlock_args *ap; +{ +DBPRINT(("unlock\n")); + return 0; +} + +int devfs_islocked(ap) + struct vop_islocked_args /* { + struct vnode *a_vp; + } */ *ap; +{ +DBPRINT(("islocked\n")); + return 0; +} + +int devfs_bmap(ap) + struct vop_bmap_args /* { + struct vnode *a_vp; + daddr_t a_bn; + struct vnode **a_vpp; + daddr_t *a_bnp; + int *a_runp; + } */ *ap; +{ +DBPRINT(("bmap\n")); + return 0; +} + +int devfs_strategy(ap) + struct vop_strategy_args /* { + struct buf *a_bp; + } */ *ap; +{ + 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(ap) + struct vop_advlock_args /* { + struct vnode *a_vp; + caddr_t a_id; + int a_op; + struct flock *a_fl; + int a_flags; + } */ *ap; +{ +DBPRINT(("advlock\n")); + return EINVAL; /* we don't do locking yet */ +} + +int devfs_reclaim(ap) + struct vop_reclaim_args /* { + struct vnode *a_vp; + } */ *ap; +{ + 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(ap) + struct vop_pathconf_args /* { + struct vnode *a_vp; + int a_name; + int *a_retval; + } */ *ap; +{ + + 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(ap) + struct vop_print_args /* { + struct vnode *a_vp; + } */ *ap; +{ + + printf("tag VT_DEVFS, devfs vnode\n"); + return (0); +} + +/*void*/ +int +devfs_vfree(ap) + struct vop_vfree_args /* { + struct vnode *a_pvp; + ino_t a_ino; + int a_mode; + } */ *ap; +{ + + return (0); +} + +/**************************************************************************\ +* pseudo ops * +\**************************************************************************/ + +/* + * /devfs vnode unsupported operation + */ +int +devfs_enotsupp() +{ + + return (EOPNOTSUPP); +} + +/* + * /devfs "should never get here" operation + */ +int +devfs_badop() +{ + + panic("devfs: bad op"); + /* NOTREACHED */ +} + +/* + * devfs vnode null operation + */ +int +devfs_nullop() +{ + + return (0); +} + + +void devfs_dropvnode(dn_p dnp) /*proto*/ +{ + struct vnode *vn_p; + + if(!dnp) + { + printf("devfs: dn count dropped too early\n"); + } + 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)(); +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(*)())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 + */ + +#include "../specfs/specdev.h" /* for all the definitions and prototypes */ + +int (**dev_spec_vnodeop_p)(); +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(*)())NULL } +}; +struct vnodeopv_desc dev_spec_vnodeop_opv_desc = + { &dev_spec_vnodeop_p, dev_spec_vnodeop_entries }; + +VNODEOP_SET(dev_spec_vnodeop_opv_desc); + diff --git a/sys/miscfs/devfs/devfsdefs.h b/sys/miscfs/devfs/devfsdefs.h new file mode 100644 index 0000000..8f5e7b9d3 --- /dev/null +++ b/sys/miscfs/devfs/devfsdefs.h @@ -0,0 +1,195 @@ +#define DEBUG 1 +#ifdef DEBUG +#define DBPRINT(A) printf(A) +#else +#define DBPRINT(A) +#endif + +/* + * Written by Julian Elischer (julian@DIALIX.oz.au) + * + * $Header: /sys/miscfs/devfs/RCS/devfsdefs.h,v 1.2 1994/12/28 02:43:47 root Exp root $ + */ + +/* first a couple of defines for compatibility with inodes */ + +#define ISUID 04000 /* set user identifier when exec'ing */ +#define ISGID 02000 /* set group identifier when exec'ing */ +#define ISVTX 01000 /* save execution information on exit */ +#define IREAD 0400 /* read permission */ +#define IWRITE 0200 /* write permission */ +#define IEXEC 0100 /* execute permission */ + + +#define ILOCKED 0x0001 /* inode is locked */ +#define IWANT 0x0002 /* some process waiting on lock */ +#define IRENAME 0x0004 /* inode is being renamed */ +#define IUPD 0x0010 /* file has been modified */ +#define IACC 0x0020 /* inode access time to be updated */ +#define ICHG 0x0040 /* inode has been changed */ +#define IMOD 0x0080 /* inode has been modified */ +#define ISHLOCK 0x0100 /* file has shared lock */ +#define IEXLOCK 0x0200 /* file has exclusive lock */ +#define ILWAIT 0x0400 /* someone waiting on file lock */ + +/* + * Lock and unlock inodes. + */ +#ifdef notdef +#define DNLOCK(ip) { \ + while ((ip)->i_flag & ILOCKED) { \ + (ip)->i_flag |= IWANT; \ + (void) sleep((caddr_t)(ip), PINOD); \ + } \ + (ip)->i_flag |= ILOCKED; \ +} + +#define DNUNLOCK(ip) { \ + (ip)->i_flag &= ~ILOCKED; \ + if ((ip)->i_flag&IWANT) { \ + (ip)->i_flag &= ~IWANT; \ + wakeup((caddr_t)(ip)); \ + } \ +} +#else +#define DNLOCK(ip) +#define DNUNLOCK(ip) +#endif + + +#define DEVMAXNAMESIZE 32 +#define DEVMAXPATHSIZE 128 +#define DEV_DIR 1 +#define DEV_BDEV 2 +#define DEV_CDEV 3 +#define DEV_DDEV 4 +#define DEV_ALIAS 5 +#define DEV_SLNK 6 + + +extern int (**devfs_vnodeop_p)(); /* our own vector array for dirs */ +extern int (**dev_spec_vnodeop_p)(); /* our own vector array for devs */ + +typedef struct dev_back *devb_p; +typedef struct dev_front *devf_p; +typedef struct devnode *dn_p; + +struct devnode +{ + u_short type; + int flags; /* more inode compatible for now *//*XXXkill*/ + u_short mode; /* basically inode compatible (drwxrwxrwx) */ + u_short uid; /* basically inode compatible */ + u_short gid; /* basically inode compatible */ + struct timespec atime; /* time of last access */ + struct timespec mtime; /* time of last modification */ + struct timespec ctime; /* time file changed */ + int links; /* how many file links does this node have? */ + struct devfsmount *dvm; /* the mount structure for this 'plane' */ + struct vnode *vn; /* address of last vnode that represented us */ + u_long vn_id; /* make sure we have the right vnode */ + int (***ops)(); /* yuk... pointer to pointer(s) to funcs */ + int len; /* of any associated info (e.g. dir data) */ + union typeinfo { + struct { + struct cdevsw *cdevsw; + dev_t dev; + }Cdev; + struct { + struct bdevsw *bdevsw; + dev_t dev; + }Bdev; + struct { + int (***ops)(); /* duplicate, used in dev_add_node */ + int arg; + }Ddev; + struct { + devf_p dirlist; + devf_p *dirlast; + dn_p parent; + devf_p myname; + int entrycount; + }Dir; + struct { + devb_p dirlist; + devb_p *dirlast; + dn_p parent; + devb_p myname; + int entrycount; + }BackDir; + struct { + char *name; /* must be allocated separatly */ + int namelen; + }Slnk; + struct { + devb_p realthing; + devb_p next; + }Alias; + }by; +}; +typedef struct devnode devnode_t; + +struct dev_back +{ + devb_p next; /* next object in this directory */ + devb_p *prevp; /* previous pointer in directory linked list */ + devb_p aliases; /* chain of aliases (kill if we are deleted)*/ + int alias_count; /* how many 'alias' nodes reference us. */ + devf_p fronts; /* the linked list of all our front nodes */ + devf_p *lastfront; /* the end of the front node chain */ + int frontcount; /* number of front nodes that reference us*/ + dn_p parent; /* backpointer to the directory itself */ + dn_p dnp; /* info a STAT would look at */ + char name[DEVMAXNAMESIZE]; +}; + +typedef struct dev_back devb_t; +extern struct dev_back *dev_root; /* always exists */ + + +/* + * Rules for front nodes: + * Dirs hava a strict 1:1 relationship with their OWN devnode + * Symlinks similarly + * Device Nodes ALWAYS point to the devnode that is linked + * to the Backing node. (with a ref count) + */ +struct dev_front +{ + devf_p next; /* next item in this directory chain */ + devf_p *prevp; /* previous pointer in the directory */ + devf_p file_node; /* the file node this represents */ + devf_p next_front; /* pointer to next item for this object */ + devf_p *prev_frontp; /* previous pointer in object chain */ + devb_p realthing; /* backpointer to the backing object */ + dn_p parent; /* our PARENT directory node */ + dn_p dnp; /* info a STAT would look at */ + char name[DEVMAXNAMESIZE]; +}; +typedef struct dev_front devf_t; + + + +/* + * DEVFS specific per/mount information, used to link a monted fs to a + * particular 'plane' of front nodes. + */ +struct devfsmount +{ + struct mount *mount; /* vfs mount struct for this fs */ + devf_p plane_root; /* the root of this 'plane' */ + int flags; /* usefule some day 8-) */ +}; + +struct dev_vn_data +{ + char magic[6]; /* = "devfs" if correct */ + devf_p front; + devb_p back; +}; + +extern struct vnodeops spec_vnodeops,devfs_vnodeops; +/* + * Prototypes for DEVFS virtual filesystem operations + */ +#include "devfs_proto.h" diff --git a/sys/miscfs/devfs/reproto.sh b/sys/miscfs/devfs/reproto.sh new file mode 100644 index 0000000..dc4b731 --- /dev/null +++ b/sys/miscfs/devfs/reproto.sh @@ -0,0 +1,2 @@ +#!/bin/sh +grep -h '/\*proto\*/' *.c |awk '{print $0 ";"}' >devfs_proto.h |
