version 1.18, 1994/02/09 06:32:17 |
version 1.38, 1995/10/09 14:03:35 |
|
|
|
/* $NetBSD$ */ |
|
|
/* |
/* |
* Copyright (c) 1992 The Regents of the University of California |
* Copyright (c) 1992, 1993 |
* Copyright (c) 1990, 1992 Jan-Simon Pendry |
* The Regents of the University of California. All rights reserved. |
* All rights reserved. |
|
* |
* |
* This code is derived from software donated to Berkeley by |
* This code is derived from software donated to Berkeley by |
* Jan-Simon Pendry. |
* Jan-Simon Pendry. |
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
* SUCH DAMAGE. |
* SUCH DAMAGE. |
* |
* |
* From: |
* @(#)kernfs_vnops.c 8.9 (Berkeley) 6/15/94 |
* Id: kernfs_vnops.c,v 4.1 1994/01/02 14:41:30 jsp Exp |
|
* |
|
* $Id$ |
|
*/ |
*/ |
|
|
/* |
/* |
* Kernel parameter filesystem |
* Kernel parameter filesystem (/kern) |
*/ |
*/ |
|
|
#include <sys/param.h> |
#include <sys/param.h> |
#include <sys/systm.h> |
#include <sys/systm.h> |
#include <sys/kernel.h> |
#include <sys/kernel.h> |
|
#include <sys/vmmeter.h> |
#include <sys/types.h> |
#include <sys/types.h> |
#include <sys/time.h> |
#include <sys/time.h> |
#include <sys/proc.h> |
#include <sys/proc.h> |
#include <sys/file.h> |
|
#include <sys/vnode.h> |
#include <sys/vnode.h> |
|
#include <sys/malloc.h> |
|
#include <sys/file.h> |
#include <sys/stat.h> |
#include <sys/stat.h> |
#include <sys/mount.h> |
#include <sys/mount.h> |
#include <sys/namei.h> |
#include <sys/namei.h> |
#include <sys/buf.h> |
#include <sys/buf.h> |
|
#include <sys/dirent.h> |
|
#include <sys/msgbuf.h> |
#include <miscfs/kernfs/kernfs.h> |
#include <miscfs/kernfs/kernfs.h> |
|
|
#include <ufs/dir.h> /* For readdir() XXX */ |
|
|
|
#define KSTRING 256 /* Largest I/O available via this filesystem */ |
#define KSTRING 256 /* Largest I/O available via this filesystem */ |
#define UIO_MX 32 |
#define UIO_MX 32 |
|
|
|
#define READ_MODE (S_IRUSR|S_IRGRP|S_IROTH) |
|
#define WRITE_MODE (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH) |
|
#define DIR_MODE (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) |
|
|
struct kern_target { |
struct kern_target { |
|
u_char kt_type; |
|
u_char kt_namlen; |
char *kt_name; |
char *kt_name; |
void *kt_data; |
void *kt_data; |
#define KTT_NULL 1 |
#define KTT_NULL 1 |
#define KTT_TIME 5 |
#define KTT_TIME 5 |
#define KTT_INT 17 |
#define KTT_INT 17 |
#define KTT_STRING 31 |
#define KTT_STRING 31 |
#define KTT_HOSTNAME 47 |
#define KTT_HOSTNAME 47 |
#define KTT_AVENRUN 53 |
#define KTT_AVENRUN 53 |
int kt_tag; |
#define KTT_DEVICE 71 |
#define KTM_RO 0 |
#define KTT_MSGBUF 89 |
#define KTM_RO_MODE \ |
u_char kt_tag; |
((VREAD) | (VREAD >> 3) | (VREAD >> 6)) |
u_char kt_vtype; |
#define KTM_RW 43 |
mode_t kt_mode; |
#define KTM_RW_MODE \ |
|
((VWRITE) | KTM_RO_MODE) |
|
#define KTM_DIR_MODE \ |
|
((VREAD|VEXEC) | ((VREAD|VEXEC) >> 3) | ((VREAD|VEXEC) >> 6)) |
|
int kt_rw; |
|
enum vtype kt_vtype; |
|
} kern_targets[] = { |
} kern_targets[] = { |
/* NOTE: The name must be less than UIO_MX-16 chars in length */ |
/* NOTE: The name must be less than UIO_MX-16 chars in length */ |
/* name data tag ro/rw */ |
#define N(s) sizeof(s)-1, s |
{ ".", 0, KTT_NULL, KTM_RO, VDIR }, |
/* name data tag type ro/rw */ |
{ "copyright", copyright, KTT_STRING, KTM_RO, VREG }, |
{ DT_DIR, N("."), 0, KTT_NULL, VDIR, DIR_MODE }, |
{ "hostname", 0, KTT_HOSTNAME, KTM_RW, VREG }, |
{ DT_DIR, N(".."), 0, KTT_NULL, VDIR, DIR_MODE }, |
{ "hz", &hz, KTT_INT, KTM_RO, VREG }, |
{ DT_REG, N("boottime"), &boottime.tv_sec, KTT_INT, VREG, READ_MODE }, |
{ "loadavg", 0, KTT_AVENRUN, KTM_RO, VREG }, |
{ DT_REG, N("copyright"), copyright, KTT_STRING, VREG, READ_MODE }, |
{ "physmem", &physmem, KTT_INT, KTM_RO, VREG }, |
{ DT_REG, N("hostname"), 0, KTT_HOSTNAME, VREG, WRITE_MODE }, |
|
{ DT_REG, N("hz"), &hz, KTT_INT, VREG, READ_MODE }, |
|
{ DT_REG, N("loadavg"), 0, KTT_AVENRUN, VREG, READ_MODE }, |
|
{ DT_REG, N("msgbuf"), 0, KTT_MSGBUF, VREG, READ_MODE }, |
|
{ DT_REG, N("pagesize"), &cnt.v_page_size, KTT_INT, VREG, READ_MODE }, |
|
{ DT_REG, N("physmem"), &physmem, KTT_INT, VREG, READ_MODE }, |
#if 0 |
#if 0 |
{ "root", 0, KTT_NULL, KTM_RO, VDIR }, |
{ DT_DIR, N("root"), 0, KTT_NULL, VDIR, DIR_MODE }, |
#endif |
#endif |
{ "rootdev", 0, KTT_NULL, KTM_RO, VBLK }, |
{ DT_BLK, N("rootdev"), &rootdev, KTT_DEVICE, VBLK, READ_MODE }, |
#ifdef notdef |
{ DT_CHR, N("rrootdev"), &rrootdev, KTT_DEVICE, VCHR, READ_MODE }, |
{ "rrootdev", 0, KTT_NULL, KTM_RO, VCHR }, |
{ DT_REG, N("time"), 0, KTT_TIME, VREG, READ_MODE }, |
#endif |
{ DT_REG, N("version"), version, KTT_STRING, VREG, READ_MODE }, |
{ "time", 0, KTT_TIME, KTM_RO, VREG }, |
#undef N |
{ "version", version, KTT_STRING, KTM_RO, VREG }, |
|
}; |
}; |
|
|
static int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); |
static int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); |
|
|
static int |
int |
kernfs_xread(kt, buf, len, lenp) |
kernfs_xread(kt, off, bufp, len) |
struct kern_target *kt; |
struct kern_target *kt; |
char *buf; |
int off; |
|
char **bufp; |
int len; |
int len; |
int *lenp; |
|
{ |
{ |
int xlen; |
|
|
|
switch (kt->kt_tag) { |
switch (kt->kt_tag) { |
case KTT_TIME: { |
case KTT_TIME: { |
struct timeval tv; |
struct timeval tv; |
|
|
microtime(&tv); |
microtime(&tv); |
sprintf(buf, "%d %d\n", tv.tv_sec, tv.tv_usec); |
sprintf(*bufp, "%d %d\n", tv.tv_sec, tv.tv_usec); |
break; |
break; |
} |
} |
|
|
case KTT_INT: { |
case KTT_INT: { |
int *ip = kt->kt_data; |
int *ip = kt->kt_data; |
sprintf(buf, "%d\n", *ip); |
|
|
sprintf(*bufp, "%d\n", *ip); |
break; |
break; |
} |
} |
|
|
case KTT_STRING: { |
case KTT_STRING: { |
char *cp = kt->kt_data; |
char *cp = kt->kt_data; |
int xlen = strlen(cp) + 1; |
|
|
|
if (xlen >= len) |
*bufp = cp; |
return (EINVAL); |
|
|
|
bcopy(cp, buf, xlen); |
|
break; |
break; |
} |
} |
|
|
|
case KTT_MSGBUF: { |
|
extern struct msgbuf *msgbufp; |
|
long n; |
|
|
|
if (off >= MSG_BSIZE) |
|
return (0); |
|
n = msgbufp->msg_bufx + off; |
|
if (n >= MSG_BSIZE) |
|
n -= MSG_BSIZE; |
|
len = min(MSG_BSIZE - n, MSG_BSIZE - off); |
|
*bufp = msgbufp->msg_bufc + n; |
|
return (len); |
|
} |
|
|
case KTT_HOSTNAME: { |
case KTT_HOSTNAME: { |
char *cp = hostname; |
char *cp = hostname; |
int xlen = hostnamelen; |
int xlen = hostnamelen; |
Line 146 kernfs_xread(kt, buf, len, lenp) |
|
Line 160 kernfs_xread(kt, buf, len, lenp) |
|
if (xlen >= (len-2)) |
if (xlen >= (len-2)) |
return (EINVAL); |
return (EINVAL); |
|
|
bcopy(cp, buf, xlen); |
bcopy(cp, *bufp, xlen); |
buf[xlen] = '\n'; |
(*bufp)[xlen] = '\n'; |
buf[xlen+1] = '\0'; |
(*bufp)[xlen+1] = '\0'; |
break; |
break; |
} |
} |
|
|
case KTT_AVENRUN: |
case KTT_AVENRUN: |
sprintf(buf, "%d %d %d %d\n", |
averunnable.fscale = FSCALE; |
averunnable.ldavg[0], |
sprintf(*bufp, "%ld %ld %ld %ld\n", |
averunnable.ldavg[1], |
averunnable.ldavg[0], averunnable.ldavg[1], |
averunnable.ldavg[2], |
averunnable.ldavg[2], averunnable.fscale); |
averunnable.fscale); |
|
break; |
break; |
|
|
default: |
default: |
return (EINVAL); |
return (0); |
} |
} |
|
|
*lenp = strlen(buf); |
len = strlen(*bufp); |
return (0); |
if (len <= off) |
|
return (0); |
|
*bufp += off; |
|
return (len - off); |
} |
} |
|
|
static int |
int |
kernfs_xwrite(kt, buf, len) |
kernfs_xwrite(kt, buf, len) |
struct kern_target *kt; |
struct kern_target *kt; |
char *buf; |
char *buf; |
int len; |
int len; |
{ |
{ |
|
|
switch (kt->kt_tag) { |
switch (kt->kt_tag) { |
case KTT_HOSTNAME: { |
case KTT_HOSTNAME: |
if (buf[len-1] == '\n') |
if (buf[len-1] == '\n') |
--len; |
--len; |
bcopy(buf, hostname, len); |
bcopy(buf, hostname, len); |
hostname[len] = '\0'; |
hostname[len] = '\0'; |
hostnamelen = len; |
hostnamelen = len; |
return (0); |
return (0); |
} |
|
|
|
default: |
default: |
return (EIO); |
return (EIO); |
} |
} |
} |
} |
|
|
/* |
|
* implement access checking. |
|
* |
|
* something very similar to this code is duplicated |
|
* throughout the 4bsd kernel and should be moved |
|
* into kern/vfs_subr.c sometime. |
|
* |
|
* actually, the check for super-user is slightly |
|
* broken since it will allow read access to write-only |
|
* objects. this doesn't cause any particular trouble |
|
* but does mean that the i/o entry points need to check |
|
* that the operation really does make sense. |
|
*/ |
|
kernfs_access(vp, mode, cred, p) |
|
struct vnode *vp; |
|
int mode; |
|
struct ucred *cred; |
|
struct proc *p; |
|
{ |
|
struct vattr *vap; |
|
struct vattr vattr; |
|
int error; |
|
|
|
/* |
|
* If you're the super-user, |
|
* you always get access. |
|
*/ |
|
if (cred->cr_uid == (uid_t) 0) |
|
return (0); |
|
vap = &vattr; |
|
if (error = VOP_GETATTR(vp, vap, cred, p)) |
|
return (error); |
|
|
|
/* |
|
* 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 != vap->va_uid) { |
|
gid_t *gp; |
|
int i; |
|
|
|
mode >>= 3; |
|
gp = cred->cr_groups; |
|
for (i = 0; i < cred->cr_ngroups; i++, gp++) |
|
if (vap->va_gid == *gp) |
|
goto found; |
|
mode >>= 3; |
|
found: |
|
; |
|
} |
|
|
|
if ((vap->va_mode & mode) == mode) |
|
return (0); |
|
|
|
return (EACCES); |
|
} |
|
|
|
/* |
/* |
* vp is the current namei directory |
* vp is the current namei directory |
* ndp is the name to locate in that directory... |
* ndp is the name to locate in that directory... |
*/ |
*/ |
kernfs_lookup(dvp, ndp, p) |
kernfs_lookup(ap) |
struct vnode *dvp; |
struct vop_lookup_args /* { |
struct nameidata *ndp; |
struct vnode * a_dvp; |
struct proc *p; |
struct vnode ** a_vpp; |
{ |
struct componentname * a_cnp; |
char *pname = ndp->ni_ptr; |
} */ *ap; |
int error = ENOENT; |
{ |
int i; |
struct componentname *cnp = ap->a_cnp; |
|
struct vnode **vpp = ap->a_vpp; |
|
struct vnode *dvp = ap->a_dvp; |
|
char *pname = cnp->cn_nameptr; |
|
struct kern_target *kt; |
struct vnode *fvp; |
struct vnode *fvp; |
|
int error, i; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_lookup(%x)\n", ap); |
|
printf("kernfs_lookup(dp = %x, vpp = %x, cnp = %x)\n", dvp, vpp, ap->a_cnp); |
printf("kernfs_lookup(%s)\n", pname); |
printf("kernfs_lookup(%s)\n", pname); |
#endif |
#endif |
if (ndp->ni_namelen == 1 && *pname == '.') { |
|
ndp->ni_dvp = dvp; |
*vpp = NULLVP; |
ndp->ni_vp = dvp; |
|
|
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) |
|
return (EROFS); |
|
|
|
if (cnp->cn_namelen == 1 && *pname == '.') { |
|
*vpp = dvp; |
VREF(dvp); |
VREF(dvp); |
/*VOP_LOCK(dvp);*/ |
/*VOP_LOCK(dvp);*/ |
return (0); |
return (0); |
} |
} |
|
|
#if 0 |
#if 0 |
if (ndp->ni_namelen == 4 && bcmp(pname, "root", 4) == 0) { |
if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) { |
ndp->ni_dvp = rootdir; |
*vpp = rootdir; |
ndp->ni_vp = rootdir; |
|
VREF(rootdir); |
|
VREF(rootdir); |
VREF(rootdir); |
VOP_LOCK(rootdir); |
VOP_LOCK(rootdir); |
return (0); |
return (0); |
} |
} |
#endif |
#endif |
|
|
/* |
|
* /kern/rootdev is the root device |
|
*/ |
|
if (ndp->ni_namelen == 7 && bcmp(pname, "rootdev", 7) == 0) { |
|
if (vfinddev(rootdev, VBLK, &fvp)) |
|
return (ENXIO); |
|
ndp->ni_dvp = dvp; |
|
ndp->ni_vp = fvp; |
|
VREF(fvp); |
|
VOP_LOCK(fvp); |
|
return (0); |
|
} |
|
|
|
for (i = 0; i < nkern_targets; i++) { |
for (kt = kern_targets, i = 0; i < nkern_targets; kt++, i++) { |
struct kern_target *kt = &kern_targets[i]; |
if (cnp->cn_namelen == kt->kt_namlen && |
if (ndp->ni_namelen == strlen(kt->kt_name) && |
bcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
bcmp(kt->kt_name, pname, ndp->ni_namelen) == 0) { |
goto found; |
error = 0; |
|
break; |
|
} |
|
} |
} |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_lookup: i = %d, error = %d\n", i, error); |
printf("kernfs_lookup: i = %d, failed", i); |
#endif |
#endif |
|
|
if (error) |
return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); |
goto bad; |
|
|
found: |
|
if (kt->kt_tag == KTT_DEVICE) { |
|
dev_t *dp = kt->kt_data; |
|
loop: |
|
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) |
|
return (ENOENT); |
|
*vpp = fvp; |
|
if (vget(fvp, 1)) |
|
goto loop; |
|
return (0); |
|
} |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_lookup: allocate new vnode\n"); |
printf("kernfs_lookup: allocate new vnode\n"); |
#endif |
#endif |
error = getnewvnode(VT_KERNFS, dvp->v_mount, &kernfs_vnodeops, &fvp); |
if (error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, |
if (error) |
&fvp)) |
goto bad; |
return (error); |
VTOKERN(fvp)->kf_kt = &kern_targets[i]; |
|
fvp->v_type = VTOKERN(fvp)->kf_kt->kt_vtype; |
MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP, |
ndp->ni_dvp = dvp; |
M_WAITOK); |
ndp->ni_vp = fvp; |
VTOKERN(fvp)->kf_kt = kt; |
|
fvp->v_type = kt->kt_vtype; |
|
*vpp = fvp; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_lookup: newvp = %x\n", fvp); |
printf("kernfs_lookup: newvp = %x\n", fvp); |
#endif |
#endif |
return (0); |
return (0); |
|
|
bad:; |
|
ndp->ni_dvp = dvp; |
|
ndp->ni_vp = NULL; |
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_lookup: error = %d\n", error); |
|
#endif |
|
return (error); |
|
} |
} |
|
|
kernfs_open(vp, mode, cred, p) |
kernfs_open(ap) |
struct vnode *vp; |
struct vop_open_args /* { |
int mode; |
struct vnode *a_vp; |
struct ucred *cred; |
int a_mode; |
struct proc *p; |
struct ucred *a_cred; |
|
struct proc *a_p; |
|
} */ *ap; |
{ |
{ |
int error; |
|
struct filedesc *fdp; |
|
struct file *fp; |
|
int dfd; |
|
int fd; |
|
|
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_open\n"); |
|
#endif |
|
|
|
/* |
|
* Can always open the root (modulo perms) |
|
*/ |
|
if (vp->v_flag & VROOT) |
|
return (0); |
|
|
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_open, mode = %x, file = %s\n", |
|
mode, VTOKERN(vp)->kf_kt->kt_name); |
|
#endif |
|
|
|
if ((mode & FWRITE) && VTOKERN(vp)->kf_kt->kt_rw != KTM_RW) |
|
return (EACCES); |
|
|
|
|
/* Only need to check access permissions. */ |
return (0); |
return (0); |
} |
} |
|
|
kernfs_getattr(vp, vap, cred, p) |
int |
struct vnode *vp; |
kernfs_access(ap) |
struct vattr *vap; |
struct vop_access_args /* { |
struct ucred *cred; |
struct vnode *a_vp; |
struct proc *p; |
int a_mode; |
{ |
struct ucred *a_cred; |
|
struct proc *a_p; |
|
} */ *ap; |
|
{ |
|
struct vnode *vp = ap->a_vp; |
|
mode_t fmode = |
|
(vp->v_flag & VROOT) ? DIR_MODE : VTOKERN(vp)->kf_kt->kt_mode; |
|
|
|
return (vaccess(fmode, (uid_t)0, (gid_t)0, ap->a_mode, ap->a_cred)); |
|
} |
|
|
|
kernfs_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 timeval tv; |
int error = 0; |
int error = 0; |
char strbuf[KSTRING]; |
char strbuf[KSTRING], *buf; |
struct kern_target *kt = VTOKERN(vp)->kf_kt; |
|
|
|
bzero((caddr_t) vap, sizeof(*vap)); |
bzero((caddr_t) vap, sizeof(*vap)); |
vattr_null(vap); |
vattr_null(vap); |
vap->va_uid = 0; |
vap->va_uid = 0; |
vap->va_gid = 0; |
vap->va_gid = 0; |
vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; |
vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; |
/* vap->va_qsize = 0; */ |
vap->va_size = 0; |
vap->va_blocksize = DEV_BSIZE; |
vap->va_blocksize = DEV_BSIZE; |
microtime(&vap->va_atime); |
microtime(&tv); |
|
TIMEVAL_TO_TIMESPEC(&tv, &vap->va_atime); |
vap->va_mtime = vap->va_atime; |
vap->va_mtime = vap->va_atime; |
vap->va_ctime = vap->va_ctime; |
vap->va_ctime = vap->va_ctime; |
vap->va_gen = 0; |
vap->va_gen = 0; |
vap->va_flags = 0; |
vap->va_flags = 0; |
vap->va_rdev = 0; |
vap->va_rdev = 0; |
/* vap->va_qbytes = 0; */ |
|
vap->va_bytes = 0; |
vap->va_bytes = 0; |
|
|
if (vp->v_flag & VROOT) { |
if (vp->v_flag & VROOT) { |
Line 400 kernfs_getattr(vp, vap, cred, p) |
|
Line 359 kernfs_getattr(vp, vap, cred, p) |
|
printf("kernfs_getattr: stat rootdir\n"); |
printf("kernfs_getattr: stat rootdir\n"); |
#endif |
#endif |
vap->va_type = VDIR; |
vap->va_type = VDIR; |
vap->va_mode = KTM_DIR_MODE; |
vap->va_mode = DIR_MODE; |
vap->va_nlink = 2; |
vap->va_nlink = 2; |
vap->va_fileid = 2; |
vap->va_fileid = 2; |
vap->va_size = DEV_BSIZE; |
vap->va_size = DEV_BSIZE; |
} else { |
} else { |
|
struct kern_target *kt = VTOKERN(vp)->kf_kt; |
|
int nbytes, total; |
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_getattr: stat target %s\n", kt->kt_name); |
printf("kernfs_getattr: stat target %s\n", kt->kt_name); |
#endif |
#endif |
vap->va_type = kt->kt_vtype; |
vap->va_type = kt->kt_vtype; |
vap->va_mode = (kt->kt_rw ? KTM_RW_MODE : KTM_RO_MODE); |
vap->va_mode = kt->kt_mode; |
vap->va_nlink = 1; |
vap->va_nlink = 1; |
vap->va_fileid = 3 + (kt - kern_targets) / sizeof(*kt); |
vap->va_fileid = 1 + (kt - kern_targets) / sizeof(*kt); |
error = kernfs_xread(kt, strbuf, sizeof(strbuf), &vap->va_size); |
total = 0; |
|
while (buf = strbuf, |
|
nbytes = kernfs_xread(kt, total, &buf, sizeof(strbuf))) |
|
total += nbytes; |
|
vap->va_size = total; |
} |
} |
|
|
vp->v_type = vap->va_type; |
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_getattr: return error %d\n", error); |
printf("kernfs_getattr: return error %d\n", error); |
#endif |
#endif |
return (error); |
return (error); |
} |
} |
|
|
kernfs_setattr(vp, vap, cred, p) |
kernfs_setattr(ap) |
struct vnode *vp; |
struct vop_setattr_args /* { |
struct vattr *vap; |
struct vnode *a_vp; |
struct ucred *cred; |
struct vattr *a_vap; |
struct proc *p; |
struct ucred *a_cred; |
|
struct proc *a_p; |
|
} */ *ap; |
{ |
{ |
|
|
/* |
/* |
Line 438 kernfs_setattr(vp, vap, cred, p) |
|
Line 404 kernfs_setattr(vp, vap, cred, p) |
|
return (0); |
return (0); |
} |
} |
|
|
static int |
int |
kernfs_read(vp, uio, ioflag, cred) |
kernfs_read(ap) |
struct vnode *vp; |
struct vop_read_args /* { |
struct uio *uio; |
struct vnode *a_vp; |
int ioflag; |
struct uio *a_uio; |
struct ucred *cred; |
int a_ioflag; |
|
struct ucred *a_cred; |
|
} */ *ap; |
{ |
{ |
struct kern_target *kt = VTOKERN(vp)->kf_kt; |
struct vnode *vp = ap->a_vp; |
char strbuf[KSTRING]; |
struct uio *uio = ap->a_uio; |
int off = uio->uio_offset; |
struct kern_target *kt; |
int len = 0; |
char strbuf[KSTRING], *buf; |
char *cp = strbuf; |
int off, len; |
int error; |
int error; |
|
|
|
if (vp->v_type == VDIR) |
|
return (EOPNOTSUPP); |
|
|
|
kt = VTOKERN(vp)->kf_kt; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kern_read %s\n", kt->kt_name); |
printf("kern_read %s\n", kt->kt_name); |
#endif |
#endif |
|
|
if (vp->v_flag & VROOT) |
off = uio->uio_offset; |
return (0); |
#if 0 |
|
while (buf = strbuf, |
error = kernfs_xread(kt, strbuf, sizeof(strbuf), &len); |
#else |
if (error) |
if (buf = strbuf, |
return (error); |
#endif |
cp = strbuf + off; |
len = kernfs_xread(kt, off, &buf, sizeof(strbuf))) { |
len -= off; |
if (error = uiomove(buf, len, uio)) |
return (uiomove(cp, len, uio)); |
return (error); |
|
off += len; |
|
} |
|
return (0); |
} |
} |
|
|
static int |
int |
kernfs_write(vp, uio, ioflag, cred) |
kernfs_write(ap) |
struct vnode *vp; |
struct vop_write_args /* { |
struct uio *uio; |
struct vnode *a_vp; |
int ioflag; |
struct uio *a_uio; |
struct ucred *cred; |
int a_ioflag; |
|
struct ucred *a_cred; |
|
} */ *ap; |
{ |
{ |
struct kern_target *kt = VTOKERN(vp)->kf_kt; |
struct vnode *vp = ap->a_vp; |
|
struct uio *uio = ap->a_uio; |
|
struct kern_target *kt; |
|
int error, xlen; |
char strbuf[KSTRING]; |
char strbuf[KSTRING]; |
int len = uio->uio_resid; |
|
char *cp = strbuf; |
if (vp->v_type == VDIR) |
int xlen; |
return (EOPNOTSUPP); |
int error; |
|
|
kt = VTOKERN(vp)->kf_kt; |
|
|
if (uio->uio_offset != 0) |
if (uio->uio_offset != 0) |
return (EINVAL); |
return (EINVAL); |
|
|
xlen = min(uio->uio_resid, KSTRING-1); |
xlen = min(uio->uio_resid, KSTRING-1); |
error = uiomove(strbuf, xlen, uio); |
if (error = uiomove(strbuf, xlen, uio)) |
if (error) |
|
return (error); |
return (error); |
|
|
if (uio->uio_resid != 0) |
if (uio->uio_resid != 0) |
Line 496 kernfs_write(vp, uio, ioflag, cred) |
|
Line 478 kernfs_write(vp, uio, ioflag, cred) |
|
return (kernfs_xwrite(kt, strbuf, xlen)); |
return (kernfs_xwrite(kt, strbuf, xlen)); |
} |
} |
|
|
kernfs_readdir(vp, uio, cred, eofflagp) |
kernfs_readdir(ap) |
struct vnode *vp; |
struct vop_readdir_args /* { |
struct uio *uio; |
struct vnode *a_vp; |
struct ucred *cred; |
struct uio *a_uio; |
int *eofflagp; |
struct ucred *a_cred; |
|
int *a_eofflag; |
|
u_long *a_cookies; |
|
int a_ncookies; |
|
} */ *ap; |
{ |
{ |
struct filedesc *fdp; |
struct uio *uio = ap->a_uio; |
|
struct dirent d; |
|
struct kern_target *kt; |
int i; |
int i; |
int error; |
int error; |
|
u_long *cookies = ap->a_cookies; |
|
int ncookies = ap->a_ncookies; |
|
|
|
if (ap->a_vp->v_type != VDIR) |
|
return (ENOTDIR); |
|
|
|
if (uio->uio_resid < UIO_MX) |
|
return (EINVAL); |
|
if (uio->uio_offset < 0) |
|
return (EINVAL); |
|
|
i = uio->uio_offset / UIO_MX; |
|
error = 0; |
error = 0; |
while (uio->uio_resid > 0) { |
i = uio->uio_offset; |
|
bzero((caddr_t)&d, UIO_MX); |
|
d.d_reclen = UIO_MX; |
|
|
|
for (kt = &kern_targets[i]; |
|
uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) { |
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_readdir: i = %d\n", i); |
printf("kernfs_readdir: i = %d\n", i); |
#endif |
#endif |
if (i >= nkern_targets) { |
|
*eofflagp = 1; |
if (kt->kt_tag == KTT_DEVICE) { |
break; |
dev_t *dp = kt->kt_data; |
} |
struct vnode *fvp; |
{ |
|
struct direct d; |
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) |
struct direct *dp = &d; |
continue; |
struct kern_target *kt = &kern_targets[i]; |
|
|
|
bzero((caddr_t) dp, UIO_MX); |
|
|
|
dp->d_namlen = strlen(kt->kt_name); |
|
bcopy(kt->kt_name, dp->d_name, dp->d_namlen+1); |
|
|
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_readdir: name = %s, len = %d\n", |
|
dp->d_name, dp->d_namlen); |
|
#endif |
|
/* |
|
* Fill in the remaining fields |
|
*/ |
|
dp->d_reclen = UIO_MX; |
|
dp->d_ino = i + 3; |
|
/* |
|
* And ship to userland |
|
*/ |
|
error = uiomove((caddr_t) dp, UIO_MX, uio); |
|
if (error) |
|
break; |
|
} |
} |
i++; |
|
} |
|
|
|
uio->uio_offset = i * UIO_MX; |
d.d_fileno = i + 3; |
|
d.d_namlen = kt->kt_namlen; |
|
bcopy(kt->kt_name, d.d_name, kt->kt_namlen + 1); |
|
d.d_type = kt->kt_type; |
|
|
|
if (error = uiomove((caddr_t)&d, UIO_MX, uio)) |
|
break; |
|
if (ncookies-- > 0) |
|
*cookies++ = i + 1; |
|
} |
|
|
|
uio->uio_offset = i; |
return (error); |
return (error); |
} |
} |
|
|
kernfs_inactive(vp, p) |
kernfs_inactive(ap) |
struct vnode *vp; |
struct vop_inactive_args /* { |
struct proc *p; |
struct vnode *a_vp; |
|
} */ *ap; |
{ |
{ |
|
struct vnode *vp = ap->a_vp; |
|
|
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_inactive(%x)\n", vp); |
|
#endif |
/* |
/* |
* Clear out the v_type field to avoid |
* Clear out the v_type field to avoid |
* nasty things happening in vgone(). |
* nasty things happening in vgone(). |
*/ |
*/ |
vp->v_type = VNON; |
vp->v_type = VNON; |
|
return (0); |
|
} |
|
|
|
kernfs_reclaim(ap) |
|
struct vop_reclaim_args /* { |
|
struct vnode *a_vp; |
|
} */ *ap; |
|
{ |
|
struct vnode *vp = ap->a_vp; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_inactive(%x)\n", vp); |
printf("kernfs_reclaim(%x)\n", vp); |
#endif |
#endif |
|
if (vp->v_data) { |
|
FREE(vp->v_data, M_TEMP); |
|
vp->v_data = 0; |
|
} |
return (0); |
return (0); |
} |
} |
|
|
/* |
/* |
* Print out the contents of a kernfs vnode. |
* Return POSIX pathconf information applicable to special devices. |
|
*/ |
|
kernfs_pathconf(ap) |
|
struct vop_pathconf_args /* { |
|
struct vnode *a_vp; |
|
int a_name; |
|
register_t *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 /dev/fd vnode. |
*/ |
*/ |
/* ARGSUSED */ |
/* ARGSUSED */ |
kernfs_print(vp) |
kernfs_print(ap) |
struct vnode *vp; |
struct vop_print_args /* { |
|
struct vnode *a_vp; |
|
} */ *ap; |
|
{ |
|
|
|
printf("tag VT_KERNFS, kernfs vnode\n"); |
|
return (0); |
|
} |
|
|
|
/*void*/ |
|
kernfs_vfree(ap) |
|
struct vop_vfree_args /* { |
|
struct vnode *a_pvp; |
|
ino_t a_ino; |
|
int a_mode; |
|
} */ *ap; |
{ |
{ |
printf("tag VT_NON, kernfs vnode\n"); |
|
|
return (0); |
} |
} |
|
|
/* |
/* |
* kernfs vnode unsupported operation |
* /dev/fd vnode unsupported operation |
*/ |
*/ |
kernfs_enotsupp() |
kernfs_enotsupp() |
{ |
{ |
|
|
return (EOPNOTSUPP); |
return (EOPNOTSUPP); |
} |
} |
|
|
/* |
/* |
* kernfs "should never get here" operation |
* /dev/fd "should never get here" operation |
*/ |
*/ |
kernfs_badop() |
kernfs_badop() |
{ |
{ |
|
|
panic("kernfs: bad op"); |
panic("kernfs: bad op"); |
/* NOTREACHED */ |
/* NOTREACHED */ |
} |
} |
|
|
*/ |
*/ |
kernfs_nullop() |
kernfs_nullop() |
{ |
{ |
|
|
return (0); |
return (0); |
} |
} |
|
|
#define kernfs_create ((int (*) __P(( \ |
#define kernfs_create ((int (*) __P((struct vop_create_args *)))kernfs_enotsupp) |
struct nameidata *ndp, \ |
#define kernfs_mknod ((int (*) __P((struct vop_mknod_args *)))kernfs_enotsupp) |
struct vattr *vap, \ |
#define kernfs_close ((int (*) __P((struct vop_close_args *)))nullop) |
struct proc *p))) kernfs_enotsupp) |
#define kernfs_ioctl ((int (*) __P((struct vop_ioctl_args *)))kernfs_enotsupp) |
#define kernfs_mknod ((int (*) __P(( \ |
#define kernfs_select ((int (*) __P((struct vop_select_args *)))kernfs_enotsupp) |
struct nameidata *ndp, \ |
#define kernfs_mmap ((int (*) __P((struct vop_mmap_args *)))kernfs_enotsupp) |
struct vattr *vap, \ |
#define kernfs_fsync ((int (*) __P((struct vop_fsync_args *)))nullop) |
struct ucred *cred, \ |
#define kernfs_seek ((int (*) __P((struct vop_seek_args *)))nullop) |
struct proc *p))) kernfs_enotsupp) |
#define kernfs_remove ((int (*) __P((struct vop_remove_args *)))kernfs_enotsupp) |
#define kernfs_close ((int (*) __P(( \ |
#define kernfs_link ((int (*) __P((struct vop_link_args *)))kernfs_enotsupp) |
struct vnode *vp, \ |
#define kernfs_rename ((int (*) __P((struct vop_rename_args *)))kernfs_enotsupp) |
int fflag, \ |
#define kernfs_mkdir ((int (*) __P((struct vop_mkdir_args *)))kernfs_enotsupp) |
struct ucred *cred, \ |
#define kernfs_rmdir ((int (*) __P((struct vop_rmdir_args *)))kernfs_enotsupp) |
struct proc *p))) nullop) |
#define kernfs_symlink ((int (*) __P((struct vop_symlink_args *)))kernfs_enotsupp) |
#define kernfs_ioctl ((int (*) __P(( \ |
#define kernfs_readlink \ |
struct vnode *vp, \ |
((int (*) __P((struct vop_readlink_args *)))kernfs_enotsupp) |
int command, \ |
#define kernfs_abortop ((int (*) __P((struct vop_abortop_args *)))nullop) |
caddr_t data, \ |
#define kernfs_lock ((int (*) __P((struct vop_lock_args *)))nullop) |
int fflag, \ |
#define kernfs_unlock ((int (*) __P((struct vop_unlock_args *)))nullop) |
|
#define kernfs_bmap ((int (*) __P((struct vop_bmap_args *)))kernfs_badop) |
|
#define kernfs_strategy ((int (*) __P((struct vop_strategy_args *)))kernfs_badop) |
|
#define kernfs_islocked ((int (*) __P((struct vop_islocked_args *)))nullop) |
|
#define kernfs_advlock ((int (*) __P((struct vop_advlock_args *)))kernfs_enotsupp) |
|
#define kernfs_blkatoff \ |
|
((int (*) __P((struct vop_blkatoff_args *)))kernfs_enotsupp) |
|
#define kernfs_valloc ((int(*) __P(( \ |
|
struct vnode *pvp, \ |
|
int mode, \ |
struct ucred *cred, \ |
struct ucred *cred, \ |
struct proc *p))) kernfs_enotsupp) |
struct vnode **vpp))) kernfs_enotsupp) |
#define kernfs_select ((int (*) __P(( \ |
#define kernfs_truncate \ |
struct vnode *vp, \ |
((int (*) __P((struct vop_truncate_args *)))kernfs_enotsupp) |
int which, \ |
#define kernfs_update ((int (*) __P((struct vop_update_args *)))kernfs_enotsupp) |
int fflags, \ |
#define kernfs_bwrite ((int (*) __P((struct vop_bwrite_args *)))kernfs_enotsupp) |
struct ucred *cred, \ |
|
struct proc *p))) kernfs_enotsupp) |
int (**kernfs_vnodeop_p)(); |
#define kernfs_mmap ((int (*) __P(( \ |
struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { |
struct vnode *vp, \ |
{ &vop_default_desc, vn_default_error }, |
int fflags, \ |
{ &vop_lookup_desc, kernfs_lookup }, /* lookup */ |
struct ucred *cred, \ |
{ &vop_create_desc, kernfs_create }, /* create */ |
struct proc *p))) kernfs_enotsupp) |
{ &vop_mknod_desc, kernfs_mknod }, /* mknod */ |
#define kernfs_fsync ((int (*) __P(( \ |
{ &vop_open_desc, kernfs_open }, /* open */ |
struct vnode *vp, \ |
{ &vop_close_desc, kernfs_close }, /* close */ |
int fflags, \ |
{ &vop_access_desc, kernfs_access }, /* access */ |
struct ucred *cred, \ |
{ &vop_getattr_desc, kernfs_getattr }, /* getattr */ |
int waitfor, \ |
{ &vop_setattr_desc, kernfs_setattr }, /* setattr */ |
struct proc *p))) nullop) |
{ &vop_read_desc, kernfs_read }, /* read */ |
#define kernfs_seek ((int (*) __P(( \ |
{ &vop_write_desc, kernfs_write }, /* write */ |
struct vnode *vp, \ |
{ &vop_ioctl_desc, kernfs_ioctl }, /* ioctl */ |
off_t oldoff, \ |
{ &vop_select_desc, kernfs_select }, /* select */ |
off_t newoff, \ |
{ &vop_mmap_desc, kernfs_mmap }, /* mmap */ |
struct ucred *cred))) nullop) |
{ &vop_fsync_desc, kernfs_fsync }, /* fsync */ |
#define kernfs_remove ((int (*) __P(( \ |
{ &vop_seek_desc, kernfs_seek }, /* seek */ |
struct nameidata *ndp, \ |
{ &vop_remove_desc, kernfs_remove }, /* remove */ |
struct proc *p))) kernfs_enotsupp) |
{ &vop_link_desc, kernfs_link }, /* link */ |
#define kernfs_link ((int (*) __P(( \ |
{ &vop_rename_desc, kernfs_rename }, /* rename */ |
struct vnode *vp, \ |
{ &vop_mkdir_desc, kernfs_mkdir }, /* mkdir */ |
struct nameidata *ndp, \ |
{ &vop_rmdir_desc, kernfs_rmdir }, /* rmdir */ |
struct proc *p))) kernfs_enotsupp) |
{ &vop_symlink_desc, kernfs_symlink }, /* symlink */ |
#define kernfs_rename ((int (*) __P(( \ |
{ &vop_readdir_desc, kernfs_readdir }, /* readdir */ |
struct nameidata *fndp, \ |
{ &vop_readlink_desc, kernfs_readlink },/* readlink */ |
struct nameidata *tdnp, \ |
{ &vop_abortop_desc, kernfs_abortop }, /* abortop */ |
struct proc *p))) kernfs_enotsupp) |
{ &vop_inactive_desc, kernfs_inactive },/* inactive */ |
#define kernfs_mkdir ((int (*) __P(( \ |
{ &vop_reclaim_desc, kernfs_reclaim }, /* reclaim */ |
struct nameidata *ndp, \ |
{ &vop_lock_desc, kernfs_lock }, /* lock */ |
struct vattr *vap, \ |
{ &vop_unlock_desc, kernfs_unlock }, /* unlock */ |
struct proc *p))) kernfs_enotsupp) |
{ &vop_bmap_desc, kernfs_bmap }, /* bmap */ |
#define kernfs_rmdir ((int (*) __P(( \ |
{ &vop_strategy_desc, kernfs_strategy },/* strategy */ |
struct nameidata *ndp, \ |
{ &vop_print_desc, kernfs_print }, /* print */ |
struct proc *p))) kernfs_enotsupp) |
{ &vop_islocked_desc, kernfs_islocked },/* islocked */ |
#define kernfs_symlink ((int (*) __P(( \ |
{ &vop_pathconf_desc, kernfs_pathconf },/* pathconf */ |
struct nameidata *ndp, \ |
{ &vop_advlock_desc, kernfs_advlock }, /* advlock */ |
struct vattr *vap, \ |
{ &vop_blkatoff_desc, kernfs_blkatoff },/* blkatoff */ |
char *target, \ |
{ &vop_valloc_desc, kernfs_valloc }, /* valloc */ |
struct proc *p))) kernfs_enotsupp) |
{ &vop_vfree_desc, kernfs_vfree }, /* vfree */ |
#define kernfs_readlink ((int (*) __P(( \ |
{ &vop_truncate_desc, kernfs_truncate },/* truncate */ |
struct vnode *vp, \ |
{ &vop_update_desc, kernfs_update }, /* update */ |
struct uio *uio, \ |
{ &vop_bwrite_desc, kernfs_bwrite }, /* bwrite */ |
struct ucred *cred))) kernfs_enotsupp) |
{ (struct vnodeop_desc*)NULL, (int(*)())NULL } |
#define kernfs_abortop ((int (*) __P(( \ |
|
struct nameidata *ndp))) nullop) |
|
#ifdef KERNFS_DIAGNOSTIC |
|
int kernfs_reclaim(vp) |
|
struct vnode *vp; |
|
{ |
|
printf("kernfs_reclaim(%x)\n", vp); |
|
return (0); |
|
} |
|
#else |
|
#define kernfs_reclaim ((int (*) __P(( \ |
|
struct vnode *vp))) nullop) |
|
#endif |
|
#define kernfs_lock ((int (*) __P(( \ |
|
struct vnode *vp))) nullop) |
|
#define kernfs_unlock ((int (*) __P(( \ |
|
struct vnode *vp))) nullop) |
|
#define kernfs_bmap ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
daddr_t bn, \ |
|
struct vnode **vpp, \ |
|
daddr_t *bnp))) kernfs_badop) |
|
#define kernfs_strategy ((int (*) __P(( \ |
|
struct buf *bp))) kernfs_badop) |
|
#define kernfs_islocked ((int (*) __P(( \ |
|
struct vnode *vp))) nullop) |
|
#define kernfs_advlock ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
caddr_t id, \ |
|
int op, \ |
|
struct flock *fl, \ |
|
int flags))) kernfs_enotsupp) |
|
|
|
struct vnodeops kernfs_vnodeops = { |
|
kernfs_lookup, /* lookup */ |
|
kernfs_create, /* create */ |
|
kernfs_mknod, /* mknod */ |
|
kernfs_open, /* open */ |
|
kernfs_close, /* close */ |
|
kernfs_access, /* access */ |
|
kernfs_getattr, /* getattr */ |
|
kernfs_setattr, /* setattr */ |
|
kernfs_read, /* read */ |
|
kernfs_write, /* write */ |
|
kernfs_ioctl, /* ioctl */ |
|
kernfs_select, /* select */ |
|
kernfs_mmap, /* mmap */ |
|
kernfs_fsync, /* fsync */ |
|
kernfs_seek, /* seek */ |
|
kernfs_remove, /* remove */ |
|
kernfs_link, /* link */ |
|
kernfs_rename, /* rename */ |
|
kernfs_mkdir, /* mkdir */ |
|
kernfs_rmdir, /* rmdir */ |
|
kernfs_symlink, /* symlink */ |
|
kernfs_readdir, /* readdir */ |
|
kernfs_readlink, /* readlink */ |
|
kernfs_abortop, /* abortop */ |
|
kernfs_inactive, /* inactive */ |
|
kernfs_reclaim, /* reclaim */ |
|
kernfs_lock, /* lock */ |
|
kernfs_unlock, /* unlock */ |
|
kernfs_bmap, /* bmap */ |
|
kernfs_strategy, /* strategy */ |
|
kernfs_print, /* print */ |
|
kernfs_islocked, /* islocked */ |
|
kernfs_advlock, /* advlock */ |
|
}; |
}; |
|
struct vnodeopv_desc kernfs_vnodeop_opv_desc = |
|
{ &kernfs_vnodeop_p, kernfs_vnodeop_entries }; |