version 1.49, 1997/05/08 16:20:17 |
version 1.61, 1998/08/10 08:11:12 |
|
|
* 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. |
* |
* |
* @(#)kernfs_vnops.c 8.9 (Berkeley) 6/15/94 |
* @(#)kernfs_vnops.c 8.15 (Berkeley) 5/21/95 |
*/ |
*/ |
|
|
/* |
/* |
* Kernel parameter filesystem (/kern) |
* Kernel parameter filesystem (/kern) |
*/ |
*/ |
|
|
|
#if defined(_KERNEL) && !defined(_LKM) |
|
#include "opt_uvm.h" |
|
#endif |
|
|
#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 <miscfs/genfs/genfs.h> |
#include <miscfs/genfs/genfs.h> |
#include <miscfs/kernfs/kernfs.h> |
#include <miscfs/kernfs/kernfs.h> |
|
|
|
#if defined(UVM) |
|
#include <vm/vm.h> |
|
#include <uvm/uvm_extern.h> |
|
#endif |
|
|
#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 WRITE_MODE (S_IWUSR|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) |
#define DIR_MODE (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) |
|
|
struct kern_target { |
struct kern_target kern_targets[] = { |
u_char kt_type; |
|
u_char kt_namlen; |
|
char *kt_name; |
|
void *kt_data; |
|
#define KTT_NULL 1 |
|
#define KTT_TIME 5 |
|
#define KTT_INT 17 |
|
#define KTT_STRING 31 |
|
#define KTT_HOSTNAME 47 |
|
#define KTT_AVENRUN 53 |
|
#define KTT_DEVICE 71 |
|
#define KTT_MSGBUF 89 |
|
u_char kt_tag; |
|
u_char kt_vtype; |
|
mode_t kt_mode; |
|
} 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 */ |
#define N(s) sizeof(s)-1, s |
#define N(s) sizeof(s)-1, s |
/* name data tag type ro/rw */ |
/* name data tag type ro/rw */ |
Line 97 struct kern_target { |
|
Line 90 struct kern_target { |
|
{ 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("msgbuf"), 0, KTT_MSGBUF, VREG, READ_MODE }, |
|
#if defined(UVM) |
|
{ DT_REG, N("pagesize"), &uvmexp.pagesize, KTT_INT, VREG, READ_MODE }, |
|
#else |
{ 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 }, |
|
#endif |
{ DT_REG, N("physmem"), &physmem, KTT_INT, VREG, READ_MODE }, |
{ DT_REG, N("physmem"), &physmem, KTT_INT, VREG, READ_MODE }, |
#if 0 |
#if 0 |
{ DT_DIR, N("root"), 0, KTT_NULL, VDIR, DIR_MODE }, |
{ DT_DIR, N("root"), 0, KTT_NULL, VDIR, DIR_MODE }, |
Line 120 int kernfs_getattr __P((void *)); |
|
Line 117 int kernfs_getattr __P((void *)); |
|
int kernfs_setattr __P((void *)); |
int kernfs_setattr __P((void *)); |
int kernfs_read __P((void *)); |
int kernfs_read __P((void *)); |
int kernfs_write __P((void *)); |
int kernfs_write __P((void *)); |
#define kernfs_ioctl genfs_eopnotsupp |
#define kernfs_ioctl genfs_enoioctl |
#define kernfs_poll genfs_poll |
#define kernfs_poll genfs_poll |
|
#define kernfs_revoke genfs_revoke |
#define kernfs_mmap genfs_eopnotsupp |
#define kernfs_mmap genfs_eopnotsupp |
#define kernfs_fsync genfs_nullop |
#define kernfs_fsync genfs_nullop |
#define kernfs_seek genfs_nullop |
#define kernfs_seek genfs_nullop |
Line 136 int kernfs_readdir __P((void *)); |
|
Line 134 int kernfs_readdir __P((void *)); |
|
#define kernfs_abortop genfs_abortop |
#define kernfs_abortop genfs_abortop |
int kernfs_inactive __P((void *)); |
int kernfs_inactive __P((void *)); |
int kernfs_reclaim __P((void *)); |
int kernfs_reclaim __P((void *)); |
#define kernfs_lock genfs_nullop |
#define kernfs_lock genfs_nolock |
#define kernfs_unlock genfs_nullop |
#define kernfs_unlock genfs_nounlock |
#define kernfs_bmap genfs_badop |
#define kernfs_bmap genfs_badop |
#define kernfs_strategy genfs_badop |
#define kernfs_strategy genfs_badop |
int kernfs_print __P((void *)); |
int kernfs_print __P((void *)); |
#define kernfs_islocked genfs_nullop |
#define kernfs_islocked genfs_noislocked |
int kernfs_pathconf __P((void *)); |
int kernfs_pathconf __P((void *)); |
#define kernfs_advlock genfs_eopnotsupp |
#define kernfs_advlock genfs_eopnotsupp |
#define kernfs_blkatoff genfs_eopnotsupp |
#define kernfs_blkatoff genfs_eopnotsupp |
Line 169 struct vnodeopv_entry_desc kernfs_vnodeo |
|
Line 167 struct vnodeopv_entry_desc kernfs_vnodeo |
|
{ &vop_write_desc, kernfs_write }, /* write */ |
{ &vop_write_desc, kernfs_write }, /* write */ |
{ &vop_ioctl_desc, kernfs_ioctl }, /* ioctl */ |
{ &vop_ioctl_desc, kernfs_ioctl }, /* ioctl */ |
{ &vop_poll_desc, kernfs_poll }, /* poll */ |
{ &vop_poll_desc, kernfs_poll }, /* poll */ |
|
{ &vop_revoke_desc, kernfs_revoke }, /* revoke */ |
{ &vop_mmap_desc, kernfs_mmap }, /* mmap */ |
{ &vop_mmap_desc, kernfs_mmap }, /* mmap */ |
{ &vop_fsync_desc, kernfs_fsync }, /* fsync */ |
{ &vop_fsync_desc, kernfs_fsync }, /* fsync */ |
{ &vop_seek_desc, kernfs_seek }, /* seek */ |
{ &vop_seek_desc, kernfs_seek }, /* seek */ |
Line 234 kernfs_xread(kt, off, bufp, len) |
|
Line 233 kernfs_xread(kt, off, bufp, len) |
|
} |
} |
|
|
case KTT_MSGBUF: { |
case KTT_MSGBUF: { |
extern struct msgbuf *msgbufp; |
|
long n; |
long n; |
|
|
if (off >= MSG_BSIZE) |
/* |
|
* deal with cases where the message buffer has |
|
* become corrupted. |
|
*/ |
|
if (!msgbufenabled || msgbufp->msg_magic != MSG_MAGIC) { |
|
msgbufenabled = 0; |
|
return (ENXIO); |
|
} |
|
|
|
/* |
|
* Note that reads of /kern/msgbuf won't necessarily yield |
|
* consistent results, if the message buffer is modified |
|
* while the read is in progress. The worst that can happen |
|
* is that incorrect data will be read. There's no way |
|
* that this can crash the system unless the values in the |
|
* message buffer header are corrupted, but that'll cause |
|
* the system to die anyway. |
|
*/ |
|
if (off >= msgbufp->msg_bufs) |
return (0); |
return (0); |
n = msgbufp->msg_bufx + off; |
n = msgbufp->msg_bufx + off; |
if (n >= MSG_BSIZE) |
if (n >= msgbufp->msg_bufs) |
n -= MSG_BSIZE; |
n -= msgbufp->msg_bufs; |
len = min(MSG_BSIZE - n, MSG_BSIZE - off); |
len = min(msgbufp->msg_bufs - n, msgbufp->msg_bufs - off); |
*bufp = msgbufp->msg_bufc + n; |
*bufp = msgbufp->msg_bufc + n; |
return (len); |
return (len); |
} |
} |
Line 254 kernfs_xread(kt, off, bufp, len) |
|
Line 270 kernfs_xread(kt, off, bufp, len) |
|
if (xlen >= (len-2)) |
if (xlen >= (len-2)) |
return (EINVAL); |
return (EINVAL); |
|
|
bcopy(cp, *bufp, xlen); |
memcpy(*bufp, cp, xlen); |
(*bufp)[xlen] = '\n'; |
(*bufp)[xlen] = '\n'; |
(*bufp)[xlen+1] = '\0'; |
(*bufp)[xlen+1] = '\0'; |
break; |
break; |
Line 289 kernfs_xwrite(kt, buf, len) |
|
Line 305 kernfs_xwrite(kt, buf, len) |
|
case KTT_HOSTNAME: |
case KTT_HOSTNAME: |
if (buf[len-1] == '\n') |
if (buf[len-1] == '\n') |
--len; |
--len; |
bcopy(buf, hostname, len); |
memcpy(hostname, buf, len); |
hostname[len] = '\0'; |
hostname[len] = '\0'; |
hostnamelen = len; |
hostnamelen = len; |
return (0); |
return (0); |
Line 322 kernfs_lookup(v) |
|
Line 338 kernfs_lookup(v) |
|
int error, i; |
int error, i; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_lookup(%x)\n", ap); |
printf("kernfs_lookup(%p)\n", ap); |
printf("kernfs_lookup(dp = %x, vpp = %x, cnp = %x)\n", dvp, vpp, ap->a_cnp); |
printf("kernfs_lookup(dp = %p, vpp = %p, cnp = %p)\n", dvp, vpp, ap->a_cnp); |
printf("kernfs_lookup(%s)\n", pname); |
printf("kernfs_lookup(%s)\n", pname); |
#endif |
#endif |
|
|
Line 332 kernfs_lookup(v) |
|
Line 348 kernfs_lookup(v) |
|
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) |
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) |
return (EROFS); |
return (EROFS); |
|
|
|
VOP_UNLOCK(dvp, 0); |
if (cnp->cn_namelen == 1 && *pname == '.') { |
if (cnp->cn_namelen == 1 && *pname == '.') { |
*vpp = dvp; |
*vpp = dvp; |
VREF(dvp); |
VREF(dvp); |
/*VOP_LOCK(dvp);*/ |
vn_lock(dvp, LK_SHARED | LK_RETRY); |
return (0); |
return (0); |
} |
} |
|
|
#if 0 |
#if 0 |
if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) { |
if (cnp->cn_namelen == 4 && memcmp(pname, "root", 4) == 0) { |
*vpp = rootdir; |
*vpp = rootdir; |
VREF(rootdir); |
VREF(rootdir); |
VOP_LOCK(rootdir); |
vn_lock(rootdir, LK_SHARED | LK_RETRY); |
return (0); |
return (0); |
} |
} |
#endif |
#endif |
|
|
for (kt = kern_targets, i = 0; i < nkern_targets; kt++, i++) { |
for (kt = kern_targets, i = 0; i < nkern_targets; kt++, i++) { |
if (cnp->cn_namelen == kt->kt_namlen && |
if (cnp->cn_namelen == kt->kt_namlen && |
bcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
goto found; |
goto found; |
} |
} |
|
|
Line 358 kernfs_lookup(v) |
|
Line 375 kernfs_lookup(v) |
|
printf("kernfs_lookup: i = %d, failed", i); |
printf("kernfs_lookup: i = %d, failed", i); |
#endif |
#endif |
|
|
|
vn_lock(dvp, LK_SHARED | LK_RETRY); |
return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); |
return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); |
|
|
found: |
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: |
loop: |
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) |
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) { |
|
vn_lock(dvp, LK_SHARED | LK_RETRY); |
return (ENOENT); |
return (ENOENT); |
|
} |
*vpp = fvp; |
*vpp = fvp; |
if (vget(fvp, 1)) |
if (vget(fvp, LK_EXCLUSIVE)) |
goto loop; |
goto loop; |
return (0); |
return (0); |
} |
} |
|
|
printf("kernfs_lookup: allocate new vnode\n"); |
printf("kernfs_lookup: allocate new vnode\n"); |
#endif |
#endif |
error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, &fvp); |
error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, &fvp); |
if (error) |
if (error) { |
|
vn_lock(dvp, LK_SHARED | LK_RETRY); |
return (error); |
return (error); |
|
} |
|
|
MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP, |
MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP, |
M_WAITOK); |
M_WAITOK); |
VTOKERN(fvp)->kf_kt = kt; |
VTOKERN(fvp)->kf_kt = kt; |
fvp->v_type = kt->kt_vtype; |
fvp->v_type = kt->kt_vtype; |
|
vn_lock(fvp, LK_SHARED | LK_RETRY); |
*vpp = fvp; |
*vpp = fvp; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_lookup: newvp = %x\n", fvp); |
printf("kernfs_lookup: newvp = %p\n", fvp); |
#endif |
#endif |
return (0); |
return (0); |
} |
} |
Line 431 kernfs_getattr(v) |
|
Line 454 kernfs_getattr(v) |
|
int error = 0; |
int error = 0; |
char strbuf[KSTRING], *buf; |
char strbuf[KSTRING], *buf; |
|
|
bzero((caddr_t) vap, sizeof(*vap)); |
memset((caddr_t) vap, 0, sizeof(*vap)); |
vattr_null(vap); |
vattr_null(vap); |
vap->va_uid = 0; |
vap->va_uid = 0; |
vap->va_gid = 0; |
vap->va_gid = 0; |
Line 465 kernfs_getattr(v) |
|
Line 488 kernfs_getattr(v) |
|
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 = 3 + (kt - kern_targets); |
vap->va_fileid = 1 + (kt - kern_targets); |
total = 0; |
total = 0; |
while (buf = strbuf, |
while (buf = strbuf, |
nbytes = kernfs_xread(kt, total, &buf, sizeof(strbuf))) |
nbytes = kernfs_xread(kt, total, &buf, sizeof(strbuf))) |
Line 578 kernfs_readdir(v) |
|
Line 601 kernfs_readdir(v) |
|
struct uio *a_uio; |
struct uio *a_uio; |
struct ucred *a_cred; |
struct ucred *a_cred; |
int *a_eofflag; |
int *a_eofflag; |
u_long *a_cookies; |
off_t **a_cookies; |
int a_ncookies; |
int a_*ncookies; |
} */ *ap = v; |
} */ *ap = v; |
struct uio *uio = ap->a_uio; |
struct uio *uio = ap->a_uio; |
struct dirent d; |
struct dirent d; |
struct kern_target *kt; |
struct kern_target *kt; |
int i; |
int i; |
int error; |
int error; |
u_long *cookies = ap->a_cookies; |
off_t *cookies = NULL; |
int ncookies = ap->a_ncookies; |
int ncookies = 0, nc = 0; |
|
|
if (ap->a_vp->v_type != VDIR) |
if (ap->a_vp->v_type != VDIR) |
return (ENOTDIR); |
return (ENOTDIR); |
Line 599 kernfs_readdir(v) |
|
Line 622 kernfs_readdir(v) |
|
|
|
error = 0; |
error = 0; |
i = uio->uio_offset; |
i = uio->uio_offset; |
bzero((caddr_t)&d, UIO_MX); |
memset((caddr_t)&d, 0, UIO_MX); |
d.d_reclen = UIO_MX; |
d.d_reclen = UIO_MX; |
|
|
|
if (ap->a_ncookies) { |
|
nc = uio->uio_resid / UIO_MX; |
|
nc = min(nc, (nkern_targets - i)); |
|
MALLOC(cookies, off_t *, nc * sizeof(off_t), M_TEMP, |
|
M_WAITOK); |
|
*ap->a_cookies = cookies; |
|
} |
|
|
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++) { |
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
Line 618 kernfs_readdir(v) |
|
Line 649 kernfs_readdir(v) |
|
|
|
d.d_fileno = i + 3; |
d.d_fileno = i + 3; |
d.d_namlen = kt->kt_namlen; |
d.d_namlen = kt->kt_namlen; |
bcopy(kt->kt_name, d.d_name, kt->kt_namlen + 1); |
memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); |
d.d_type = kt->kt_type; |
d.d_type = kt->kt_type; |
|
|
if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) |
if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) |
break; |
break; |
if (ncookies-- > 0) |
if (cookies) { |
*cookies++ = i + 1; |
*cookies++ = i + 1; |
|
ncookies++; |
|
} |
|
} |
|
|
|
if (ap->a_ncookies) { |
|
if (error) { |
|
FREE(*ap->a_cookies, M_TEMP); |
|
*ap->a_ncookies = 0; |
|
*ap->a_cookies = NULL; |
|
} else |
|
*ap->a_ncookies = ncookies; |
} |
} |
|
|
uio->uio_offset = i; |
uio->uio_offset = i; |
Line 637 kernfs_inactive(v) |
|
Line 679 kernfs_inactive(v) |
|
{ |
{ |
struct vop_inactive_args /* { |
struct vop_inactive_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
|
struct proc *a_p; |
} */ *ap = v; |
} */ *ap = v; |
struct vnode *vp = ap->a_vp; |
struct vnode *vp = ap->a_vp; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_inactive(%x)\n", vp); |
printf("kernfs_inactive(%p)\n", vp); |
#endif |
#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(). |
*/ |
*/ |
|
VOP_UNLOCK(vp, 0); |
vp->v_type = VNON; |
vp->v_type = VNON; |
return (0); |
return (0); |
} |
} |
Line 661 kernfs_reclaim(v) |
|
Line 705 kernfs_reclaim(v) |
|
struct vnode *vp = ap->a_vp; |
struct vnode *vp = ap->a_vp; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef KERNFS_DIAGNOSTIC |
printf("kernfs_reclaim(%x)\n", vp); |
printf("kernfs_reclaim(%p)\n", vp); |
#endif |
#endif |
if (vp->v_data) { |
if (vp->v_data) { |
FREE(vp->v_data, M_TEMP); |
FREE(vp->v_data, M_TEMP); |
Line 702 kernfs_pathconf(v) |
|
Line 746 kernfs_pathconf(v) |
|
case _PC_VDISABLE: |
case _PC_VDISABLE: |
*ap->a_retval = _POSIX_VDISABLE; |
*ap->a_retval = _POSIX_VDISABLE; |
return (0); |
return (0); |
|
case _PC_SYNC_IO: |
|
*ap->a_retval = 1; |
|
return (0); |
default: |
default: |
return (EINVAL); |
return (EINVAL); |
} |
} |