version 1.23, 1994/06/08 11:33:21 |
version 1.39, 1995/10/09 14:25:02 |
|
|
|
/* $NetBSD$ */ |
|
|
/* |
/* |
* Copyright (c) 1992, 1993 |
* Copyright (c) 1992, 1993 |
* The Regents of the University of California. All rights reserved. |
* The Regents of the University of California. All rights reserved. |
|
|
* 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.6 (Berkeley) 2/10/94 |
* @(#)kernfs_vnops.c 8.9 (Berkeley) 6/15/94 |
* $Id$ |
|
*/ |
*/ |
|
|
/* |
/* |
|
|
#include <sys/namei.h> |
#include <sys/namei.h> |
#include <sys/buf.h> |
#include <sys/buf.h> |
#include <sys/dirent.h> |
#include <sys/dirent.h> |
|
#include <sys/msgbuf.h> |
#include <miscfs/kernfs/kernfs.h> |
#include <miscfs/kernfs/kernfs.h> |
|
|
#define KSTRING 256 /* Largest I/O available via this filesystem */ |
#define KSTRING 256 /* Largest I/O available via this filesystem */ |
Line 77 struct kern_target { |
|
Line 79 struct kern_target { |
|
#define KTT_HOSTNAME 47 |
#define KTT_HOSTNAME 47 |
#define KTT_AVENRUN 53 |
#define KTT_AVENRUN 53 |
#define KTT_DEVICE 71 |
#define KTT_DEVICE 71 |
|
#define KTT_MSGBUF 89 |
u_char kt_tag; |
u_char kt_tag; |
u_char kt_vtype; |
u_char kt_vtype; |
mode_t kt_mode; |
mode_t kt_mode; |
Line 91 struct kern_target { |
|
Line 94 struct kern_target { |
|
{ DT_REG, N("hostname"), 0, KTT_HOSTNAME, VREG, WRITE_MODE }, |
{ DT_REG, N("hostname"), 0, KTT_HOSTNAME, VREG, WRITE_MODE }, |
{ DT_REG, N("hz"), &hz, KTT_INT, VREG, READ_MODE }, |
{ DT_REG, N("hz"), &hz, KTT_INT, VREG, READ_MODE }, |
{ DT_REG, N("loadavg"), 0, KTT_AVENRUN, 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("pagesize"), &cnt.v_page_size, KTT_INT, VREG, READ_MODE }, |
{ DT_REG, N("physmem"), &physmem, KTT_INT, VREG, READ_MODE }, |
{ DT_REG, N("physmem"), &physmem, KTT_INT, VREG, READ_MODE }, |
#if 0 |
#if 0 |
Line 104 struct kern_target { |
|
Line 108 struct kern_target { |
|
}; |
}; |
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; |
|
{ |
{ |
|
|
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) |
|
return (EINVAL); |
|
|
|
bcopy(cp, buf, xlen); |
*bufp = cp; |
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 144 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, "%ld %ld %ld %ld\n", |
averunnable.fscale = FSCALE; |
|
sprintf(*bufp, "%ld %ld %ld %ld\n", |
averunnable.ldavg[0], averunnable.ldavg[1], |
averunnable.ldavg[0], averunnable.ldavg[1], |
averunnable.ldavg[2], averunnable.fscale); |
averunnable.ldavg[2], averunnable.fscale); |
break; |
break; |
|
|
default: |
default: |
return (EIO); |
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; |
Line 211 kernfs_lookup(ap) |
|
Line 231 kernfs_lookup(ap) |
|
printf("kernfs_lookup(%s)\n", pname); |
printf("kernfs_lookup(%s)\n", pname); |
#endif |
#endif |
|
|
|
*vpp = NULLVP; |
|
|
|
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) |
|
return (EROFS); |
|
|
if (cnp->cn_namelen == 1 && *pname == '.') { |
if (cnp->cn_namelen == 1 && *pname == '.') { |
*vpp = dvp; |
*vpp = dvp; |
VREF(dvp); |
VREF(dvp); |
Line 227 kernfs_lookup(ap) |
|
Line 252 kernfs_lookup(ap) |
|
} |
} |
#endif |
#endif |
|
|
for (error = ENOENT, kt = kern_targets, i = 0; i < nkern_targets; |
for (kt = kern_targets, i = 0; i < nkern_targets; kt++, i++) { |
kt++, i++) { |
if (cnp->cn_namelen == kt->kt_namlen && |
if (cnp->cn_namelen == strlen(kt->kt_name) && |
bcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
bcmp(kt->kt_name, pname, cnp->cn_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); |
return (error); |
|
|
|
|
found: |
if (kt->kt_tag == KTT_DEVICE) { |
if (kt->kt_tag == KTT_DEVICE) { |
dev_t *dp = kt->kt_data; |
dev_t *dp = kt->kt_data; |
|
loop: |
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) |
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) |
return (ENXIO); |
return (ENOENT); |
*vpp = fvp; |
*vpp = fvp; |
VREF(fvp); |
if (vget(fvp, 1)) |
VOP_LOCK(fvp); |
goto loop; |
return (0); |
return (0); |
} |
} |
|
|
|
|
return (0); |
return (0); |
} |
} |
|
|
static int |
int |
kernfs_access(ap) |
kernfs_access(ap) |
struct vop_access_args /* { |
struct vop_access_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
int a_mode; |
int a_mode; |
struct ucred *a_cred; |
struct ucred *a_cred; |
struct proc *a_p; |
struct proc *a_p; |
} */ *ap; |
} */ *ap; |
{ |
{ |
register struct vnode *vp = ap->a_vp; |
struct vnode *vp = ap->a_vp; |
register struct ucred *cred = ap->a_cred; |
|
mode_t amode = ap->a_mode; |
|
mode_t fmode = |
mode_t fmode = |
(vp->v_flag & VROOT) ? DIR_MODE : VTOKERN(vp)->kf_kt->kt_mode; |
(vp->v_flag & VROOT) ? DIR_MODE : VTOKERN(vp)->kf_kt->kt_mode; |
mode_t mask = 0; |
|
register gid_t *gp; |
|
int i; |
|
|
|
/* Some files are simply not modifiable. */ |
return (vaccess(fmode, (uid_t)0, (gid_t)0, ap->a_mode, ap->a_cred)); |
if ((amode & VWRITE) && (fmode & (S_IWUSR|S_IWGRP|S_IWOTH)) == 0) |
|
return (EPERM); |
|
|
|
/* Root can do anything else. */ |
|
if (cred->cr_uid == 0) |
|
return (0); |
|
|
|
/* Check for group 0 (wheel) permissions. */ |
|
for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) |
|
if (*gp == 0) { |
|
if (amode & VEXEC) |
|
mask |= S_IXGRP; |
|
if (amode & VREAD) |
|
mask |= S_IRGRP; |
|
if (amode & VWRITE) |
|
mask |= S_IWGRP; |
|
return ((fmode & mask) == mask ? 0 : EACCES); |
|
} |
|
|
|
/* Otherwise, check everyone else. */ |
|
if (amode & VEXEC) |
|
mask |= S_IXOTH; |
|
if (amode & VREAD) |
|
mask |= S_IROTH; |
|
if (amode & VWRITE) |
|
mask |= S_IWOTH; |
|
return ((fmode & mask) == mask ? 0 : EACCES); |
|
} |
} |
|
|
kernfs_getattr(ap) |
kernfs_getattr(ap) |
Line 343 kernfs_getattr(ap) |
|
Line 334 kernfs_getattr(ap) |
|
{ |
{ |
struct vnode *vp = ap->a_vp; |
struct vnode *vp = ap->a_vp; |
struct vattr *vap = ap->a_vap; |
struct vattr *vap = ap->a_vap; |
|
struct timeval tv; |
int error = 0; |
int error = 0; |
char strbuf[KSTRING]; |
char strbuf[KSTRING], *buf; |
|
|
bzero((caddr_t) vap, sizeof(*vap)); |
bzero((caddr_t) vap, sizeof(*vap)); |
vattr_null(vap); |
vattr_null(vap); |
Line 353 kernfs_getattr(ap) |
|
Line 345 kernfs_getattr(ap) |
|
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_size = 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; |
Line 372 kernfs_getattr(ap) |
|
Line 365 kernfs_getattr(ap) |
|
vap->va_size = DEV_BSIZE; |
vap->va_size = DEV_BSIZE; |
} else { |
} else { |
struct kern_target *kt = VTOKERN(vp)->kf_kt; |
struct kern_target *kt = VTOKERN(vp)->kf_kt; |
int nbytes; |
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_mode; |
vap->va_mode = kt->kt_mode; |
vap->va_nlink = 1; |
vap->va_nlink = 1; |
vap->va_fileid = 1 + (kt - kern_targets) / sizeof(*kt); |
vap->va_fileid = 3 + (kt - kern_targets); |
error = kernfs_xread(kt, strbuf, sizeof(strbuf), &nbytes); |
total = 0; |
vap->va_size = nbytes; |
while (buf = strbuf, |
|
nbytes = kernfs_xread(kt, total, &buf, sizeof(strbuf))) |
|
total += nbytes; |
|
vap->va_size = total; |
} |
} |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
Line 408 kernfs_setattr(ap) |
|
Line 404 kernfs_setattr(ap) |
|
return (0); |
return (0); |
} |
} |
|
|
static int |
int |
kernfs_read(ap) |
kernfs_read(ap) |
struct vop_read_args /* { |
struct vop_read_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
|
|
struct vnode *vp = ap->a_vp; |
struct vnode *vp = ap->a_vp; |
struct uio *uio = ap->a_uio; |
struct uio *uio = ap->a_uio; |
struct kern_target *kt; |
struct kern_target *kt; |
char strbuf[KSTRING]; |
char strbuf[KSTRING], *buf; |
int off = uio->uio_offset; |
int off, len; |
int error, len; |
int error; |
char *cp; |
|
|
|
if (vp->v_type == VDIR) |
if (vp->v_type == VDIR) |
return (EOPNOTSUPP); |
return (EOPNOTSUPP); |
|
|
printf("kern_read %s\n", kt->kt_name); |
printf("kern_read %s\n", kt->kt_name); |
#endif |
#endif |
|
|
len = 0; |
off = uio->uio_offset; |
if (error = kernfs_xread(kt, strbuf, sizeof(strbuf), &len)) |
#if 0 |
return (error); |
while (buf = strbuf, |
if (len <= off) |
#else |
return (0); |
if (buf = strbuf, |
return (uiomove(&strbuf[off], len - off, uio)); |
#endif |
|
len = kernfs_xread(kt, off, &buf, sizeof(strbuf))) { |
|
if (error = uiomove(buf, len, uio)) |
|
return (error); |
|
off += len; |
|
} |
|
return (0); |
} |
} |
|
|
static int |
int |
kernfs_write(ap) |
kernfs_write(ap) |
struct vop_write_args /* { |
struct vop_write_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
Line 482 kernfs_readdir(ap) |
|
Line 483 kernfs_readdir(ap) |
|
struct vnode *a_vp; |
struct vnode *a_vp; |
struct uio *a_uio; |
struct uio *a_uio; |
struct ucred *a_cred; |
struct ucred *a_cred; |
|
int *a_eofflag; |
|
u_long *a_cookies; |
|
int a_ncookies; |
} */ *ap; |
} */ *ap; |
{ |
{ |
struct uio *uio = ap->a_uio; |
struct uio *uio = ap->a_uio; |
register struct kern_target *kt; |
|
struct dirent d; |
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) |
if (ap->a_vp->v_type != VDIR) |
return (ENOTDIR); |
return (ENOTDIR); |
|
|
i = uio->uio_offset / UIO_MX; |
if (uio->uio_resid < UIO_MX) |
|
return (EINVAL); |
|
if (uio->uio_offset < 0) |
|
return (EINVAL); |
|
|
error = 0; |
error = 0; |
|
i = uio->uio_offset; |
|
bzero((caddr_t)&d, UIO_MX); |
|
d.d_reclen = UIO_MX; |
|
|
for (kt = &kern_targets[i]; |
for (kt = &kern_targets[i]; |
uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) { |
uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) { |
register struct dirent *dp = &d; |
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_readdir: i = %d\n", i); |
printf("kernfs_readdir: i = %d\n", i); |
#endif |
#endif |
|
|
if (kt->kt_tag == KTT_DEVICE) { |
if (kt->kt_tag == KTT_DEVICE) { |
register dev_t *dp = kt->kt_data; |
dev_t *dp = kt->kt_data; |
struct vnode *fvp; |
struct vnode *fvp; |
|
|
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) |
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) |
continue; |
continue; |
} |
} |
bzero((caddr_t)dp, UIO_MX); |
|
dp->d_namlen = kt->kt_namlen; |
d.d_fileno = i + 3; |
bcopy(kt->kt_name, dp->d_name, kt->kt_namlen + 1); |
d.d_namlen = kt->kt_namlen; |
#ifdef KERNFS_DIAGNOSTIC |
bcopy(kt->kt_name, d.d_name, kt->kt_namlen + 1); |
printf("kernfs_readdir: name = %s, len = %d\n", |
d.d_type = kt->kt_type; |
dp->d_name, dp->d_namlen); |
|
#endif |
if (error = uiomove((caddr_t)&d, UIO_MX, uio)) |
/* |
|
* Fill in the remaining fields |
|
*/ |
|
dp->d_reclen = UIO_MX; |
|
dp->d_fileno = i + 3; |
|
dp->d_type = kt->kt_type; |
|
/* |
|
* And ship to userland |
|
*/ |
|
if (error = uiomove((caddr_t)dp, UIO_MX, uio)) |
|
break; |
break; |
|
if (ncookies-- > 0) |
|
*cookies++ = i + 1; |
} |
} |
|
|
uio->uio_offset = i * UIO_MX; |
uio->uio_offset = i; |
|
|
return (error); |
return (error); |
} |
} |
|
|
Line 574 kernfs_pathconf(ap) |
|
Line 580 kernfs_pathconf(ap) |
|
struct vop_pathconf_args /* { |
struct vop_pathconf_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
int a_name; |
int a_name; |
int *a_retval; |
register_t *a_retval; |
} */ *ap; |
} */ *ap; |
{ |
{ |
|
|