#define SPLIT_DEVS 1
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/malloc.h>
#include <sys/mount_internal.h>
#include <sys/proc.h>
#include <sys/vnode_internal.h>
#include <stdarg.h>
#include <libkern/OSAtomic.h>
#define BSD_KERNEL_PRIVATE 1
#include "devfs.h"
#include "devfsdefs.h"
#if CONFIG_MACF
#include <security/mac_framework.h>
#endif
static void devfs_release_busy(devnode_t *);
static void dev_free_hier(devdirent_t *);
static int devfs_propogate(devdirent_t *, devdirent_t *);
static int dev_finddir(const char *, devnode_t *, int, devnode_t **);
static int dev_dup_entry(devnode_t *, devdirent_t *, devdirent_t **, struct devfsmount *);
lck_grp_t * devfs_lck_grp;
lck_grp_attr_t * devfs_lck_grp_attr;
lck_attr_t * devfs_lck_attr;
lck_mtx_t devfs_mutex;
devdirent_t * dev_root = NULL;
struct devfs_stats devfs_stats;
#ifdef HIDDEN_MOUNTPOINT
static struct mount *devfs_hidden_mount;
#endif
static int devfs_ready = 0;
#define DEVFS_NOCREATE FALSE
#define DEVFS_CREATE TRUE
int
devfs_sinit(void)
{
int error;
devfs_lck_grp_attr = lck_grp_attr_alloc_init();
devfs_lck_grp = lck_grp_alloc_init("devfs_lock", devfs_lck_grp_attr);
devfs_lck_attr = lck_attr_alloc_init();
lck_mtx_init(&devfs_mutex, devfs_lck_grp, devfs_lck_attr);
DEVFS_LOCK();
error = dev_add_entry("root", NULL, DEV_DIR, NULL, NULL, NULL, &dev_root);
DEVFS_UNLOCK();
if (error) {
printf("devfs_sinit: dev_add_entry failed ");
return (ENOTSUP);
}
#ifdef HIDDEN_MOUNTPOINT
MALLOC(devfs_hidden_mount, struct mount *, sizeof(struct mount),
M_MOUNT, M_WAITOK);
bzero(devfs_hidden_mount,sizeof(struct mount));
mount_lock_init(devfs_hidden_mount);
TAILQ_INIT(&devfs_hidden_mount->mnt_vnodelist);
TAILQ_INIT(&devfs_hidden_mount->mnt_workerqueue);
TAILQ_INIT(&devfs_hidden_mount->mnt_newvnodes);
#if CONFIG_MACF
mac_mount_label_init(devfs_hidden_mount);
mac_mount_label_associate(vfs_context_kernel(), devfs_hidden_mount);
#endif
mp->mnt_maxreadcnt = mp->mnt_maxwritecnt = MAXPHYS;
mp->mnt_segreadcnt = mp->mnt_segwritecnt = 32;
mp->mnt_ioflags = 0;
mp->mnt_realrootvp = NULLVP;
mp->mnt_authcache_ttl = CACHED_LOOKUP_RIGHT_TTL;
devfs_mount(devfs_hidden_mount,"dummy",NULL,NULL,NULL);
dev_root->de_dnp->dn_dvm
= (struct devfsmount *)devfs_hidden_mount->mnt_data;
#endif
#if CONFIG_MACF
mac_devfs_label_associate_directory("/", strlen("/"),
dev_root->de_dnp, "/");
#endif
devfs_ready = 1;
return (0);
}
devdirent_t *
dev_findname(devnode_t * dir, const char *name)
{
devdirent_t * newfp;
if (dir->dn_type != DEV_DIR) return 0;
if (name[0] == '.')
{
if(name[1] == 0)
{
return dir->dn_typeinfo.Dir.myname;
}
if((name[1] == '.') && (name[2] == 0))
{
return dir->dn_typeinfo.Dir.parent->dn_typeinfo.Dir.myname;
}
}
newfp = dir->dn_typeinfo.Dir.dirlist;
while(newfp)
{
if(!(strncmp(name, newfp->de_name, sizeof(newfp->de_name))))
return newfp;
newfp = newfp->de_next;
}
return NULL;
}
static int
dev_finddir(const char * path,
devnode_t * dirnode,
int create,
devnode_t * * dn_pp)
{
devnode_t * dnp = NULL;
int error = 0;
const char * scan;
#if CONFIG_MACF
char fullpath[DEVMAXPATHSIZE];
#endif
if (!dirnode)
dirnode = dev_root->de_dnp;
if (dirnode->dn_type != DEV_DIR)
return ENOTDIR;
if (strlen(path) > (DEVMAXPATHSIZE - 1))
return ENAMETOOLONG;
#if CONFIG_MACF
strlcpy (fullpath, path, DEVMAXPATHSIZE);
#endif
scan = path;
while (*scan == '/')
scan++;
*dn_pp = NULL;
while (1) {
char component[DEVMAXPATHSIZE];
devdirent_t * dirent_p;
const char * start;
if (*scan == 0) {
*dn_pp = dirnode;
break;
}
start = scan;
while (*scan != '/' && *scan)
scan++;
strlcpy(component, start, scan - start);
if (*scan == '/')
scan++;
dirent_p = dev_findname(dirnode, component);
if (dirent_p) {
dnp = dirent_p->de_dnp;
if (dnp->dn_type != DEV_DIR) {
error = ENOTDIR;
break;
}
}
else {
if (!create) {
error = ENOENT;
break;
}
error = dev_add_entry(component, dirnode,
DEV_DIR, NULL, NULL, NULL, &dirent_p);
if (error)
break;
dnp = dirent_p->de_dnp;
#if CONFIG_MACF
mac_devfs_label_associate_directory(
dirnode->dn_typeinfo.Dir.myname->de_name,
strlen(dirnode->dn_typeinfo.Dir.myname->de_name),
dnp, fullpath);
#endif
devfs_propogate(dirnode->dn_typeinfo.Dir.myname, dirent_p);
}
dirnode = dnp;
}
return (error);
}
int
dev_add_name(const char * name, devnode_t * dirnode, __unused devdirent_t * back,
devnode_t * dnp, devdirent_t * *dirent_pp)
{
devdirent_t * dirent_p = NULL;
if(dirnode != NULL ) {
if(dirnode->dn_type != DEV_DIR) return(ENOTDIR);
if( dev_findname(dirnode,name))
return(EEXIST);
}
if (!name || (strlen(name) > (DEVMAXNAMESIZE - 1)))
return (ENAMETOOLONG);
MALLOC(dirent_p, devdirent_t *, sizeof(devdirent_t),
M_DEVFSNAME, M_WAITOK);
if (!dirent_p) {
return ENOMEM;
}
bzero(dirent_p,sizeof(devdirent_t));
if(dirnode && ( dnp->dn_dvm == NULL)) {
dnp->dn_dvm = dirnode->dn_dvm;
}
dirent_p->de_dnp = dnp;
dnp->dn_links++ ;
if(dnp->dn_linklist) {
dirent_p->de_nextlink = dnp->dn_linklist;
dirent_p->de_prevlinkp = dirent_p->de_nextlink->de_prevlinkp;
dirent_p->de_nextlink->de_prevlinkp = &(dirent_p->de_nextlink);
*dirent_p->de_prevlinkp = dirent_p;
} else {
dirent_p->de_nextlink = dirent_p;
dirent_p->de_prevlinkp = &(dirent_p->de_nextlink);
}
dnp->dn_linklist = dirent_p;
if(dnp->dn_type == DEV_DIR) {
dnp->dn_typeinfo.Dir.myname = dirent_p;
if(dnp->dn_typeinfo.Dir.parent) {
dnp->dn_typeinfo.Dir.parent->dn_links--;
}
if(dirnode) {
dnp->dn_typeinfo.Dir.parent = dirnode;
} else {
dnp->dn_typeinfo.Dir.parent = dnp;
}
dnp->dn_typeinfo.Dir.parent->dn_links++;
}
strlcpy(dirent_p->de_name, name, DEVMAXNAMESIZE);
if(dirnode) {
dirent_p->de_parent = dirnode;
dirent_p->de_prevp = dirnode->dn_typeinfo.Dir.dirlast;
dirent_p->de_next = *(dirent_p->de_prevp);
*(dirent_p->de_prevp) = dirent_p;
dirnode->dn_typeinfo.Dir.dirlast = &(dirent_p->de_next);
dirnode->dn_typeinfo.Dir.entrycount++;
dirnode->dn_len += strlen(name) + 8;
}
*dirent_pp = dirent_p;
DEVFS_INCR_ENTRIES();
return 0 ;
}
int
dev_add_node(int entrytype, devnode_type_t * typeinfo, devnode_t * proto,
devnode_t * *dn_pp, struct devfsmount *dvm)
{
devnode_t * dnp = NULL;
#if defined SPLIT_DEVS
if (proto) {
dnp = proto->dn_nextsibling;
while( dnp != proto) {
if (dnp->dn_dvm == dvm) {
*dn_pp = dnp;
return (0);
}
dnp = dnp->dn_nextsibling;
}
if (typeinfo == NULL)
typeinfo = &(proto->dn_typeinfo);
}
#else
if ( proto ) {
switch (proto->type) {
case DEV_BDEV:
case DEV_CDEV:
*dn_pp = proto;
return 0;
}
}
#endif
MALLOC(dnp, devnode_t *, sizeof(devnode_t), M_DEVFSNODE, M_WAITOK);
if (!dnp) {
return ENOMEM;
}
if (proto) {
bcopy(proto, dnp, sizeof(devnode_t));
dnp->dn_links = 0;
dnp->dn_linklist = NULL;
dnp->dn_vn = NULL;
dnp->dn_len = 0;
dnp->dn_prevsiblingp = proto->dn_prevsiblingp;
*(dnp->dn_prevsiblingp) = dnp;
dnp->dn_nextsibling = proto;
proto->dn_prevsiblingp = &(dnp->dn_nextsibling);
#if CONFIG_MACF
mac_devfs_label_init(dnp);
mac_devfs_label_copy(proto->dn_label, dnp->dn_label);
#endif
} else {
struct timeval tv;
microtime(&tv);
bzero(dnp, sizeof(devnode_t));
dnp->dn_type = entrytype;
dnp->dn_nextsibling = dnp;
dnp->dn_prevsiblingp = &(dnp->dn_nextsibling);
dnp->dn_atime.tv_sec = tv.tv_sec;
dnp->dn_mtime.tv_sec = tv.tv_sec;
dnp->dn_ctime.tv_sec = tv.tv_sec;
#if CONFIG_MACF
mac_devfs_label_init(dnp);
#endif
}
dnp->dn_dvm = dvm;
switch(entrytype) {
case DEV_DIR:
dnp->dn_typeinfo.Dir.dirlast = &(dnp->dn_typeinfo.Dir.dirlist);
dnp->dn_typeinfo.Dir.dirlist = (devdirent_t *)0;
dnp->dn_typeinfo.Dir.entrycount = 0;
dnp->dn_typeinfo.Dir.parent = NULL;
dnp->dn_links++;
dnp->dn_typeinfo.Dir.myname = NULL;
dnp->dn_ops = &devfs_vnodeop_p;
dnp->dn_mode |= 0555;
break;
case DEV_SLNK:
MALLOC(dnp->dn_typeinfo.Slnk.name, char *,
typeinfo->Slnk.namelen+1,
M_DEVFSNODE, M_WAITOK);
if (!dnp->dn_typeinfo.Slnk.name) {
FREE(dnp,M_DEVFSNODE);
return ENOMEM;
}
strlcpy(dnp->dn_typeinfo.Slnk.name, typeinfo->Slnk.name,
typeinfo->Slnk.namelen + 1);
dnp->dn_typeinfo.Slnk.namelen = typeinfo->Slnk.namelen;
DEVFS_INCR_STRINGSPACE(dnp->dn_typeinfo.Slnk.namelen + 1);
dnp->dn_ops = &devfs_vnodeop_p;
dnp->dn_mode |= 0555;
break;
case DEV_CDEV:
case DEV_BDEV:
dnp->dn_ops = &devfs_spec_vnodeop_p;
dnp->dn_typeinfo.dev = typeinfo->dev;
break;
default:
return EINVAL;
}
*dn_pp = dnp;
DEVFS_INCR_NODES();
return 0 ;
}
void
devnode_free(devnode_t * dnp)
{
if (dnp->dn_lflags & DN_BUSY) {
dnp->dn_lflags |= DN_DELETE;
return;
}
#if CONFIG_MACF
mac_devfs_label_destroy(dnp);
#endif
if (dnp->dn_type == DEV_SLNK) {
DEVFS_DECR_STRINGSPACE(dnp->dn_typeinfo.Slnk.namelen + 1);
FREE(dnp->dn_typeinfo.Slnk.name, M_DEVFSNODE);
}
DEVFS_DECR_NODES();
FREE(dnp, M_DEVFSNODE);
}
static void
devfs_dn_free(devnode_t * dnp)
{
if(--dnp->dn_links <= 0 )
{
if (dnp->dn_nextsibling != dnp) {
devnode_t * * prevp = dnp->dn_prevsiblingp;
*prevp = dnp->dn_nextsibling;
dnp->dn_nextsibling->dn_prevsiblingp = prevp;
}
if (dnp->dn_vn == NULL) {
devnode_free(dnp);
}
else {
dnp->dn_delete = TRUE;
}
}
}
static int
devfs_propogate(devdirent_t * parent,devdirent_t * child)
{
int error;
devdirent_t * newnmp;
devnode_t * dnp = child->de_dnp;
devnode_t * pdnp = parent->de_dnp;
devnode_t * adnp = parent->de_dnp;
int type = child->de_dnp->dn_type;
for (adnp = pdnp->dn_nextsibling;
adnp != pdnp;
adnp = adnp->dn_nextsibling)
{
if ((error = dev_add_entry(child->de_name, adnp, type,
NULL, dnp, adnp->dn_dvm,
&newnmp)) != 0) {
printf("duplicating %s failed\n",child->de_name);
}
}
return 0;
}
void
devfs_remove(void *dirent_p)
{
devnode_t * dnp = ((devdirent_t *)dirent_p)->de_dnp;
devnode_t * dnp2;
boolean_t lastlink;
DEVFS_LOCK();
if (!devfs_ready) {
printf("devfs_remove: not ready for devices!\n");
goto out;
}
while ((dnp2 = dnp->dn_nextsibling) != dnp) {
dnp->dn_nextsibling = dnp2->dn_nextsibling;
dnp->dn_nextsibling->dn_prevsiblingp = &(dnp->dn_nextsibling);
dnp2->dn_nextsibling = dnp2;
dnp2->dn_prevsiblingp = &(dnp2->dn_nextsibling);
if (dnp2->dn_linklist) {
do {
lastlink = (1 == dnp2->dn_links);
dev_free_name(dnp2->dn_linklist);
} while (!lastlink);
}
}
if (dnp->dn_linklist) {
do {
lastlink = (1 == dnp->dn_links);
dev_free_name(dnp->dn_linklist);
} while (!lastlink);
}
out:
DEVFS_UNLOCK();
return ;
}
int
dev_dup_plane(struct devfsmount *devfs_mp_p)
{
devdirent_t * new;
int error = 0;
if ((error = dev_dup_entry(NULL, dev_root, &new, devfs_mp_p)))
return error;
devfs_mp_p->plane_root = new;
return error;
}
void
devfs_free_plane(struct devfsmount *devfs_mp_p)
{
devdirent_t * dirent_p;
dirent_p = devfs_mp_p->plane_root;
if (dirent_p) {
dev_free_hier(dirent_p);
dev_free_name(dirent_p);
}
devfs_mp_p->plane_root = NULL;
}
static int
dev_dup_entry(devnode_t * parent, devdirent_t * back, devdirent_t * *dnm_pp,
struct devfsmount *dvm)
{
devdirent_t * entry_p;
devdirent_t * newback;
devdirent_t * newfront;
int error;
devnode_t * dnp = back->de_dnp;
int type = dnp->dn_type;
if ((error = dev_add_entry(back->de_name, parent, type,
NULL, dnp,
parent?parent->dn_dvm:dvm, &entry_p)) != 0) {
printf("duplicating %s failed\n",back->de_name);
}
if(dvm) {
entry_p->de_dnp->dn_dvm = dvm;
}
if (type == DEV_DIR)
{
for(newback = back->de_dnp->dn_typeinfo.Dir.dirlist;
newback; newback = newback->de_next)
{
if((error = dev_dup_entry(entry_p->de_dnp,
newback, &newfront, NULL)) != 0)
{
break;
}
}
}
*dnm_pp = entry_p;
return error;
}
int
dev_free_name(devdirent_t * dirent_p)
{
devnode_t * parent = dirent_p->de_parent;
devnode_t * dnp = dirent_p->de_dnp;
if(dnp) {
if(dnp->dn_type == DEV_DIR)
{
devnode_t * p;
if(dnp->dn_typeinfo.Dir.dirlist)
return (ENOTEMPTY);
p = dnp->dn_typeinfo.Dir.parent;
devfs_dn_free(dnp);
devfs_dn_free(p);
}
if(dirent_p->de_nextlink == dirent_p) {
dnp->dn_linklist = NULL;
} else {
if(dnp->dn_linklist == dirent_p) {
dnp->dn_linklist = dirent_p->de_nextlink;
}
dirent_p->de_nextlink->de_prevlinkp
= dirent_p->de_prevlinkp;
*dirent_p->de_prevlinkp = dirent_p->de_nextlink;
}
devfs_dn_free(dnp);
}
if(parent)
{
if( (*dirent_p->de_prevp = dirent_p->de_next) )
{
dirent_p->de_next->de_prevp = dirent_p->de_prevp;
}
else
{
parent->dn_typeinfo.Dir.dirlast
= dirent_p->de_prevp;
}
parent->dn_typeinfo.Dir.entrycount--;
parent->dn_len -= strlen(dirent_p->de_name) + 8;
}
DEVFS_DECR_ENTRIES();
FREE(dirent_p, M_DEVFSNAME);
return 0;
}
static void
dev_free_hier(devdirent_t * dirent_p)
{
devnode_t * dnp = dirent_p->de_dnp;
if(dnp) {
if(dnp->dn_type == DEV_DIR)
{
while(dnp->dn_typeinfo.Dir.dirlist)
{
dev_free_hier(dnp->dn_typeinfo.Dir.dirlist);
dev_free_name(dnp->dn_typeinfo.Dir.dirlist);
}
}
}
}
int
devfs_dntovn(devnode_t * dnp, struct vnode **vn_pp, __unused struct proc * p)
{
struct vnode *vn_p;
struct vnode ** vnptr;
int error = 0;
struct vnode_fsparam vfsp;
enum vtype vtype = 0;
int markroot = 0;
int n_minor = DEVFS_CLONE_ALLOC;
retry:
*vn_pp = NULL;
vn_p = dnp->dn_vn;
dnp->dn_lflags |= DN_BUSY;
if (vn_p) {
uint32_t vid;
vid = vnode_vid(vn_p);
DEVFS_UNLOCK();
error = vnode_getwithvid(vn_p, vid);
DEVFS_LOCK();
if (dnp->dn_lflags & DN_DELETE) {
if (error == 0) {
vnode_put(vn_p);
}
error = EAGAIN;
}
if ( !error)
*vn_pp = vn_p;
devfs_release_busy(dnp);
return error;
}
if (dnp->dn_lflags & DN_CREATE) {
dnp->dn_lflags |= DN_CREATEWAIT;
msleep(&dnp->dn_lflags, &devfs_mutex, PRIBIO, 0 , 0);
goto retry;
}
dnp->dn_lflags |= DN_CREATE;
switch (dnp->dn_type) {
case DEV_SLNK:
vtype = VLNK;
break;
case DEV_DIR:
if (dnp->dn_typeinfo.Dir.parent == dnp) {
markroot = 1;
}
vtype = VDIR;
break;
case DEV_BDEV:
case DEV_CDEV:
vtype = (dnp->dn_type == DEV_BDEV) ? VBLK : VCHR;
break;
}
vfsp.vnfs_mp = dnp->dn_dvm->mount;
vfsp.vnfs_vtype = vtype;
vfsp.vnfs_str = "devfs";
vfsp.vnfs_dvp = 0;
vfsp.vnfs_fsnode = dnp;
vfsp.vnfs_cnp = 0;
vfsp.vnfs_vops = *(dnp->dn_ops);
if (vtype == VBLK || vtype == VCHR) {
if (dnp->dn_clone != NULL) {
int n_major = major(dnp->dn_typeinfo.dev);
n_minor = (*dnp->dn_clone)(dnp->dn_typeinfo.dev, DEVFS_CLONE_ALLOC);
if (n_minor == -1) {
devfs_release_busy(dnp);
return ENOMEM;
}
vfsp.vnfs_rdev = makedev(n_major, n_minor);;
} else {
vfsp.vnfs_rdev = dnp->dn_typeinfo.dev;
}
} else {
vfsp.vnfs_rdev = 0;
}
vfsp.vnfs_filesize = 0;
vfsp.vnfs_flags = VNFS_NOCACHE | VNFS_CANTCACHE;
vfsp.vnfs_marksystem = 0;
vfsp.vnfs_markroot = markroot;
DEVFS_UNLOCK();
if (dnp->dn_clone == NULL)
vnptr = &dnp->dn_vn;
else
vnptr = &vn_p;
error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vfsp, vnptr);
DEVFS_LOCK();
if (error == 0) {
if ((dnp->dn_clone != NULL) && (dnp->dn_vn != NULLVP) )
panic("devnode already has a vnode?");
if (dnp->dn_clone == NULL) {
*vn_pp = dnp->dn_vn;
} else {
*vn_pp = vn_p;
}
} else if (n_minor != DEVFS_CLONE_ALLOC) {
(void)(*dnp->dn_clone)(dnp->dn_typeinfo.dev, DEVFS_CLONE_FREE);
}
dnp->dn_lflags &= ~DN_CREATE;
if (dnp->dn_lflags & DN_CREATEWAIT) {
dnp->dn_lflags &= ~DN_CREATEWAIT;
wakeup(&dnp->dn_lflags);
}
devfs_release_busy(dnp);
return error;
}
static void
devfs_release_busy(devnode_t *dnp) {
dnp->dn_lflags &= ~DN_BUSY;
if (dnp->dn_lflags & DN_DELETE)
devnode_free(dnp);
}
int
dev_add_entry(const char *name, devnode_t * parent, int type, devnode_type_t * typeinfo,
devnode_t * proto, struct devfsmount *dvm, devdirent_t * *nm_pp)
{
devnode_t * dnp;
int error = 0;
if ((error = dev_add_node(type, typeinfo, proto, &dnp,
(parent?parent->dn_dvm:dvm))) != 0)
{
printf("devfs: %s: base node allocation failed (Errno=%d)\n",
name,error);
return error;
}
if ((error = dev_add_name(name ,parent ,NULL, dnp, nm_pp)) != 0)
{
devfs_dn_free(dnp);
printf("devfs: %s: name slot allocation failed (Errno=%d)\n",
name,error);
}
return error;
}
void *
devfs_make_node_clone(dev_t dev, int chrblk, uid_t uid,
gid_t gid, int perms, int (*clone)(dev_t dev, int action),
const char *fmt, ...)
{
devdirent_t * new_dev = NULL;
devnode_t * dnp;
devnode_type_t typeinfo;
char *name, buf[256];
const char *path;
int i;
va_list ap;
DEVFS_LOCK();
if (!devfs_ready) {
printf("devfs_make_node: not ready for devices!\n");
goto out;
}
if (chrblk != DEVFS_CHAR && chrblk != DEVFS_BLOCK)
goto out;
DEVFS_UNLOCK();
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
name = NULL;
for(i=strlen(buf); i>0; i--)
if(buf[i] == '/') {
name=&buf[i];
buf[i]=0;
break;
}
if (name) {
*name++ = '\0';
path = buf;
} else {
name = buf;
path = "/";
}
DEVFS_LOCK();
if (dev_finddir(path, NULL, DEVFS_CREATE, &dnp) == 0) {
typeinfo.dev = dev;
if (dev_add_entry(name, dnp,
(chrblk == DEVFS_CHAR) ? DEV_CDEV : DEV_BDEV,
&typeinfo, NULL, NULL, &new_dev) == 0) {
new_dev->de_dnp->dn_gid = gid;
new_dev->de_dnp->dn_uid = uid;
new_dev->de_dnp->dn_mode |= perms;
new_dev->de_dnp->dn_clone = clone;
devfs_propogate(dnp->dn_typeinfo.Dir.myname, new_dev);
}
}
out:
DEVFS_UNLOCK();
return new_dev;
}
void *
devfs_make_node(dev_t dev, int chrblk, uid_t uid,
gid_t gid, int perms, const char *fmt, ...)
{
devdirent_t * new_dev = NULL;
devnode_t * dnp;
devnode_type_t typeinfo;
char *name, buf[256];
const char *path;
#if CONFIG_MACF
char buff[sizeof(buf)];
#endif
int i;
va_list ap;
DEVFS_LOCK();
if (!devfs_ready) {
printf("devfs_make_node: not ready for devices!\n");
goto out;
}
if (chrblk != DEVFS_CHAR && chrblk != DEVFS_BLOCK)
goto out;
DEVFS_UNLOCK();
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
#if CONFIG_MACF
bcopy(buf, buff, sizeof(buff));
buff[sizeof(buff)-1] = 0;
#endif
name = NULL;
for(i=strlen(buf); i>0; i--)
if(buf[i] == '/') {
name=&buf[i];
buf[i]=0;
break;
}
if (name) {
*name++ = '\0';
path = buf;
} else {
name = buf;
path = "/";
}
DEVFS_LOCK();
if (dev_finddir(path, NULL, DEVFS_CREATE, &dnp) == 0) {
typeinfo.dev = dev;
if (dev_add_entry(name, dnp,
(chrblk == DEVFS_CHAR) ? DEV_CDEV : DEV_BDEV,
&typeinfo, NULL, NULL, &new_dev) == 0) {
new_dev->de_dnp->dn_gid = gid;
new_dev->de_dnp->dn_uid = uid;
new_dev->de_dnp->dn_mode |= perms;
new_dev->de_dnp->dn_clone = NULL;
#if CONFIG_MACF
mac_devfs_label_associate_device(dev, new_dev->de_dnp, buff);
#endif
devfs_propogate(dnp->dn_typeinfo.Dir.myname, new_dev);
}
}
out:
DEVFS_UNLOCK();
return new_dev;
}
int
devfs_make_link(void *original, char *fmt, ...)
{
devdirent_t * new_dev = NULL;
devdirent_t * orig = (devdirent_t *) original;
devnode_t * dirnode;
va_list ap;
char *p, buf[256];
int i;
DEVFS_LOCK();
if (!devfs_ready) {
printf("devfs_make_link: not ready for devices!\n");
goto out;
}
DEVFS_UNLOCK();
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
p = NULL;
for(i=strlen(buf); i>0; i--) {
if(buf[i] == '/') {
p=&buf[i];
buf[i]=0;
break;
}
}
DEVFS_LOCK();
if (p) {
*p++ = '\0';
if (dev_finddir(buf, NULL, DEVFS_CREATE, &dirnode)
|| dev_add_name(p, dirnode, NULL, orig->de_dnp, &new_dev))
goto fail;
} else {
if (dev_finddir("", NULL, DEVFS_CREATE, &dirnode)
|| dev_add_name(buf, dirnode, NULL, orig->de_dnp, &new_dev))
goto fail;
}
devfs_propogate(dirnode->dn_typeinfo.Dir.myname, new_dev);
fail:
out:
DEVFS_UNLOCK();
return ((new_dev != NULL) ? 0 : -1);
}