version 1.10, 1993/06/07 05:25:25 |
version 1.160, 2018/09/03 16:29:35 |
|
|
|
/* $NetBSD$ */ |
|
|
/* |
/* |
* Copyright (c) 1990, 1992 Jan-Simon Pendry |
* Copyright (c) 1992, 1993 |
* All rights reserved. |
* The Regents of the University of California. All rights reserved. |
* |
* |
* This code is derived from software contributed to Berkeley by |
* This code is derived from software donated to Berkeley by |
* Jan-Simon Pendry. |
* Jan-Simon Pendry. |
* |
* |
* Redistribution and use in source and binary forms, with or without |
* Redistribution and use in source and binary forms, with or without |
|
|
* 2. Redistributions in binary form must reproduce the above copyright |
* 2. Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* documentation and/or other materials provided with the distribution. |
* 3. All advertising materials mentioning features or use of this software |
* 3. Neither the name of the University nor the names of its contributors |
* 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 |
* may be used to endorse or promote products derived from this software |
* without specific prior written permission. |
* without specific prior written permission. |
* |
* |
|
|
* 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. |
* |
* |
* $Id$ |
* @(#)kernfs_vnops.c 8.15 (Berkeley) 5/21/95 |
*/ |
*/ |
|
|
/* |
/* |
* Kernel parameter filesystem |
* Kernel parameter filesystem (/kern) |
*/ |
*/ |
|
|
#include "param.h" |
#include <sys/cdefs.h> |
#include "systm.h" |
__KERNEL_RCSID(0, "$NetBSD$"); |
#include "kernel.h" |
|
#include "types.h" |
|
#include "time.h" |
|
#include "proc.h" |
|
#include "file.h" |
|
#include "vnode.h" |
|
#include "stat.h" |
|
#include "mount.h" |
|
#include "namei.h" |
|
#include "buf.h" |
|
#include "miscfs/kernfs/kernfs.h" |
|
|
|
#include "../ufs/dir.h" /* For readdir() XXX */ |
#include <sys/param.h> |
|
#include <sys/systm.h> |
|
#include <sys/kernel.h> |
|
#include <sys/vmmeter.h> |
|
#include <sys/time.h> |
|
#include <sys/proc.h> |
|
#include <sys/vnode.h> |
|
#include <sys/malloc.h> |
|
#include <sys/file.h> |
|
#include <sys/stat.h> |
|
#include <sys/mount.h> |
|
#include <sys/namei.h> |
|
#include <sys/buf.h> |
|
#include <sys/dirent.h> |
|
#include <sys/msgbuf.h> |
|
|
|
#include <miscfs/genfs/genfs.h> |
|
#include <miscfs/kernfs/kernfs.h> |
|
#include <miscfs/specfs/specdev.h> |
|
|
|
#include <uvm/uvm_extern.h> |
|
|
|
#define KSTRING 256 /* Largest I/O available via this filesystem */ |
|
#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 UREAD_MODE (S_IRUSR) |
|
#define DIR_MODE (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) |
|
#define UDIR_MODE (S_IRUSR|S_IXUSR) |
|
|
struct kernfs_target kernfs_targets[] = { |
#define N(s) sizeof(s)-1, s |
|
const struct kern_target 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 */ |
DIR_TARGET(".", 0, KTT_NULL, KTM_DIR_PERMS ) |
/* name data tag type ro/rw */ |
DIR_TARGET("..", 0, KTT_NULL, KTM_DIR_PERMS ) |
{ DT_DIR, N("."), 0, KFSkern, VDIR, DIR_MODE }, |
REG_TARGET("copyright", copyright, KTT_STRING, KTM_RO_PERMS ) |
{ DT_DIR, N(".."), 0, KFSroot, VDIR, DIR_MODE }, |
REG_TARGET("hostname", 0, KTT_HOSTNAME, KTM_RW_PERMS ) |
{ DT_REG, N("boottime"), &boottime.tv_sec, KFSint, VREG, READ_MODE }, |
REG_TARGET("hz", &hz, KTT_INT, KTM_RO_PERMS ) |
/* XXXUNCONST */ |
REG_TARGET("loadavg", 0, KTT_AVENRUN, KTM_RO_PERMS ) |
{ DT_REG, N("copyright"), __UNCONST(copyright), |
REG_TARGET("physmem", &physmem, KTT_INT, KTM_RO_PERMS ) |
KFSstring, VREG, READ_MODE }, |
DIR_TARGET("root", 0, KTT_NULL, KTM_DIR_PERMS ) |
{ DT_REG, N("hostname"), 0, KFShostname, VREG, WRITE_MODE }, |
BLK_TARGET("rootdev", 0, KTT_NULL, KTM_RO_PERMS ) |
{ DT_REG, N("hz"), &hz, KFSint, VREG, READ_MODE }, |
CHR_TARGET("rrootdev", 0, KTT_NULL, KTM_RO_PERMS ) |
{ DT_REG, N("loadavg"), 0, KFSavenrun, VREG, READ_MODE }, |
REG_TARGET("time", 0, KTT_TIME, KTM_RO_PERMS ) |
{ DT_REG, N("msgbuf"), 0, KFSmsgbuf, VREG, READ_MODE }, |
REG_TARGET("version", version, KTT_STRING, KTM_RO_PERMS ) |
{ DT_REG, N("pagesize"), &uvmexp.pagesize, KFSint, VREG, READ_MODE }, |
|
{ DT_REG, N("physmem"), &physmem, KFSint, VREG, READ_MODE }, |
|
#if 0 |
|
{ DT_DIR, N("root"), 0, KFSnull, VDIR, DIR_MODE }, |
|
#endif |
|
{ DT_BLK, N("rootdev"), &rootdev, KFSdevice, VBLK, READ_MODE }, |
|
{ DT_CHR, N("rrootdev"), &rrootdev, KFSdevice, VCHR, READ_MODE }, |
|
{ DT_REG, N("time"), 0, KFStime, VREG, READ_MODE }, |
|
/* XXXUNCONST */ |
|
{ DT_REG, N("version"), __UNCONST(version), |
|
KFSstring, VREG, READ_MODE }, |
|
}; |
|
const struct kern_target subdir_targets[] = { |
|
/* NOTE: The name must be less than UIO_MX-16 chars in length */ |
|
/* name data tag type ro/rw */ |
|
{ DT_DIR, N("."), 0, KFSsubdir, VDIR, DIR_MODE }, |
|
{ DT_DIR, N(".."), 0, KFSkern, VDIR, DIR_MODE }, |
|
}; |
|
#undef N |
|
SIMPLEQ_HEAD(,dyn_kern_target) dyn_kern_targets = |
|
SIMPLEQ_HEAD_INITIALIZER(dyn_kern_targets); |
|
int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); |
|
const int static_nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); |
|
int nkern_dirs = 2; |
|
|
|
int kernfs_try_fileop(kfstype, kfsfileop, void *, int); |
|
int kernfs_try_xread(kfstype, const struct kernfs_node *, char **, |
|
size_t, int); |
|
int kernfs_try_xwrite(kfstype, const struct kernfs_node *, char *, |
|
size_t, int); |
|
|
|
static int kernfs_default_xread(void *v); |
|
static int kernfs_default_xwrite(void *v); |
|
static int kernfs_default_fileop_getattr(void *); |
|
|
|
/* must include all fileop's */ |
|
const struct kernfs_fileop kernfs_default_fileops[] = { |
|
{ .kf_fileop = KERNFS_XREAD }, |
|
{ .kf_fileop = KERNFS_XWRITE }, |
|
{ .kf_fileop = KERNFS_FILEOP_OPEN }, |
|
{ .kf_fileop = KERNFS_FILEOP_GETATTR, |
|
.kf_vop = kernfs_default_fileop_getattr }, |
|
{ .kf_fileop = KERNFS_FILEOP_IOCTL }, |
|
{ .kf_fileop = KERNFS_FILEOP_CLOSE }, |
|
{ .kf_fileop = KERNFS_FILEOP_READ, |
|
.kf_vop = kernfs_default_xread }, |
|
{ .kf_fileop = KERNFS_FILEOP_WRITE, |
|
.kf_vop = kernfs_default_xwrite }, |
}; |
}; |
|
|
static int nkernfs_targets = sizeof(kernfs_targets) / sizeof(kernfs_targets[0]); |
int kernfs_lookup(void *); |
|
#define kernfs_create genfs_eopnotsupp |
|
#define kernfs_mknod genfs_eopnotsupp |
|
int kernfs_open(void *); |
|
int kernfs_close(void *); |
|
int kernfs_access(void *); |
|
int kernfs_getattr(void *); |
|
int kernfs_setattr(void *); |
|
int kernfs_read(void *); |
|
int kernfs_write(void *); |
|
#define kernfs_fcntl genfs_fcntl |
|
int kernfs_ioctl(void *); |
|
#define kernfs_poll genfs_poll |
|
#define kernfs_revoke genfs_revoke |
|
#define kernfs_fsync genfs_nullop |
|
#define kernfs_seek genfs_nullop |
|
#define kernfs_remove genfs_eopnotsupp |
|
int kernfs_link(void *); |
|
#define kernfs_rename genfs_eopnotsupp |
|
#define kernfs_mkdir genfs_eopnotsupp |
|
#define kernfs_rmdir genfs_eopnotsupp |
|
int kernfs_symlink(void *); |
|
int kernfs_readdir(void *); |
|
#define kernfs_readlink genfs_eopnotsupp |
|
#define kernfs_abortop genfs_abortop |
|
int kernfs_inactive(void *); |
|
int kernfs_reclaim(void *); |
|
#define kernfs_lock genfs_lock |
|
#define kernfs_unlock genfs_unlock |
|
#define kernfs_bmap genfs_badop |
|
#define kernfs_strategy genfs_badop |
|
int kernfs_print(void *); |
|
#define kernfs_islocked genfs_islocked |
|
int kernfs_pathconf(void *); |
|
#define kernfs_advlock genfs_einval |
|
#define kernfs_bwrite genfs_eopnotsupp |
|
#define kernfs_putpages genfs_putpages |
|
|
|
static int kernfs_xread(struct kernfs_node *, int, char **, |
|
size_t, size_t *); |
|
static int kernfs_xwrite(const struct kernfs_node *, char *, size_t); |
|
|
|
int (**kernfs_vnodeop_p)(void *); |
|
const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { |
|
{ &vop_default_desc, vn_default_error }, |
|
{ &vop_lookup_desc, kernfs_lookup }, /* lookup */ |
|
{ &vop_create_desc, kernfs_create }, /* create */ |
|
{ &vop_mknod_desc, kernfs_mknod }, /* mknod */ |
|
{ &vop_open_desc, kernfs_open }, /* open */ |
|
{ &vop_close_desc, kernfs_close }, /* close */ |
|
{ &vop_access_desc, kernfs_access }, /* access */ |
|
{ &vop_getattr_desc, kernfs_getattr }, /* getattr */ |
|
{ &vop_setattr_desc, kernfs_setattr }, /* setattr */ |
|
{ &vop_read_desc, kernfs_read }, /* read */ |
|
{ &vop_write_desc, kernfs_write }, /* write */ |
|
{ &vop_fallocate_desc, genfs_eopnotsupp }, /* fallocate */ |
|
{ &vop_fdiscard_desc, genfs_eopnotsupp }, /* fdiscard */ |
|
{ &vop_fcntl_desc, kernfs_fcntl }, /* fcntl */ |
|
{ &vop_ioctl_desc, kernfs_ioctl }, /* ioctl */ |
|
{ &vop_poll_desc, kernfs_poll }, /* poll */ |
|
{ &vop_revoke_desc, kernfs_revoke }, /* revoke */ |
|
{ &vop_fsync_desc, kernfs_fsync }, /* fsync */ |
|
{ &vop_seek_desc, kernfs_seek }, /* seek */ |
|
{ &vop_remove_desc, kernfs_remove }, /* remove */ |
|
{ &vop_link_desc, kernfs_link }, /* link */ |
|
{ &vop_rename_desc, kernfs_rename }, /* rename */ |
|
{ &vop_mkdir_desc, kernfs_mkdir }, /* mkdir */ |
|
{ &vop_rmdir_desc, kernfs_rmdir }, /* rmdir */ |
|
{ &vop_symlink_desc, kernfs_symlink }, /* symlink */ |
|
{ &vop_readdir_desc, kernfs_readdir }, /* readdir */ |
|
{ &vop_readlink_desc, kernfs_readlink }, /* readlink */ |
|
{ &vop_abortop_desc, kernfs_abortop }, /* abortop */ |
|
{ &vop_inactive_desc, kernfs_inactive }, /* inactive */ |
|
{ &vop_reclaim_desc, kernfs_reclaim }, /* reclaim */ |
|
{ &vop_lock_desc, kernfs_lock }, /* lock */ |
|
{ &vop_unlock_desc, kernfs_unlock }, /* unlock */ |
|
{ &vop_bmap_desc, kernfs_bmap }, /* bmap */ |
|
{ &vop_strategy_desc, kernfs_strategy }, /* strategy */ |
|
{ &vop_print_desc, kernfs_print }, /* print */ |
|
{ &vop_islocked_desc, kernfs_islocked }, /* islocked */ |
|
{ &vop_pathconf_desc, kernfs_pathconf }, /* pathconf */ |
|
{ &vop_advlock_desc, kernfs_advlock }, /* advlock */ |
|
{ &vop_bwrite_desc, kernfs_bwrite }, /* bwrite */ |
|
{ &vop_putpages_desc, kernfs_putpages }, /* putpages */ |
|
{ NULL, NULL } |
|
}; |
|
const struct vnodeopv_desc kernfs_vnodeop_opv_desc = |
|
{ &kernfs_vnodeop_p, kernfs_vnodeop_entries }; |
|
|
|
static inline int |
|
kernfs_fileop_compare(struct kernfs_fileop *a, struct kernfs_fileop *b) |
|
{ |
|
if (a->kf_type < b->kf_type) |
|
return -1; |
|
if (a->kf_type > b->kf_type) |
|
return 1; |
|
if (a->kf_fileop < b->kf_fileop) |
|
return -1; |
|
if (a->kf_fileop > b->kf_fileop) |
|
return 1; |
|
return (0); |
|
} |
|
|
|
SPLAY_HEAD(kfsfileoptree, kernfs_fileop) kfsfileoptree = |
|
SPLAY_INITIALIZER(kfsfileoptree); |
|
SPLAY_PROTOTYPE(kfsfileoptree, kernfs_fileop, kf_node, kernfs_fileop_compare); |
|
SPLAY_GENERATE(kfsfileoptree, kernfs_fileop, kf_node, kernfs_fileop_compare); |
|
|
|
kfstype |
|
kernfs_alloctype(int nkf, const struct kernfs_fileop *kf) |
|
{ |
|
static u_char nextfreetype = KFSlasttype; |
|
struct kernfs_fileop *dkf, *fkf, skf; |
|
int i; |
|
|
|
/* XXX need to keep track of dkf's memory if we support |
|
deallocating types */ |
|
dkf = malloc(sizeof(kernfs_default_fileops), M_TEMP, M_WAITOK); |
|
memcpy(dkf, kernfs_default_fileops, sizeof(kernfs_default_fileops)); |
|
|
|
for (i = 0; i < sizeof(kernfs_default_fileops) / |
|
sizeof(kernfs_default_fileops[0]); i++) { |
|
dkf[i].kf_type = nextfreetype; |
|
SPLAY_INSERT(kfsfileoptree, &kfsfileoptree, &dkf[i]); |
|
} |
|
|
|
for (i = 0; i < nkf; i++) { |
|
skf.kf_type = nextfreetype; |
|
skf.kf_fileop = kf[i].kf_fileop; |
|
if ((fkf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) |
|
fkf->kf_vop = kf[i].kf_vop; |
|
} |
|
|
|
return nextfreetype++; |
|
} |
|
|
|
int |
|
kernfs_try_fileop(kfstype type, kfsfileop fileop, void *v, int error) |
|
{ |
|
struct kernfs_fileop *kf, skf; |
|
|
|
skf.kf_type = type; |
|
skf.kf_fileop = fileop; |
|
if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) |
|
if (kf->kf_vop) |
|
return kf->kf_vop(v); |
|
return error; |
|
} |
|
|
|
int |
|
kernfs_try_xread(kfstype type, const struct kernfs_node *kfs, char **bfp, |
|
size_t len, int error) |
|
{ |
|
struct kernfs_fileop *kf, skf; |
|
|
|
skf.kf_type = type; |
|
skf.kf_fileop = KERNFS_XREAD; |
|
if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) |
|
if (kf->kf_xread) |
|
return kf->kf_xread(kfs, bfp, len); |
|
return error; |
|
} |
|
|
|
int |
|
kernfs_try_xwrite(kfstype type, const struct kernfs_node *kfs, char *bf, |
|
size_t len, int error) |
|
{ |
|
struct kernfs_fileop *kf, skf; |
|
|
|
skf.kf_type = type; |
|
skf.kf_fileop = KERNFS_XWRITE; |
|
if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) |
|
if (kf->kf_xwrite) |
|
return kf->kf_xwrite(kfs, bf, len); |
|
return error; |
|
} |
|
|
|
int |
|
kernfs_addentry(kernfs_parentdir_t *pkt, kernfs_entry_t *dkt) |
|
{ |
|
struct kernfs_subdir *ks, *parent; |
|
|
|
if (pkt == NULL) { |
|
SIMPLEQ_INSERT_TAIL(&dyn_kern_targets, dkt, dkt_queue); |
|
nkern_targets++; |
|
if (dkt->dkt_kt.kt_vtype == VDIR) |
|
nkern_dirs++; |
|
} else { |
|
parent = (struct kernfs_subdir *)pkt->kt_data; |
|
SIMPLEQ_INSERT_TAIL(&parent->ks_entries, dkt, dkt_queue); |
|
parent->ks_nentries++; |
|
if (dkt->dkt_kt.kt_vtype == VDIR) |
|
parent->ks_dirs++; |
|
} |
|
if (dkt->dkt_kt.kt_vtype == VDIR && dkt->dkt_kt.kt_data == NULL) { |
|
ks = malloc(sizeof(struct kernfs_subdir), |
|
M_TEMP, M_WAITOK); |
|
SIMPLEQ_INIT(&ks->ks_entries); |
|
ks->ks_nentries = 2; /* . and .. */ |
|
ks->ks_dirs = 2; |
|
ks->ks_parent = pkt ? pkt : &kern_targets[0]; |
|
dkt->dkt_kt.kt_data = ks; |
|
} |
|
return 0; |
|
} |
|
|
static int |
static int |
kernfs_xread(kt, buf, len, lenp) |
kernfs_xread(struct kernfs_node *kfs, int off, char **bufp, size_t len, size_t *wrlen) |
struct kernfs_target *kt; |
|
char *buf; |
|
int len; |
|
int *lenp; |
|
{ |
{ |
int xlen; |
const struct kern_target *kt; |
|
int err; |
|
|
switch (kt->kt_tag) { |
kt = kfs->kfs_kt; |
case KTT_TIME: { |
|
|
switch (kfs->kfs_type) { |
|
case KFStime: { |
struct timeval tv; |
struct timeval tv; |
|
|
microtime(&tv); |
microtime(&tv); |
sprintf(buf, "%d %d\n", tv.tv_sec, tv.tv_usec); |
snprintf(*bufp, len, "%lld %ld\n", (long long)tv.tv_sec, |
|
(long)tv.tv_usec); |
break; |
break; |
} |
} |
|
|
case KTT_INT: { |
case KFSint: { |
int *ip = kt->kt_data; |
int *ip = kt->kt_data; |
sprintf(buf, "%d\n", *ip); |
|
|
snprintf(*bufp, len, "%d\n", *ip); |
break; |
break; |
} |
} |
|
|
case KTT_STRING: { |
case KFSstring: { |
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_HOSTNAME: { |
case KFSmsgbuf: { |
|
long n; |
|
|
|
/* |
|
* deal with cases where the message buffer has |
|
* become corrupted. |
|
*/ |
|
if (!logenabled(msgbufp)) { |
|
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) { |
|
*wrlen = 0; |
|
return (0); |
|
} |
|
n = msgbufp->msg_bufx + off; |
|
if (n >= msgbufp->msg_bufs) |
|
n -= msgbufp->msg_bufs; |
|
len = uimin(msgbufp->msg_bufs - n, msgbufp->msg_bufs - off); |
|
*bufp = msgbufp->msg_bufc + n; |
|
*wrlen = len; |
|
return (0); |
|
} |
|
|
|
case KFShostname: { |
char *cp = hostname; |
char *cp = hostname; |
int xlen = hostnamelen; |
size_t xlen = hostnamelen; |
|
|
if (xlen + 2 > len) /* extra space for null and newline */ |
if (xlen >= (len - 2)) |
return (EINVAL); |
return (EINVAL); |
|
|
bcopy(cp, buf, xlen); /* safer than sprintf */ |
memcpy(*bufp, cp, xlen); |
buf[xlen] = '\n'; |
(*bufp)[xlen] = '\n'; |
buf[xlen+1] = '\0'; |
(*bufp)[xlen+1] = '\0'; |
break; |
break; |
} |
} |
|
|
case KTT_AVENRUN: |
case KFSavenrun: |
sprintf(buf, "%d %d %d %d\n", |
averunnable.fscale = FSCALE; |
averunnable[0], |
snprintf(*bufp, len, "%d %d %d %ld\n", |
averunnable[1], |
averunnable.ldavg[0], averunnable.ldavg[1], |
averunnable[2], |
averunnable.ldavg[2], averunnable.fscale); |
FSCALE); |
|
break; |
break; |
|
|
default: |
default: |
return (EINVAL); |
err = kernfs_try_xread(kfs->kfs_type, kfs, bufp, len, |
|
EOPNOTSUPP); |
|
if (err) |
|
return err; |
} |
} |
|
|
*lenp = strlen(buf); |
len = strlen(*bufp); |
|
if (len <= off) |
|
*wrlen = 0; |
|
else { |
|
*bufp += off; |
|
*wrlen = len - off; |
|
} |
return (0); |
return (0); |
} |
} |
|
|
static int |
static int |
kernfs_xwrite(kt, buf, len) |
kernfs_xwrite(const struct kernfs_node *kfs, char *bf, size_t len) |
struct kernfs_target *kt; |
{ |
char *buf; |
|
int len; |
switch (kfs->kfs_type) { |
{ |
case KFShostname: |
switch (kt->kt_tag) { |
if (bf[len-1] == '\n') |
case KTT_HOSTNAME: { |
|
if (buf[len-1] == '\n') |
|
--len; |
--len; |
bcopy(buf, hostname, len); |
memcpy(hostname, bf, len); |
/* kernfs_write set buf[value_passed_as_len] = \0. |
hostname[len] = '\0'; |
* therefore, buf len (hostnamelen) = len. |
hostnamelen = (size_t) len; |
*/ |
|
hostnamelen = len; |
|
hostname[hostnamelen] = '\0'; /* null end of string. */ |
|
return (0); |
return (0); |
} |
|
|
|
default: |
default: |
return (EIO); |
return kernfs_try_xwrite(kfs->kfs_type, kfs, bf, len, EIO); |
} |
} |
} |
} |
|
|
|
|
/* |
/* |
* 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) |
int |
struct vnode *dvp; |
kernfs_lookup(void *v) |
struct nameidata *ndp; |
|
struct proc *p; |
|
{ |
{ |
char *pname = ndp->ni_ptr; |
struct vop_lookup_v2_args /* { |
int error = ENOENT; |
struct vnode * a_dvp; |
int i; |
struct vnode ** a_vpp; |
struct vnode *fvp; |
struct componentname * a_cnp; |
|
} */ *ap = v; |
#ifdef KERNFS_DIAGNOSTIC |
struct componentname *cnp = ap->a_cnp; |
printf("kernfs_lookup(%s)\n", pname); |
struct vnode **vpp = ap->a_vpp; |
#endif |
struct vnode *dvp = ap->a_dvp; |
if (ndp->ni_namelen == 1 && *pname == '.') { |
const char *pname = cnp->cn_nameptr; |
ndp->ni_dvp = dvp; |
const struct kernfs_node *kfs; |
ndp->ni_vp = dvp; |
const struct kern_target *kt; |
VREF(dvp); |
const struct dyn_kern_target *dkt; |
/*VOP_LOCK(dvp);*/ |
const struct kernfs_subdir *ks; |
return (0); |
int error, i; |
} |
|
|
*vpp = NULLVP; |
if (ndp->ni_namelen == 4 && bcmp(pname, "root", 4) == 0) { |
|
ndp->ni_dvp = dvp; |
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) |
ndp->ni_vp = rootdir; |
return (EROFS); |
VREF(rootdir); |
|
VOP_LOCK(rootdir); |
if (cnp->cn_namelen == 1 && *pname == '.') { |
return (0); |
*vpp = dvp; |
} |
vref(dvp); |
|
|
/* |
|
* /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); |
return (0); |
} |
} |
|
|
/* |
kfs = VTOKERN(dvp); |
* /kern/rrootdev is the root device |
switch (kfs->kfs_type) { |
*/ |
case KFSkern: |
if (ndp->ni_namelen == 8 && bcmp(pname, "rrootdev", 7) == 0) { |
/* |
ndp->ni_dvp = dvp; |
* Shouldn't get here with .. in the root node. |
ndp->ni_vp = rrootdevvp; |
*/ |
VREF(rrootdevvp); |
if (cnp->cn_flags & ISDOTDOT) |
VOP_LOCK(rrootdevvp); |
return (EIO); |
return (0); |
|
} |
for (i = 0; i < static_nkern_targets; i++) { |
|
kt = &kern_targets[i]; |
|
if (cnp->cn_namelen == kt->kt_namlen && |
|
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
|
goto found; |
|
} |
|
SIMPLEQ_FOREACH(dkt, &dyn_kern_targets, dkt_queue) { |
|
if (cnp->cn_namelen == dkt->dkt_kt.kt_namlen && |
|
memcmp(dkt->dkt_kt.kt_name, pname, cnp->cn_namelen) == 0) { |
|
kt = &dkt->dkt_kt; |
|
goto found; |
|
} |
|
} |
|
break; |
|
|
|
found: |
|
error = vcache_get(dvp->v_mount, &kt, sizeof(kt), vpp); |
|
return error; |
|
|
|
case KFSsubdir: |
|
ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data; |
|
if (cnp->cn_flags & ISDOTDOT) { |
|
kt = ks->ks_parent; |
|
goto found; |
|
} |
|
|
for (i = 0; i < nkernfs_targets; i++) { |
SIMPLEQ_FOREACH(dkt, &ks->ks_entries, dkt_queue) { |
struct kernfs_target *kt = &kernfs_targets[i]; |
if (cnp->cn_namelen == dkt->dkt_kt.kt_namlen && |
if (ndp->ni_namelen == strlen(kt->kt_name) && |
memcmp(dkt->dkt_kt.kt_name, pname, cnp->cn_namelen) == 0) { |
bcmp(kt->kt_name, pname, ndp->ni_namelen) == 0) { |
kt = &dkt->dkt_kt; |
error = 0; |
goto found; |
break; |
} |
} |
} |
|
break; |
|
|
|
default: |
|
return (ENOTDIR); |
} |
} |
|
|
#ifdef KERNFS_DIAGNOSTIC |
return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); |
printf("kernfs_lookup: i = %d, error = %d\n", i, error); |
} |
#endif |
|
|
|
if (error) |
int |
goto bad; |
kernfs_open(void *v) |
|
{ |
|
struct vop_open_args /* { |
|
struct vnode *a_vp; |
|
int a_mode; |
|
kauth_cred_t a_cred; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
#ifdef KERNFS_DIAGNOSTIC |
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_OPEN, v, 0); |
printf("kernfs_lookup: allocate new vnode\n"); |
} |
#endif |
|
error = getnewvnode(VT_KERNFS, dvp->v_mount, &kernfs_vnodeops, &fvp); |
|
if (error) |
|
goto bad; |
|
VTOKERN(fvp)->kf_kt = &kernfs_targets[i]; |
|
fvp->v_type = VTOKERN(fvp)->kf_kt->kt_vtype; |
|
ndp->ni_dvp = dvp; |
|
ndp->ni_vp = fvp; |
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_lookup: newvp = %x\n", fvp); |
|
#endif |
|
return (0); |
|
|
|
bad:; |
int |
ndp->ni_dvp = dvp; |
kernfs_close(void *v) |
ndp->ni_vp = NULL; |
{ |
#ifdef KERNFS_DIAGNOSTIC |
struct vop_close_args /* { |
printf("kernfs_lookup: error = %d\n", error); |
struct vnode *a_vp; |
#endif |
int a_fflag; |
return (error); |
kauth_cred_t a_cred; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
|
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_CLOSE, v, 0); |
} |
} |
|
|
kernfs_open(vp, mode, cred, p) |
int |
struct vnode *vp; |
kernfs_access(void *v) |
int mode; |
|
struct ucred *cred; |
|
struct proc *p; |
|
{ |
{ |
/* if access succeeded, this always does, too */ |
struct vop_access_args /* { |
|
struct vnode *a_vp; |
|
int a_mode; |
|
kauth_cred_t a_cred; |
|
} */ *ap = v; |
|
struct vattr va; |
|
int error; |
|
|
return (0); |
if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0) |
|
return (error); |
|
|
|
return kauth_authorize_vnode(ap->a_cred, |
|
KAUTH_ACCESS_ACTION(ap->a_mode, ap->a_vp->v_type, va.va_mode), |
|
ap->a_vp, NULL, genfs_can_access(va.va_type, va.va_mode, |
|
va.va_uid, va.va_gid, ap->a_mode, ap->a_cred)); |
} |
} |
|
|
/* |
static int |
* Check mode permission on target pointer. Mode is READ, WRITE or EXEC. |
kernfs_default_fileop_getattr(void *v) |
* The mode is shifted to select the owner/group/other fields. The |
{ |
* super user is granted all permissions. |
struct vop_getattr_args /* { |
*/ |
struct vnode *a_vp; |
kernfs_access(vp, mode, cred, p) |
struct vattr *a_vap; |
struct vnode *vp; |
kauth_cred_t a_cred; |
register int mode; |
} */ *ap = v; |
struct ucred *cred; |
struct vattr *vap = ap->a_vap; |
struct proc *p; |
|
{ |
vap->va_nlink = 1; |
struct kernfs_target *kt = VTOKERN(vp)->kf_kt; |
vap->va_bytes = vap->va_size = 0; |
register gid_t *gp; |
|
int i, error; |
return 0; |
|
|
#ifdef KERN_DIAGNOSTIC |
|
if (!VOP_ISLOCKED(vp)) { |
|
vprint("kernfs_access: not locked", vp); |
|
panic("kernfs_access: not locked"); |
|
} |
|
#endif |
|
/* |
|
* If you're the super-user, you always get access. |
|
*/ |
|
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 != /* kt->kt_uid XXX */ 0) { |
|
mode >>= 3; |
|
gp = cred->cr_groups; |
|
for (i = 0; i < cred->cr_ngroups; i++, gp++) |
|
if (/* kt->kt_gid XXX */ 0 == *gp) |
|
goto found; |
|
mode >>= 3; |
|
found: |
|
; |
|
} |
|
if ((kt->kt_perms & mode) == mode) |
|
return (0); |
|
return (EACCES); |
|
} |
} |
|
|
kernfs_getattr(vp, vap, cred, p) |
int |
struct vnode *vp; |
kernfs_getattr(void *v) |
struct vattr *vap; |
|
struct ucred *cred; |
|
struct proc *p; |
|
{ |
{ |
|
struct vop_getattr_args /* { |
|
struct vnode *a_vp; |
|
struct vattr *a_vap; |
|
kauth_cred_t a_cred; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
struct kernfs_subdir *ks; |
|
struct vattr *vap = ap->a_vap; |
int error = 0; |
int error = 0; |
char strbuf[KSTRING]; |
char strbuf[KSTRING], *bf; |
struct kernfs_target *kt = VTOKERN(vp)->kf_kt; |
size_t nread, total; |
|
|
bzero((caddr_t) vap, sizeof(*vap)); |
|
vattr_null(vap); |
vattr_null(vap); |
vap->va_uid = kt->kt_uid; |
vap->va_type = ap->a_vp->v_type; |
vap->va_gid = kt->kt_gid; |
vap->va_uid = 0; |
vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; |
vap->va_gid = 0; |
/* vap->va_qsize = 0; */ |
vap->va_mode = kfs->kfs_mode; |
|
vap->va_fileid = kfs->kfs_fileno; |
|
vap->va_flags = 0; |
|
vap->va_size = 0; |
vap->va_blocksize = DEV_BSIZE; |
vap->va_blocksize = DEV_BSIZE; |
microtime(&vap->va_atime); |
/* Make all times be current TOD, except for the "boottime" node. */ |
vap->va_mtime = vap->va_atime; |
if (kfs->kfs_kt->kt_namlen == 8 && |
vap->va_ctime = vap->va_ctime; |
!memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) { |
|
vap->va_ctime = boottime; |
|
} else { |
|
getnanotime(&vap->va_ctime); |
|
} |
|
vap->va_atime = vap->va_mtime = 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; |
vap->va_type = kt->kt_vtype; |
|
vap->va_mode = kt->kt_perms; |
|
|
|
if (vp->v_flag & VROOT) { |
switch (kfs->kfs_type) { |
#ifdef KERNFS_DIAGNOSTIC |
case KFSkern: |
printf("kernfs_getattr: stat rootdir\n"); |
vap->va_nlink = nkern_dirs; |
#endif |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
vap->va_nlink = 2; |
break; |
vap->va_fileid = 2; |
|
vap->va_size = DEV_BSIZE; |
case KFSdevice: |
} else { |
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_getattr: stat target %s\n", kt->kt_name); |
|
#endif |
|
vap->va_nlink = 1; |
vap->va_nlink = 1; |
vap->va_fileid = 3 + (kt - kernfs_targets) / sizeof(*kt); |
vap->va_rdev = ap->a_vp->v_rdev; |
error = kernfs_xread(kt, strbuf, sizeof(strbuf), &vap->va_size); |
break; |
} |
|
|
|
vp->v_type = vap->va_type; |
case KFSroot: |
#ifdef KERNFS_DIAGNOSTIC |
vap->va_nlink = 1; |
printf("kernfs_getattr: return error %d\n", error); |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
#endif |
break; |
return (error); |
|
} |
|
|
|
|
case KFSsubdir: |
|
ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data; |
|
vap->va_nlink = ks->ks_dirs; |
|
vap->va_bytes = vap->va_size = DEV_BSIZE; |
|
break; |
|
|
/* |
case KFSnull: |
* Change the mode on a file. |
case KFStime: |
*/ |
case KFSint: |
kernfs_chmod1(vp, mode, p) |
case KFSstring: |
register struct vnode *vp; |
case KFShostname: |
register int mode; |
case KFSavenrun: |
struct proc *p; |
case KFSmsgbuf: |
{ |
vap->va_nlink = 1; |
register struct ucred *cred = p->p_ucred; |
total = 0; |
register struct kernfs_target *kt = VTOKERN(vp)->kf_kt; |
do { |
int error; |
bf = strbuf; |
|
error = kernfs_xread(kfs, total, &bf, |
|
sizeof(strbuf), &nread); |
|
total += nread; |
|
} while (error == 0 && nread != 0); |
|
vap->va_bytes = vap->va_size = total; |
|
break; |
|
|
if ((mode & kt->kt_maxperms) != mode) /* can't set ro var to rw */ |
default: |
return (EPERM); |
error = kernfs_try_fileop(kfs->kfs_type, |
|
KERNFS_FILEOP_GETATTR, v, EINVAL); |
|
break; |
|
} |
|
|
if (cred->cr_uid != kt->kt_uid && |
return (error); |
(error = suser(cred, &p->p_acflag))) |
|
return (error); |
|
if (cred->cr_uid) { |
|
if (vp->v_type != VDIR && (mode & S_ISVTX)) |
|
return (EFTYPE); |
|
if (!groupmember(kt->kt_gid, cred) && (mode & S_ISGID)) |
|
return (EPERM); |
|
} |
|
kt->kt_perms &= ~07777; |
|
kt->kt_perms |= mode & 07777; |
|
/* ip->i_flag |= ICHG;*/ |
|
return (0); |
|
} |
} |
|
|
/* |
/*ARGSUSED*/ |
* Perform chown operation on kernfs_target kt |
int |
*/ |
kernfs_setattr(void *v) |
kernfs_chown1(vp, uid, gid, p) |
{ |
register struct vnode *vp; |
|
uid_t uid; |
|
gid_t gid; |
|
struct proc *p; |
|
{ |
|
register struct kernfs_target *kt = VTOKERN(vp)->kf_kt; |
|
register struct ucred *cred = p->p_ucred; |
|
uid_t ouid; |
|
gid_t ogid; |
|
int error = 0; |
|
|
|
if (uid == (u_short)VNOVAL) |
|
uid = kt->kt_uid; |
|
if (gid == (u_short)VNOVAL) |
|
gid = kt->kt_gid; |
|
/* |
/* |
* If we don't own the file, are trying to change the owner |
* Silently ignore attribute changes. |
* of the file, or are not a member of the target group, |
* This allows for open with truncate to have no |
* the caller must be superuser or the call fails. |
* effect until some data is written. I want to |
|
* do it this way because all writes are atomic. |
*/ |
*/ |
if ((cred->cr_uid != kt->kt_uid || uid != kt->kt_uid || |
|
!groupmember((gid_t)gid, cred)) && |
|
(error = suser(cred, &p->p_acflag))) |
|
return (error); |
|
ouid = kt->kt_uid; |
|
ogid = kt->kt_gid; |
|
|
|
kt->kt_uid = uid; |
|
kt->kt_gid = gid; |
|
|
|
/* if (ouid != uid || ogid != gid) |
|
ip->i_flag |= ICHG;*/ |
|
if (ouid != uid && cred->cr_uid != 0) |
|
kt->kt_perms &= ~S_ISUID; |
|
if (ogid != gid && cred->cr_uid != 0) |
|
kt->kt_perms &= ~S_ISGID; |
|
return (0); |
return (0); |
} |
} |
|
|
/* |
int |
* Set attribute vnode op. called from several syscalls |
kernfs_default_xread(void *v) |
*/ |
|
kernfs_setattr(vp, vap, cred, p) |
|
struct vnode *vp; |
|
struct vattr *vap; |
|
struct ucred *cred; |
|
struct proc *p; |
|
{ |
{ |
int error = 0; |
struct vop_read_args /* { |
|
struct vnode *a_vp; |
|
struct uio *a_uio; |
|
int a_ioflag; |
|
kauth_cred_t a_cred; |
|
} */ *ap = v; |
|
struct uio *uio = ap->a_uio; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
char strbuf[KSTRING], *bf; |
|
int off; |
|
size_t len; |
|
int error; |
|
|
/* |
if (ap->a_vp->v_type == VDIR) |
* Check for unsetable attributes. |
return EISDIR; |
*/ |
|
if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || |
off = (int)uio->uio_offset; |
(vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || |
/* Don't allow negative offsets */ |
(vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || |
if (off < 0) |
((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) { |
return EINVAL; |
return (EINVAL); |
|
} |
bf = strbuf; |
/* |
if ((error = kernfs_xread(kfs, off, &bf, sizeof(strbuf), &len)) == 0) |
* Go through the fields and update iff not VNOVAL. |
error = uiomove(bf, len, uio); |
*/ |
|
if (vap->va_uid != (u_short)VNOVAL || vap->va_gid != (u_short)VNOVAL) |
|
if (error = kernfs_chown1(vp, vap->va_uid, vap->va_gid, p)) |
|
return (error); |
|
if (vap->va_size != VNOVAL) { |
|
if (vp->v_type == VDIR) |
|
return (EISDIR); |
|
/* else just nod and smile... */ |
|
} |
|
if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { |
|
/* if (cred->cr_uid != ip->i_uid && |
|
(error = suser(cred, &p->p_acflag))) |
|
return (error); |
|
if (vap->va_atime.tv_sec != VNOVAL) |
|
ip->i_flag |= IACC; |
|
if (vap->va_mtime.tv_sec != VNOVAL) |
|
ip->i_flag |= IUPD; |
|
ip->i_flag |= ICHG; |
|
if (error = iupdat(ip, &vap->va_atime, &vap->va_mtime, 1)) |
|
return (error); |
|
*/ |
|
} |
|
if (vap->va_mode != (u_short)VNOVAL) |
|
error = kernfs_chmod1(vp, (int)vap->va_mode, p); |
|
if (vap->va_flags != VNOVAL) { |
|
/* if (cred->cr_uid != ip->i_uid && |
|
(error = suser(cred, &p->p_acflag))) |
|
return (error); |
|
if (cred->cr_uid == 0) { |
|
ip->i_flags = vap->va_flags; |
|
} else { |
|
ip->i_flags &= 0xffff0000; |
|
ip->i_flags |= (vap->va_flags & 0xffff); |
|
} |
|
ip->i_flag |= ICHG; |
|
*/ |
|
} |
|
return (error); |
return (error); |
} |
} |
|
|
static int |
int |
kernfs_read(vp, uio, ioflag, cred) |
kernfs_read(void *v) |
struct vnode *vp; |
|
struct uio *uio; |
|
int ioflag; |
|
struct ucred *cred; |
|
{ |
{ |
struct kernfs_target *kt = VTOKERN(vp)->kf_kt; |
struct vop_read_args /* { |
char strbuf[KSTRING]; |
struct vnode *a_vp; |
int off = uio->uio_offset; |
struct uio *a_uio; |
int len = 0; |
int a_ioflag; |
char *cp = strbuf; |
struct ucred *a_cred; |
int error; |
} */ *ap = v; |
#ifdef KERNFS_DIAGNOSTIC |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
printf("kern_read %s\n", kt->kt_name); |
|
#endif |
if (kfs->kfs_type < KFSlasttype) { |
|
/* use default function */ |
error = kernfs_xread(kt, strbuf, sizeof(strbuf), &len); |
return kernfs_default_xread(v); |
if (error) |
} |
return (error); |
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_READ, v, |
cp = strbuf + off; |
EOPNOTSUPP); |
len -= off; |
|
return (uiomove(cp, len, uio)); |
|
} |
} |
|
|
static int |
static int |
kernfs_write(vp, uio, ioflag, cred) |
kernfs_default_xwrite(void *v) |
struct vnode *vp; |
|
struct uio *uio; |
|
int ioflag; |
|
struct ucred *cred; |
|
{ |
{ |
struct kernfs_target *kt = VTOKERN(vp)->kf_kt; |
struct vop_write_args /* { |
char strbuf[KSTRING]; |
struct vnode *a_vp; |
int len = uio->uio_resid; |
struct uio *a_uio; |
char *cp = strbuf; |
int a_ioflag; |
int xlen; |
kauth_cred_t a_cred; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
struct uio *uio = ap->a_uio; |
int error; |
int error; |
|
size_t xlen; |
|
char strbuf[KSTRING]; |
|
|
if (uio->uio_offset != 0) |
if (uio->uio_offset != 0) |
return (EINVAL); |
return (EINVAL); |
|
|
xlen = min(uio->uio_resid, KSTRING-1); |
xlen = uimin(uio->uio_resid, KSTRING-1); |
error = uiomove(strbuf, xlen, uio); |
if ((error = uiomove(strbuf, xlen, uio)) != 0) |
if (error) |
|
return (error); |
return (error); |
|
|
if (uio->uio_resid != 0) |
if (uio->uio_resid != 0) |
return (EIO); |
return (EIO); |
|
|
strbuf[xlen] = '\0'; |
strbuf[xlen] = '\0'; |
return (kernfs_xwrite(kt, strbuf, xlen)); |
xlen = strlen(strbuf); |
|
return (kernfs_xwrite(kfs, strbuf, xlen)); |
|
} |
|
|
|
int |
|
kernfs_write(void *v) |
|
{ |
|
struct vop_write_args /* { |
|
struct vnode *a_vp; |
|
struct uio *a_uio; |
|
int a_ioflag; |
|
kauth_cred_t a_cred; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
|
if (kfs->kfs_type < KFSlasttype) { |
|
/* use default function */ |
|
return kernfs_default_xwrite(v); |
|
} |
|
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_WRITE, v, |
|
EOPNOTSUPP); |
|
} |
|
|
|
int |
|
kernfs_ioctl(void *v) |
|
{ |
|
struct vop_ioctl_args /* { |
|
const struct vnodeop_desc *a_desc; |
|
struct vnode *a_vp; |
|
u_long a_command; |
|
void *a_data; |
|
int a_fflag; |
|
kauth_cred_t a_cred; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
|
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_IOCTL, v, |
|
EPASSTHROUGH); |
} |
} |
|
|
kernfs_readdir(vp, uio, cred, eofflagp) |
static int |
|
kernfs_setdirentfileno_kt(struct dirent *d, const struct kern_target *kt, |
|
struct vop_readdir_args *ap) |
|
{ |
|
struct kernfs_node *kfs; |
struct vnode *vp; |
struct vnode *vp; |
struct uio *uio; |
int error; |
struct ucred *cred; |
|
int *eofflagp; |
if ((error = vcache_get(ap->a_vp->v_mount, &kt, sizeof(kt), &vp)) != 0) |
|
return error; |
|
kfs = VTOKERN(vp); |
|
d->d_fileno = kfs->kfs_fileno; |
|
vrele(vp); |
|
return 0; |
|
} |
|
|
|
static int |
|
kernfs_setdirentfileno(struct dirent *d, off_t entry, |
|
struct kernfs_node *thisdir_kfs, const struct kern_target *parent_kt, |
|
const struct kern_target *kt, struct vop_readdir_args *ap) |
{ |
{ |
struct filedesc *fdp; |
const struct kern_target *ikt; |
int i; |
|
int error; |
int error; |
|
|
i = uio->uio_offset / UIO_MX; |
switch (entry) { |
|
case 0: |
|
d->d_fileno = thisdir_kfs->kfs_fileno; |
|
return 0; |
|
case 1: |
|
ikt = parent_kt; |
|
break; |
|
default: |
|
ikt = kt; |
|
break; |
|
} |
|
if (ikt != thisdir_kfs->kfs_kt) { |
|
if ((error = kernfs_setdirentfileno_kt(d, ikt, ap)) != 0) |
|
return error; |
|
} else |
|
d->d_fileno = thisdir_kfs->kfs_fileno; |
|
return 0; |
|
} |
|
|
|
int |
|
kernfs_readdir(void *v) |
|
{ |
|
struct vop_readdir_args /* { |
|
struct vnode *a_vp; |
|
struct uio *a_uio; |
|
kauth_cred_t a_cred; |
|
int *a_eofflag; |
|
off_t **a_cookies; |
|
int a_*ncookies; |
|
} */ *ap = v; |
|
struct uio *uio = ap->a_uio; |
|
struct dirent d; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
const struct kern_target *kt; |
|
const struct dyn_kern_target *dkt = NULL; |
|
const struct kernfs_subdir *ks; |
|
off_t i, j; |
|
int error; |
|
off_t *cookies = NULL; |
|
int ncookies = 0, n; |
|
|
|
if (uio->uio_resid < UIO_MX) |
|
return (EINVAL); |
|
if (uio->uio_offset < 0) |
|
return (EINVAL); |
|
|
error = 0; |
error = 0; |
while (uio->uio_resid > 0) { |
i = uio->uio_offset; |
#ifdef KERNFS_DIAGNOSTIC |
memset(&d, 0, sizeof(d)); |
printf("kernfs_readdir: i = %d\n", i); |
d.d_reclen = UIO_MX; |
#endif |
ncookies = uio->uio_resid / UIO_MX; |
if (i >= nkernfs_targets) { |
|
*eofflagp = 1; |
switch (kfs->kfs_type) { |
break; |
case KFSkern: |
} |
if (i >= nkern_targets) |
{ |
return (0); |
struct direct d; |
|
struct direct *dp = &d; |
if (ap->a_ncookies) { |
struct kernfs_target *kt = &kernfs_targets[i]; |
ncookies = uimin(ncookies, (nkern_targets - i)); |
|
cookies = malloc(ncookies * sizeof(off_t), M_TEMP, |
bzero((caddr_t) dp, UIO_MX); |
M_WAITOK); |
|
*ap->a_cookies = cookies; |
dp->d_namlen = strlen(kt->kt_name); |
} |
bcopy(kt->kt_name, dp->d_name, dp->d_namlen+1); |
|
|
n = 0; |
#ifdef KERNFS_DIAGNOSTIC |
for (; i < nkern_targets && uio->uio_resid >= UIO_MX; i++) { |
printf("kernfs_readdir: name = %s, len = %d\n", |
if (i < static_nkern_targets) |
dp->d_name, dp->d_namlen); |
kt = &kern_targets[i]; |
#endif |
else { |
/* |
if (dkt == NULL) { |
* Fill in the remaining fields |
dkt = SIMPLEQ_FIRST(&dyn_kern_targets); |
*/ |
for (j = static_nkern_targets; j < i && |
dp->d_reclen = UIO_MX; |
dkt != NULL; j++) |
dp->d_ino = i + 3; |
dkt = SIMPLEQ_NEXT(dkt, dkt_queue); |
/* |
if (j != i) |
* And ship to userland |
break; |
*/ |
} else { |
error = uiomove((caddr_t) dp, UIO_MX, uio); |
dkt = SIMPLEQ_NEXT(dkt, dkt_queue); |
if (error) |
} |
|
if (dkt == NULL) |
|
break; |
|
kt = &dkt->dkt_kt; |
|
} |
|
if (kt->kt_tag == KFSdevice) { |
|
dev_t *dp = kt->kt_data; |
|
struct vnode *fvp; |
|
|
|
if (*dp == NODEV || |
|
!vfinddev(*dp, kt->kt_vtype, &fvp)) |
|
continue; |
|
vrele(fvp); |
|
} |
|
if (kt->kt_tag == KFSmsgbuf) { |
|
if (!logenabled(msgbufp)) { |
|
continue; |
|
} |
|
} |
|
d.d_namlen = kt->kt_namlen; |
|
if ((error = kernfs_setdirentfileno(&d, i, kfs, |
|
&kern_targets[0], kt, ap)) != 0) |
|
break; |
|
memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); |
|
d.d_type = kt->kt_type; |
|
if ((error = uiomove(&d, UIO_MX, uio)) != 0) |
|
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
|
} |
|
ncookies = n; |
|
break; |
|
|
|
case KFSroot: |
|
if (i >= 2) |
|
return 0; |
|
|
|
if (ap->a_ncookies) { |
|
ncookies = uimin(ncookies, (2 - i)); |
|
cookies = malloc(ncookies * sizeof(off_t), M_TEMP, |
|
M_WAITOK); |
|
*ap->a_cookies = cookies; |
|
} |
|
|
|
n = 0; |
|
for (; i < 2 && uio->uio_resid >= UIO_MX; i++) { |
|
kt = &kern_targets[i]; |
|
d.d_namlen = kt->kt_namlen; |
|
d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0); |
|
memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); |
|
d.d_type = kt->kt_type; |
|
if ((error = uiomove(&d, UIO_MX, uio)) != 0) |
|
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
|
} |
|
ncookies = n; |
|
break; |
|
|
|
case KFSsubdir: |
|
ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data; |
|
if (i >= ks->ks_nentries) |
|
return (0); |
|
|
|
if (ap->a_ncookies) { |
|
ncookies = uimin(ncookies, (ks->ks_nentries - i)); |
|
cookies = malloc(ncookies * sizeof(off_t), M_TEMP, |
|
M_WAITOK); |
|
*ap->a_cookies = cookies; |
|
} |
|
|
|
dkt = SIMPLEQ_FIRST(&ks->ks_entries); |
|
for (j = 0; j < i && dkt != NULL; j++) |
|
dkt = SIMPLEQ_NEXT(dkt, dkt_queue); |
|
n = 0; |
|
for (; i < ks->ks_nentries && uio->uio_resid >= UIO_MX; i++) { |
|
if (i < 2) |
|
kt = &subdir_targets[i]; |
|
else { |
|
/* check if ks_nentries lied to us */ |
|
if (dkt == NULL) |
|
break; |
|
kt = &dkt->dkt_kt; |
|
dkt = SIMPLEQ_NEXT(dkt, dkt_queue); |
|
} |
|
if (kt->kt_tag == KFSdevice) { |
|
dev_t *dp = kt->kt_data; |
|
struct vnode *fvp; |
|
|
|
if (*dp == NODEV || |
|
!vfinddev(*dp, kt->kt_vtype, &fvp)) |
|
continue; |
|
vrele(fvp); |
|
} |
|
d.d_namlen = kt->kt_namlen; |
|
if ((error = kernfs_setdirentfileno(&d, i, kfs, |
|
ks->ks_parent, kt, ap)) != 0) |
|
break; |
|
memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); |
|
d.d_type = kt->kt_type; |
|
if ((error = uiomove(&d, UIO_MX, uio)) != 0) |
break; |
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
} |
} |
i++; |
ncookies = n; |
|
break; |
|
|
|
default: |
|
error = ENOTDIR; |
|
break; |
} |
} |
|
|
uio->uio_offset = i * UIO_MX; |
if (ap->a_ncookies) { |
|
if (error) { |
|
if (cookies) |
|
free(*ap->a_cookies, M_TEMP); |
|
*ap->a_ncookies = 0; |
|
*ap->a_cookies = NULL; |
|
} else |
|
*ap->a_ncookies = ncookies; |
|
} |
|
|
|
uio->uio_offset = i; |
return (error); |
return (error); |
} |
} |
|
|
kernfs_inactive(vp, p) |
int |
struct vnode *vp; |
kernfs_inactive(void *v) |
struct proc *p; |
|
{ |
{ |
/* |
struct vop_inactive_v2_args /* { |
* Clear out the v_type field to avoid |
struct vnode *a_vp; |
* nasty things happening in vgone(). |
bool *a_recycle; |
*/ |
} */ *ap = v; |
vp->v_type = VNON; |
|
#ifdef KERNFS_DIAGNOSTIC |
*ap->a_recycle = false; |
printf("kernfs_inactive(%x)\n", vp); |
|
#endif |
|
return (0); |
return (0); |
} |
} |
|
|
/* |
int |
* Print out the contents of a kernfs vnode. |
kernfs_reclaim(void *v) |
*/ |
|
/* ARGSUSED */ |
|
kernfs_print(vp) |
|
struct vnode *vp; |
|
{ |
{ |
printf("tag VT_KERNFS, kernfs vnode\n"); |
struct vop_reclaim_v2_args /* { |
} |
struct vnode *a_vp; |
|
} */ *ap = v; |
|
struct vnode *vp = ap->a_vp; |
|
struct kernfs_node *kfs = VTOKERN(vp); |
|
|
|
VOP_UNLOCK(vp); |
|
|
|
vp->v_data = NULL; |
|
mutex_enter(&kfs_lock); |
|
TAILQ_REMOVE(&VFSTOKERNFS(vp->v_mount)->nodelist, kfs, kfs_list); |
|
mutex_exit(&kfs_lock); |
|
kmem_free(kfs, sizeof(struct kernfs_node)); |
|
|
/* |
return 0; |
* kernfs vnode unsupported operation |
|
*/ |
|
kernfs_enotsupp() |
|
{ |
|
return (EOPNOTSUPP); |
|
} |
} |
|
|
/* |
/* |
* kernfs "should never get here" operation |
* Return POSIX pathconf information applicable to special devices. |
*/ |
*/ |
kernfs_badop() |
int |
|
kernfs_pathconf(void *v) |
{ |
{ |
panic("kernfs: bad op"); |
struct vop_pathconf_args /* { |
|
struct vnode *a_vp; |
|
int a_name; |
|
register_t *a_retval; |
|
} */ *ap = v; |
|
|
|
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); |
|
case _PC_SYNC_IO: |
|
*ap->a_retval = 1; |
|
return (0); |
|
default: |
|
return (EINVAL); |
|
} |
/* NOTREACHED */ |
/* NOTREACHED */ |
} |
} |
|
|
/* |
/* |
* kernfs vnode null operation |
* Print out the contents of a /dev/fd vnode. |
*/ |
*/ |
kernfs_nullop() |
/* ARGSUSED */ |
|
int |
|
kernfs_print(void *v) |
{ |
{ |
|
|
|
printf("tag VT_KERNFS, kernfs vnode\n"); |
return (0); |
return (0); |
} |
} |
|
|
#define kernfs_create ((int (*) __P(( \ |
int |
struct nameidata *ndp, \ |
kernfs_link(void *v) |
struct vattr *vap, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_mknod ((int (*) __P(( \ |
|
struct nameidata *ndp, \ |
|
struct vattr *vap, \ |
|
struct ucred *cred, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_close ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
int fflag, \ |
|
struct ucred *cred, \ |
|
struct proc *p))) nullop) |
|
#define kernfs_ioctl ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
int command, \ |
|
caddr_t data, \ |
|
int fflag, \ |
|
struct ucred *cred, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_select ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
int which, \ |
|
int fflags, \ |
|
struct ucred *cred, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_mmap ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
int fflags, \ |
|
struct ucred *cred, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_fsync ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
int fflags, \ |
|
struct ucred *cred, \ |
|
int waitfor, \ |
|
struct proc *p))) nullop) |
|
#define kernfs_seek ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
off_t oldoff, \ |
|
off_t newoff, \ |
|
struct ucred *cred))) nullop) |
|
#define kernfs_remove ((int (*) __P(( \ |
|
struct nameidata *ndp, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_link ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
struct nameidata *ndp, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_rename ((int (*) __P(( \ |
|
struct nameidata *fndp, \ |
|
struct nameidata *tdnp, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_mkdir ((int (*) __P(( \ |
|
struct nameidata *ndp, \ |
|
struct vattr *vap, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_rmdir ((int (*) __P(( \ |
|
struct nameidata *ndp, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_symlink ((int (*) __P(( \ |
|
struct nameidata *ndp, \ |
|
struct vattr *vap, \ |
|
char *target, \ |
|
struct proc *p))) kernfs_enotsupp) |
|
#define kernfs_readlink ((int (*) __P(( \ |
|
struct vnode *vp, \ |
|
struct uio *uio, \ |
|
struct ucred *cred))) kernfs_enotsupp) |
|
#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); |
struct vop_link_v2_args /* { |
return (0); |
struct vnode *a_dvp; |
|
struct vnode *a_vp; |
|
struct componentname *a_cnp; |
|
} */ *ap = v; |
|
|
|
VOP_ABORTOP(ap->a_dvp, ap->a_cnp); |
|
return (EROFS); |
|
} |
|
|
|
int |
|
kernfs_symlink(void *v) |
|
{ |
|
struct vop_symlink_v3_args /* { |
|
struct vnode *a_dvp; |
|
struct vnode **a_vpp; |
|
struct componentname *a_cnp; |
|
struct vattr *a_vap; |
|
char *a_target; |
|
} */ *ap = v; |
|
|
|
VOP_ABORTOP(ap->a_dvp, ap->a_cnp); |
|
return (EROFS); |
} |
} |
#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 */ |
|
}; |
|