version 1.90, 2003/09/08 06:51:54 |
version 1.127, 2006/11/04 20:51:32 |
Line 79 __KERNEL_RCSID(0, "$NetBSD$"); |
|
Line 79 __KERNEL_RCSID(0, "$NetBSD$"); |
|
|
|
#define READ_MODE (S_IRUSR|S_IRGRP|S_IROTH) |
#define READ_MODE (S_IRUSR|S_IRGRP|S_IROTH) |
#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 UREAD_MODE (S_IRUSR) |
#define UDIR_MODE (S_IRUSR|S_IXUSR) |
#define DIR_MODE (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) |
|
#define UDIR_MODE (S_IRUSR|S_IXUSR) |
|
|
#define N(s) sizeof(s)-1, s |
#define N(s) sizeof(s)-1, s |
const struct kern_target kern_targets[] = { |
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 */ |
/* name data tag type ro/rw */ |
/* name data tag type ro/rw */ |
{ DT_DIR, N("."), 0, Pkern, VDIR, DIR_MODE }, |
{ DT_DIR, N("."), 0, KFSkern, VDIR, DIR_MODE }, |
{ DT_DIR, N(".."), 0, Proot, VDIR, DIR_MODE }, |
{ DT_DIR, N(".."), 0, KFSroot, VDIR, DIR_MODE }, |
{ DT_REG, N("boottime"), &boottime.tv_sec, Pint, VREG, READ_MODE }, |
{ DT_REG, N("boottime"), &boottime.tv_sec, KFSint, VREG, READ_MODE }, |
/* XXX cast away const */ |
/* XXXUNCONST */ |
{ DT_REG, N("copyright"), (void *)copyright, |
{ DT_REG, N("copyright"), __UNCONST(copyright), |
Pstring, VREG, READ_MODE }, |
KFSstring, VREG, READ_MODE }, |
{ DT_REG, N("hostname"), 0, Phostname, VREG, WRITE_MODE }, |
{ DT_REG, N("hostname"), 0, KFShostname, VREG, WRITE_MODE }, |
{ DT_REG, N("hz"), &hz, Pint, VREG, READ_MODE }, |
{ DT_REG, N("hz"), &hz, KFSint, VREG, READ_MODE }, |
#ifdef IPSEC |
#ifdef IPSEC |
{ DT_DIR, N("ipsecsa"), 0, Pipsecsadir, VDIR, UDIR_MODE }, |
{ DT_DIR, N("ipsecsa"), 0, KFSipsecsadir, VDIR, UDIR_MODE }, |
{ DT_DIR, N("ipsecsp"), 0, Pipsecspdir, VDIR, UDIR_MODE }, |
{ DT_DIR, N("ipsecsp"), 0, KFSipsecspdir, VDIR, UDIR_MODE }, |
#endif |
#endif |
{ DT_REG, N("loadavg"), 0, Pavenrun, VREG, READ_MODE }, |
{ DT_REG, N("loadavg"), 0, KFSavenrun, VREG, READ_MODE }, |
{ DT_REG, N("msgbuf"), 0, Pmsgbuf, VREG, READ_MODE }, |
{ DT_REG, N("msgbuf"), 0, KFSmsgbuf, VREG, READ_MODE }, |
{ DT_REG, N("pagesize"), &uvmexp.pagesize, Pint, VREG, READ_MODE }, |
{ DT_REG, N("pagesize"), &uvmexp.pagesize, KFSint, VREG, READ_MODE }, |
{ DT_REG, N("physmem"), &physmem, Pint, VREG, READ_MODE }, |
{ DT_REG, N("physmem"), &physmem, KFSint, VREG, READ_MODE }, |
#if 0 |
#if 0 |
{ DT_DIR, N("root"), 0, Pnull, VDIR, DIR_MODE }, |
{ DT_DIR, N("root"), 0, KFSnull, VDIR, DIR_MODE }, |
#endif |
#endif |
{ DT_BLK, N("rootdev"), &rootdev, Pdevice, VBLK, READ_MODE }, |
{ DT_BLK, N("rootdev"), &rootdev, KFSdevice, VBLK, READ_MODE }, |
{ DT_CHR, N("rrootdev"), &rrootdev, Pdevice, VCHR, READ_MODE }, |
{ DT_CHR, N("rrootdev"), &rrootdev, KFSdevice, VCHR, READ_MODE }, |
{ DT_REG, N("time"), 0, Ptime, VREG, READ_MODE }, |
{ DT_REG, N("time"), 0, KFStime, VREG, READ_MODE }, |
/* XXX cast away const */ |
/* XXXUNCONST */ |
{ DT_REG, N("version"), (void *)version, |
{ DT_REG, N("version"), __UNCONST(version), |
Pstring, VREG, READ_MODE }, |
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 }, |
}; |
}; |
#ifdef IPSEC |
#ifdef IPSEC |
const struct kern_target ipsecsa_targets[] = { |
const struct kern_target ipsecsa_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 type ro/rw */ |
/* name data tag type ro/rw */ |
{ DT_DIR, N("."), 0, Pipsecsadir, VDIR, DIR_MODE }, |
{ DT_DIR, N("."), 0, KFSipsecsadir, VDIR, DIR_MODE }, |
{ DT_DIR, N(".."), 0, Pkern, VDIR, DIR_MODE }, |
{ DT_DIR, N(".."), 0, KFSkern, VDIR, DIR_MODE }, |
}; |
}; |
const struct kern_target ipsecsp_targets[] = { |
const struct kern_target ipsecsp_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 type ro/rw */ |
/* name data tag type ro/rw */ |
{ DT_DIR, N("."), 0, Pipsecspdir, VDIR, DIR_MODE }, |
{ DT_DIR, N("."), 0, KFSipsecspdir, VDIR, DIR_MODE }, |
{ DT_DIR, N(".."), 0, Pkern, VDIR, DIR_MODE }, |
{ DT_DIR, N(".."), 0, KFSkern, VDIR, DIR_MODE }, |
}; |
}; |
|
const struct kern_target ipsecsa_kt = |
|
{ DT_DIR, N(""), 0, KFSipsecsa, VREG, UREAD_MODE }; |
|
const struct kern_target ipsecsp_kt = |
|
{ DT_DIR, N(""), 0, KFSipsecsp, VREG, UREAD_MODE }; |
#endif |
#endif |
#undef N |
#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]); |
int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); |
|
const int static_nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); |
#ifdef IPSEC |
#ifdef IPSEC |
int nipsecsa_targets = sizeof(ipsecsa_targets) / sizeof(ipsecsa_targets[0]); |
int nipsecsa_targets = sizeof(ipsecsa_targets) / sizeof(ipsecsa_targets[0]); |
int nipsecsp_targets = sizeof(ipsecsp_targets) / sizeof(ipsecsp_targets[0]); |
int nipsecsp_targets = sizeof(ipsecsp_targets) / sizeof(ipsecsp_targets[0]); |
|
int nkern_dirs = 4; /* 2 extra subdirs */ |
|
#else |
|
int nkern_dirs = 2; |
#endif |
#endif |
|
|
|
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 }, |
|
}; |
|
|
int kernfs_lookup __P((void *)); |
int kernfs_lookup(void *); |
#define kernfs_create genfs_eopnotsupp |
#define kernfs_create genfs_eopnotsupp |
#define kernfs_mknod genfs_eopnotsupp |
#define kernfs_mknod genfs_eopnotsupp |
int kernfs_open __P((void *)); |
int kernfs_open(void *); |
int kernfs_close __P((void *)); |
int kernfs_close(void *); |
int kernfs_access __P((void *)); |
int kernfs_access(void *); |
int kernfs_getattr __P((void *)); |
int kernfs_getattr(void *); |
int kernfs_setattr __P((void *)); |
int kernfs_setattr(void *); |
int kernfs_read __P((void *)); |
int kernfs_read(void *); |
int kernfs_write __P((void *)); |
int kernfs_write(void *); |
#define kernfs_fcntl genfs_fcntl |
#define kernfs_fcntl genfs_fcntl |
#define kernfs_ioctl genfs_enoioctl |
int kernfs_ioctl(void *); |
#define kernfs_poll genfs_poll |
#define kernfs_poll genfs_poll |
#define kernfs_revoke genfs_revoke |
#define kernfs_revoke genfs_revoke |
#define kernfs_fsync genfs_nullop |
#define kernfs_fsync genfs_nullop |
#define kernfs_seek genfs_nullop |
#define kernfs_seek genfs_nullop |
#define kernfs_remove genfs_eopnotsupp |
#define kernfs_remove genfs_eopnotsupp |
int kernfs_link __P((void *)); |
int kernfs_link(void *); |
#define kernfs_rename genfs_eopnotsupp |
#define kernfs_rename genfs_eopnotsupp |
#define kernfs_mkdir genfs_eopnotsupp |
#define kernfs_mkdir genfs_eopnotsupp |
#define kernfs_rmdir genfs_eopnotsupp |
#define kernfs_rmdir genfs_eopnotsupp |
int kernfs_symlink __P((void *)); |
int kernfs_symlink(void *); |
int kernfs_readdir __P((void *)); |
int kernfs_readdir(void *); |
#define kernfs_readlink genfs_eopnotsupp |
#define kernfs_readlink genfs_eopnotsupp |
#define kernfs_abortop genfs_abortop |
#define kernfs_abortop genfs_abortop |
int kernfs_inactive __P((void *)); |
int kernfs_inactive(void *); |
int kernfs_reclaim __P((void *)); |
int kernfs_reclaim(void *); |
#define kernfs_lock genfs_lock |
#define kernfs_lock genfs_lock |
#define kernfs_unlock genfs_unlock |
#define kernfs_unlock genfs_unlock |
#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(void *); |
#define kernfs_islocked genfs_islocked |
#define kernfs_islocked genfs_islocked |
int kernfs_pathconf __P((void *)); |
int kernfs_pathconf(void *); |
#define kernfs_advlock genfs_einval |
#define kernfs_advlock genfs_einval |
#define kernfs_blkatoff genfs_eopnotsupp |
|
#define kernfs_valloc genfs_eopnotsupp |
|
#define kernfs_vfree genfs_nullop |
|
#define kernfs_truncate genfs_eopnotsupp |
|
#define kernfs_update genfs_nullop |
|
#define kernfs_bwrite genfs_eopnotsupp |
#define kernfs_bwrite genfs_eopnotsupp |
#define kernfs_putpages genfs_putpages |
#define kernfs_putpages genfs_putpages |
|
|
static int kernfs_xread __P((struct kernfs_node *, int, char **, size_t, size_t *)); |
static int kernfs_xread(struct kernfs_node *, int, char **, |
static int kernfs_xwrite __P((const struct kernfs_node *, char *, size_t)); |
size_t, size_t *); |
|
static int kernfs_xwrite(const struct kernfs_node *, char *, size_t); |
|
|
int (**kernfs_vnodeop_p) __P((void *)); |
int (**kernfs_vnodeop_p)(void *); |
const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { |
const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { |
{ &vop_default_desc, vn_default_error }, |
{ &vop_default_desc, vn_default_error }, |
{ &vop_lookup_desc, kernfs_lookup }, /* lookup */ |
{ &vop_lookup_desc, kernfs_lookup }, /* lookup */ |
Line 218 const struct vnodeopv_entry_desc kernfs_ |
|
Line 255 const struct vnodeopv_entry_desc kernfs_ |
|
{ &vop_islocked_desc, kernfs_islocked }, /* islocked */ |
{ &vop_islocked_desc, kernfs_islocked }, /* islocked */ |
{ &vop_pathconf_desc, kernfs_pathconf }, /* pathconf */ |
{ &vop_pathconf_desc, kernfs_pathconf }, /* pathconf */ |
{ &vop_advlock_desc, kernfs_advlock }, /* advlock */ |
{ &vop_advlock_desc, kernfs_advlock }, /* advlock */ |
{ &vop_blkatoff_desc, kernfs_blkatoff }, /* blkatoff */ |
|
{ &vop_valloc_desc, kernfs_valloc }, /* valloc */ |
|
{ &vop_vfree_desc, kernfs_vfree }, /* vfree */ |
|
{ &vop_truncate_desc, kernfs_truncate }, /* truncate */ |
|
{ &vop_update_desc, kernfs_update }, /* update */ |
|
{ &vop_bwrite_desc, kernfs_bwrite }, /* bwrite */ |
{ &vop_bwrite_desc, kernfs_bwrite }, /* bwrite */ |
{ &vop_putpages_desc, kernfs_putpages }, /* putpages */ |
{ &vop_putpages_desc, kernfs_putpages }, /* putpages */ |
{ NULL, NULL } |
{ NULL, NULL } |
Line 230 const struct vnodeopv_entry_desc kernfs_ |
|
Line 262 const struct vnodeopv_entry_desc kernfs_ |
|
const struct vnodeopv_desc kernfs_vnodeop_opv_desc = |
const struct vnodeopv_desc kernfs_vnodeop_opv_desc = |
{ &kernfs_vnodeop_p, kernfs_vnodeop_entries }; |
{ &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(kfs, off, bufp, len, wrlen) |
kernfs_xread(kfs, off, bufp, len, wrlen) |
struct kernfs_node *kfs; |
struct kernfs_node *kfs; |
Line 242 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 391 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
#ifdef IPSEC |
#ifdef IPSEC |
struct mbuf *m; |
struct mbuf *m; |
#endif |
#endif |
|
int err; |
|
|
kt = kfs->kfs_kt; |
kt = kfs->kfs_kt; |
|
|
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
case Ptime: { |
case KFStime: { |
struct timeval tv; |
struct timeval tv; |
|
|
microtime(&tv); |
microtime(&tv); |
Line 254 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 404 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
break; |
break; |
} |
} |
|
|
case Pint: { |
case KFSint: { |
int *ip = kt->kt_data; |
int *ip = kt->kt_data; |
|
|
snprintf(*bufp, len, "%d\n", *ip); |
snprintf(*bufp, len, "%d\n", *ip); |
break; |
break; |
} |
} |
|
|
case Pstring: { |
case KFSstring: { |
char *cp = kt->kt_data; |
char *cp = kt->kt_data; |
|
|
*bufp = cp; |
*bufp = cp; |
break; |
break; |
} |
} |
|
|
case Pmsgbuf: { |
case KFSmsgbuf: { |
long n; |
long n; |
|
|
/* |
/* |
Line 302 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 452 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
return (0); |
return (0); |
} |
} |
|
|
case Phostname: { |
case KFShostname: { |
char *cp = hostname; |
char *cp = hostname; |
int xlen = hostnamelen; |
size_t xlen = hostnamelen; |
|
|
if (xlen >= (len - 2)) |
if (xlen >= (len - 2)) |
return (EINVAL); |
return (EINVAL); |
Line 316 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 466 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
break; |
break; |
} |
} |
|
|
case Pavenrun: |
case KFSavenrun: |
averunnable.fscale = FSCALE; |
averunnable.fscale = FSCALE; |
snprintf(*bufp, len, "%d %d %d %ld\n", |
snprintf(*bufp, len, "%d %d %d %ld\n", |
averunnable.ldavg[0], averunnable.ldavg[1], |
averunnable.ldavg[0], averunnable.ldavg[1], |
Line 324 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 474 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
break; |
break; |
|
|
#ifdef IPSEC |
#ifdef IPSEC |
case Pipsecsa: |
case KFSipsecsa: |
/* |
/* |
* Note that SA configuration could be changed during the |
* Note that SA configuration could be changed during the |
* read operation, resulting in garbled output. |
* read operation, resulting in garbled output. |
Line 344 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 494 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
m_freem(m); |
m_freem(m); |
return (0); |
return (0); |
|
|
case Pipsecsp: |
case KFSipsecsp: |
/* |
/* |
* Note that SP configuration could be changed during the |
* Note that SP configuration could be changed during the |
* read operation, resulting in garbled output. |
* read operation, resulting in garbled output. |
Line 376 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 526 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
#endif |
#endif |
|
|
default: |
default: |
*wrlen = 0; |
err = kernfs_try_xread(kfs->kfs_type, kfs, bufp, len, |
return (0); |
EOPNOTSUPP); |
|
if (err) |
|
return err; |
} |
} |
|
|
len = strlen(*bufp); |
len = strlen(*bufp); |
Line 391 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 543 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
} |
} |
|
|
static int |
static int |
kernfs_xwrite(kfs, buf, len) |
kernfs_xwrite(kfs, bf, len) |
const struct kernfs_node *kfs; |
const struct kernfs_node *kfs; |
char *buf; |
char *bf; |
size_t len; |
size_t len; |
{ |
{ |
|
|
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
case Phostname: |
case KFShostname: |
if (buf[len-1] == '\n') |
if (bf[len-1] == '\n') |
--len; |
--len; |
memcpy(hostname, buf, len); |
memcpy(hostname, bf, len); |
hostname[len] = '\0'; |
hostname[len] = '\0'; |
hostnamelen = (size_t) len; |
hostnamelen = (size_t) len; |
return (0); |
return (0); |
|
|
default: |
default: |
return (EIO); |
return kernfs_try_xwrite(kfs->kfs_type, kfs, bf, len, EIO); |
} |
} |
} |
} |
|
|
Line 431 kernfs_lookup(v) |
|
Line 583 kernfs_lookup(v) |
|
const char *pname = cnp->cn_nameptr; |
const char *pname = cnp->cn_nameptr; |
const struct kernfs_node *kfs; |
const struct kernfs_node *kfs; |
const struct kern_target *kt; |
const struct kern_target *kt; |
|
const struct dyn_kern_target *dkt; |
|
const struct kernfs_subdir *ks; |
int error, i, wantpunlock; |
int error, i, wantpunlock; |
#ifdef IPSEC |
#ifdef IPSEC |
char *ep; |
char *ep; |
Line 452 kernfs_lookup(v) |
|
Line 606 kernfs_lookup(v) |
|
wantpunlock = (~cnp->cn_flags & (LOCKPARENT | ISLASTCN)); |
wantpunlock = (~cnp->cn_flags & (LOCKPARENT | ISLASTCN)); |
kfs = VTOKERN(dvp); |
kfs = VTOKERN(dvp); |
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
case Pkern: |
case KFSkern: |
/* |
/* |
* Shouldn't get here with .. in the root node. |
* Shouldn't get here with .. in the root node. |
*/ |
*/ |
if (cnp->cn_flags & ISDOTDOT) |
if (cnp->cn_flags & ISDOTDOT) |
return (EIO); |
return (EIO); |
|
|
for (i = 0; i < nkern_targets; i++) { |
for (i = 0; i < static_nkern_targets; i++) { |
kt = &kern_targets[i]; |
kt = &kern_targets[i]; |
if (cnp->cn_namelen == kt->kt_namlen && |
if (cnp->cn_namelen == kt->kt_namlen && |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
goto found; |
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; |
break; |
|
|
found: |
found: |
Line 475 kernfs_lookup(v) |
|
Line 636 kernfs_lookup(v) |
|
} |
} |
return (error); |
return (error); |
|
|
|
case KFSsubdir: |
|
ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data; |
|
if (cnp->cn_flags & ISDOTDOT) { |
|
kt = ks->ks_parent; |
|
goto found; |
|
} |
|
|
|
SIMPLEQ_FOREACH(dkt, &ks->ks_entries, 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; |
|
|
#ifdef IPSEC |
#ifdef IPSEC |
case Pipsecsadir: |
case KFSipsecsadir: |
for (i = 0; i < nipsecsa_targets; i++) { |
if (cnp->cn_flags & ISDOTDOT) { |
|
kt = &kern_targets[0]; |
|
goto found; |
|
} |
|
|
|
for (i = 2; i < nipsecsa_targets; i++) { |
kt = &ipsecsa_targets[i]; |
kt = &ipsecsa_targets[i]; |
if (cnp->cn_namelen == kt->kt_namlen && |
if (cnp->cn_namelen == kt->kt_namlen && |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) { |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
error = kernfs_allocvp(dvp->v_mount, vpp, |
goto found; |
kt->kt_tag, kt, 0); |
|
if ((error == 0) && wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
|
return (error); |
|
} |
|
} |
} |
|
|
ep = NULL; |
ep = NULL; |
Line 496 kernfs_lookup(v) |
|
Line 671 kernfs_lookup(v) |
|
if (!ep || *ep || ep == pname) |
if (!ep || *ep || ep == pname) |
break; |
break; |
|
|
error = kernfs_allocvp(dvp->v_mount, vpp, Pipsecsa, NULL, id); |
error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsa, &ipsecsa_kt, id); |
if ((error == 0) && wantpunlock) { |
if ((error == 0) && wantpunlock) { |
VOP_UNLOCK(dvp, 0); |
VOP_UNLOCK(dvp, 0); |
cnp->cn_flags |= PDIRUNLOCK; |
cnp->cn_flags |= PDIRUNLOCK; |
} |
} |
return (error); |
return (error); |
|
|
case Pipsecspdir: |
case KFSipsecspdir: |
for (i = 0; i < nipsecsp_targets; i++) { |
if (cnp->cn_flags & ISDOTDOT) { |
|
kt = &kern_targets[0]; |
|
goto found; |
|
} |
|
|
|
for (i = 2; i < nipsecsp_targets; i++) { |
kt = &ipsecsp_targets[i]; |
kt = &ipsecsp_targets[i]; |
if (cnp->cn_namelen == kt->kt_namlen && |
if (cnp->cn_namelen == kt->kt_namlen && |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) { |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
error = kernfs_allocvp(dvp->v_mount, vpp, |
goto found; |
kt->kt_tag, kt, 0); |
|
if ((error == 0) && wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
|
return (error); |
|
} |
|
} |
} |
|
|
ep = NULL; |
ep = NULL; |
Line 523 kernfs_lookup(v) |
|
Line 696 kernfs_lookup(v) |
|
if (!ep || *ep || ep == pname) |
if (!ep || *ep || ep == pname) |
break; |
break; |
|
|
error = kernfs_allocvp(dvp->v_mount, vpp, Pipsecsp, NULL, id); |
error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsp, &ipsecsp_kt, id); |
if ((error == 0) && wantpunlock) { |
if ((error == 0) && wantpunlock) { |
VOP_UNLOCK(dvp, 0); |
VOP_UNLOCK(dvp, 0); |
cnp->cn_flags |= PDIRUNLOCK; |
cnp->cn_flags |= PDIRUNLOCK; |
|
|
struct vop_open_args /* { |
struct vop_open_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
int a_mode; |
int a_mode; |
struct ucred *a_cred; |
kauth_cred_t a_cred; |
struct proc *a_p; |
struct lwp *a_l; |
} */ *ap = v; |
} */ *ap = v; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
#ifdef IPSEC |
#ifdef IPSEC |
|
|
|
|
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
#ifdef IPSEC |
#ifdef IPSEC |
case Pipsecsa: |
case KFSipsecsa: |
m = key_setdumpsa_spi(htonl(kfs->kfs_value)); |
m = key_setdumpsa_spi(htonl(kfs->kfs_value)); |
if (m) { |
if (m) { |
m_freem(m); |
m_freem(m); |
|
|
} else |
} else |
return (ENOENT); |
return (ENOENT); |
|
|
case Pipsecsp: |
case KFSipsecsp: |
sp = key_getspbyid(kfs->kfs_value); |
sp = key_getspbyid(kfs->kfs_value); |
if (sp) { |
if (sp) { |
kfs->kfs_v = sp; |
kfs->kfs_v = sp; |
|
|
#endif |
#endif |
|
|
default: |
default: |
return (0); |
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_OPEN, |
|
v, 0); |
} |
} |
} |
} |
|
|
|
|
struct vop_close_args /* { |
struct vop_close_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
int a_fflag; |
int a_fflag; |
struct ucred *a_cred; |
kauth_cred_t a_cred; |
struct proc *a_p; |
struct lwp *a_l; |
} */ *ap = v; |
} */ *ap = v; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
#ifdef IPSEC |
#ifdef IPSEC |
case Pipsecsp: |
case KFSipsecsp: |
key_freesp((struct secpolicy *)kfs->kfs_v); |
key_freesp((struct secpolicy *)kfs->kfs_v); |
break; |
break; |
#endif |
#endif |
|
|
default: |
default: |
break; |
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_CLOSE, |
|
v, 0); |
} |
} |
|
|
return (0); |
return (0); |
Line 611 kernfs_access(v) |
|
Line 786 kernfs_access(v) |
|
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; |
kauth_cred_t a_cred; |
struct proc *a_p; |
struct lwp *a_l; |
} */ *ap = v; |
} */ *ap = v; |
struct vattr va; |
struct vattr va; |
int error; |
int error; |
|
|
if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_p)) != 0) |
if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_l)) != 0) |
return (error); |
return (error); |
|
|
return (vaccess(va.va_type, va.va_mode, va.va_uid, va.va_gid, |
return (vaccess(va.va_type, va.va_mode, va.va_uid, va.va_gid, |
ap->a_mode, ap->a_cred)); |
ap->a_mode, ap->a_cred)); |
} |
} |
|
|
|
static int |
|
kernfs_default_fileop_getattr(v) |
|
void *v; |
|
{ |
|
struct vop_getattr_args /* { |
|
struct vnode *a_vp; |
|
struct vattr *a_vap; |
|
kauth_cred_t a_cred; |
|
struct lwp *a_l; |
|
} */ *ap = v; |
|
struct vattr *vap = ap->a_vap; |
|
|
|
vap->va_nlink = 1; |
|
vap->va_bytes = vap->va_size = 0; |
|
|
|
return 0; |
|
} |
|
|
int |
int |
kernfs_getattr(v) |
kernfs_getattr(v) |
void *v; |
void *v; |
Line 631 kernfs_getattr(v) |
|
Line 824 kernfs_getattr(v) |
|
struct vop_getattr_args /* { |
struct vop_getattr_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
struct vattr *a_vap; |
struct vattr *a_vap; |
struct ucred *a_cred; |
kauth_cred_t a_cred; |
struct proc *a_p; |
struct lwp *a_l; |
} */ *ap = v; |
} */ *ap = v; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
struct kernfs_subdir *ks; |
struct vattr *vap = ap->a_vap; |
struct vattr *vap = ap->a_vap; |
int error = 0; |
int error = 0; |
char strbuf[KSTRING], *buf; |
char strbuf[KSTRING], *bf; |
size_t nread, total; |
size_t nread, total; |
|
|
VATTR_NULL(vap); |
VATTR_NULL(vap); |
Line 649 kernfs_getattr(v) |
|
Line 843 kernfs_getattr(v) |
|
vap->va_flags = 0; |
vap->va_flags = 0; |
vap->va_size = 0; |
vap->va_size = 0; |
vap->va_blocksize = DEV_BSIZE; |
vap->va_blocksize = DEV_BSIZE; |
/* |
/* Make all times be current TOD, except for the "boottime" node. */ |
* Make all times be current TOD. Avoid microtime(9), it's slow. |
if (kfs->kfs_kt && kfs->kfs_kt->kt_namlen == 8 && |
* We don't guard the read from time(9) with splclock(9) since we |
!memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) { |
* don't actually need to be THAT sure the access is atomic. |
TIMEVAL_TO_TIMESPEC(&boottime, &vap->va_ctime); |
*/ |
} else { |
TIMEVAL_TO_TIMESPEC(&time, &vap->va_ctime); |
getnanotime(&vap->va_ctime); |
|
} |
vap->va_atime = vap->va_mtime = 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; |
Line 662 kernfs_getattr(v) |
|
Line 857 kernfs_getattr(v) |
|
vap->va_bytes = 0; |
vap->va_bytes = 0; |
|
|
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
case Pkern: |
case KFSkern: |
vap->va_nlink = 4; |
vap->va_nlink = nkern_dirs; |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
break; |
break; |
|
|
case Proot: |
case KFSroot: |
vap->va_nlink = 1; |
vap->va_nlink = 1; |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
break; |
break; |
|
|
case Pnull: |
case KFSsubdir: |
case Ptime: |
ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data; |
case Pint: |
vap->va_nlink = ks->ks_dirs; |
case Pstring: |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
case Phostname: |
break; |
case Pavenrun: |
|
case Pdevice: |
case KFSnull: |
case Pmsgbuf: |
case KFStime: |
|
case KFSint: |
|
case KFSstring: |
|
case KFShostname: |
|
case KFSavenrun: |
|
case KFSdevice: |
|
case KFSmsgbuf: |
#ifdef IPSEC |
#ifdef IPSEC |
case Pipsecsa: |
case KFSipsecsa: |
case Pipsecsp: |
case KFSipsecsp: |
#endif |
#endif |
vap->va_nlink = 1; |
vap->va_nlink = 1; |
total = 0; |
total = 0; |
do { |
do { |
buf = strbuf; |
bf = strbuf; |
error = kernfs_xread(kfs, total, &buf, |
error = kernfs_xread(kfs, total, &bf, |
sizeof(strbuf), &nread); |
sizeof(strbuf), &nread); |
total += nread; |
total += nread; |
} while (error == 0 && nread != 0); |
} while (error == 0 && nread != 0); |
Line 696 kernfs_getattr(v) |
|
Line 897 kernfs_getattr(v) |
|
break; |
break; |
|
|
#ifdef IPSEC |
#ifdef IPSEC |
case Pipsecsadir: |
case KFSipsecsadir: |
case Pipsecspdir: |
case KFSipsecspdir: |
vap->va_nlink = 2; |
vap->va_nlink = 2; |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
break; |
break; |
#endif |
#endif |
|
|
default: |
default: |
error = EINVAL; |
error = kernfs_try_fileop(kfs->kfs_type, |
|
KERNFS_FILEOP_GETATTR, v, EINVAL); |
break; |
break; |
} |
} |
|
|
Line 713 kernfs_getattr(v) |
|
Line 915 kernfs_getattr(v) |
|
|
|
/*ARGSUSED*/ |
/*ARGSUSED*/ |
int |
int |
kernfs_setattr(v) |
kernfs_setattr(void *v __unused) |
void *v; |
|
{ |
{ |
|
|
/* |
/* |
Line 727 kernfs_setattr(v) |
|
Line 928 kernfs_setattr(v) |
|
} |
} |
|
|
int |
int |
kernfs_read(v) |
kernfs_default_xread(v) |
void *v; |
void *v; |
{ |
{ |
struct vop_read_args /* { |
struct vop_read_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
struct uio *a_uio; |
struct uio *a_uio; |
int a_ioflag; |
int a_ioflag; |
struct ucred *a_cred; |
kauth_cred_t a_cred; |
} */ *ap = v; |
} */ *ap = v; |
struct uio *uio = ap->a_uio; |
struct uio *uio = ap->a_uio; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
char strbuf[KSTRING], *buf; |
char strbuf[KSTRING], *bf; |
off_t off; |
int off; |
size_t len; |
size_t len; |
int error; |
int error; |
|
|
if (ap->a_vp->v_type == VDIR) |
if (ap->a_vp->v_type == VDIR) |
return (EOPNOTSUPP); |
return (EOPNOTSUPP); |
|
|
off = uio->uio_offset; |
off = (int)uio->uio_offset; |
buf = strbuf; |
/* Don't allow negative offsets */ |
if ((error = kernfs_xread(kfs, off, &buf, sizeof(strbuf), &len)) == 0) |
if (off < 0) |
error = uiomove(buf, len, uio); |
return EINVAL; |
|
|
|
bf = strbuf; |
|
if ((error = kernfs_xread(kfs, off, &bf, sizeof(strbuf), &len)) == 0) |
|
error = uiomove(bf, len, uio); |
return (error); |
return (error); |
} |
} |
|
|
int |
int |
kernfs_write(v) |
kernfs_read(v) |
void *v; |
void *v; |
{ |
{ |
struct vop_write_args /* { |
struct vop_read_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
struct uio *a_uio; |
struct uio *a_uio; |
int a_ioflag; |
int a_ioflag; |
struct ucred *a_cred; |
struct ucred *a_cred; |
} */ *ap = v; |
} */ *ap = v; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
|
if (kfs->kfs_type < KFSlasttype) { |
|
/* use default function */ |
|
return kernfs_default_xread(v); |
|
} |
|
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_READ, v, |
|
EOPNOTSUPP); |
|
} |
|
|
|
static int |
|
kernfs_default_xwrite(v) |
|
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); |
struct uio *uio = ap->a_uio; |
struct uio *uio = ap->a_uio; |
int error, xlen; |
int error; |
|
size_t xlen; |
char strbuf[KSTRING]; |
char strbuf[KSTRING]; |
|
|
if (uio->uio_offset != 0) |
if (uio->uio_offset != 0) |
|
Line 1010 kernfs_write(v) |
|
} |
} |
|
|
int |
int |
|
kernfs_write(v) |
|
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(v) |
|
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; |
|
struct lwp *a_l; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
|
return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_IOCTL, v, |
|
EPASSTHROUGH); |
|
} |
|
|
|
static int |
|
kernfs_setdirentfileno_kt(struct dirent *d, const struct kern_target *kt, |
|
u_int32_t value, struct vop_readdir_args *ap) |
|
{ |
|
struct kernfs_node *kfs; |
|
struct vnode *vp; |
|
int error; |
|
|
|
if ((error = kernfs_allocvp(ap->a_vp->v_mount, &vp, kt->kt_tag, kt, |
|
value)) != 0) |
|
return error; |
|
if (kt->kt_tag == KFSdevice) { |
|
struct vattr va; |
|
|
|
error = VOP_GETATTR(vp, &va, ap->a_cred, curlwp); |
|
if (error != 0) { |
|
return error; |
|
} |
|
d->d_fileno = va.va_fileid; |
|
} else { |
|
kfs = VTOKERN(vp); |
|
d->d_fileno = kfs->kfs_fileno; |
|
} |
|
vput(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) |
|
{ |
|
const struct kern_target *ikt; |
|
int error; |
|
|
|
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, 0, ap)) != 0) |
|
return error; |
|
} else |
|
d->d_fileno = thisdir_kfs->kfs_fileno; |
|
return 0; |
|
} |
|
|
|
int |
kernfs_readdir(v) |
kernfs_readdir(v) |
void *v; |
void *v; |
{ |
{ |
struct vop_readdir_args /* { |
struct vop_readdir_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
struct uio *a_uio; |
struct uio *a_uio; |
struct ucred *a_cred; |
kauth_cred_t a_cred; |
int *a_eofflag; |
int *a_eofflag; |
off_t **a_cookies; |
off_t **a_cookies; |
int a_*ncookies; |
int a_*ncookies; |
Line 799 kernfs_readdir(v) |
|
Line 1118 kernfs_readdir(v) |
|
struct dirent d; |
struct dirent d; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
const struct kern_target *kt; |
const struct kern_target *kt; |
off_t i; |
const struct dyn_kern_target *dkt = NULL; |
|
const struct kernfs_subdir *ks; |
|
off_t i, j; |
int error; |
int error; |
off_t *cookies = NULL; |
off_t *cookies = NULL; |
int ncookies = 0, n; |
int ncookies = 0, n; |
Line 820 kernfs_readdir(v) |
|
Line 1141 kernfs_readdir(v) |
|
ncookies = uio->uio_resid / UIO_MX; |
ncookies = uio->uio_resid / UIO_MX; |
|
|
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
case Pkern: |
case KFSkern: |
if (i >= nkern_targets) |
if (i >= nkern_targets) |
return (0); |
return (0); |
|
|
Line 833 kernfs_readdir(v) |
|
Line 1154 kernfs_readdir(v) |
|
|
|
n = 0; |
n = 0; |
for (; i < nkern_targets && uio->uio_resid >= UIO_MX; i++) { |
for (; i < nkern_targets && uio->uio_resid >= UIO_MX; i++) { |
kt = &kern_targets[i]; |
if (i < static_nkern_targets) |
|
kt = &kern_targets[i]; |
|
else { |
|
if (dkt == NULL) { |
|
dkt = SIMPLEQ_FIRST(&dyn_kern_targets); |
|
for (j = static_nkern_targets; j < i && |
|
dkt != NULL; j++) |
|
dkt = SIMPLEQ_NEXT(dkt, dkt_queue); |
|
if (j != i) |
|
break; |
|
} else { |
|
dkt = SIMPLEQ_NEXT(dkt, dkt_queue); |
|
} |
|
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; |
|
} |
d.d_namlen = kt->kt_namlen; |
d.d_namlen = kt->kt_namlen; |
if (i < 2) |
if ((error = kernfs_setdirentfileno(&d, i, kfs, |
d.d_fileno = KERNFS_FILENO(&kern_targets[0], |
&kern_targets[0], kt, ap)) != 0) |
kern_targets[0].kt_tag, 0); |
break; |
else |
|
d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0); |
|
memcpy(d.d_name, kt->kt_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(&d, UIO_MX, uio)) != 0) |
break; |
break; |
if (cookies) |
if (cookies) |
*cookies++ = i + 1; |
*cookies++ = i + 1; |
Line 851 kernfs_readdir(v) |
|
Line 1194 kernfs_readdir(v) |
|
ncookies = n; |
ncookies = n; |
break; |
break; |
|
|
case Proot: |
case KFSroot: |
if (i >= 2) |
if (i >= 2) |
return 0; |
return 0; |
|
|
Line 869 kernfs_readdir(v) |
|
Line 1212 kernfs_readdir(v) |
|
d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0); |
d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0); |
memcpy(d.d_name, kt->kt_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(&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 = min(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; |
|
} |
|
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) |
if (cookies) |
*cookies++ = i + 1; |
*cookies++ = i + 1; |
Line 879 kernfs_readdir(v) |
|
Line 1271 kernfs_readdir(v) |
|
break; |
break; |
|
|
#ifdef IPSEC |
#ifdef IPSEC |
case Pipsecsadir: |
case KFSipsecsadir: |
/* count SA in the system */ |
/* count SA in the system */ |
n = 0; |
n = 0; |
TAILQ_FOREACH(sav, &satailq, tailq) { |
TAILQ_FOREACH(sav, &satailq, tailq) { |
Line 909 kernfs_readdir(v) |
|
Line 1301 kernfs_readdir(v) |
|
for (; i < nipsecsa_targets && uio->uio_resid >= UIO_MX; i++) { |
for (; i < nipsecsa_targets && uio->uio_resid >= UIO_MX; i++) { |
kt = &ipsecsa_targets[i]; |
kt = &ipsecsa_targets[i]; |
d.d_namlen = kt->kt_namlen; |
d.d_namlen = kt->kt_namlen; |
d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0); |
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); |
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(&d, UIO_MX, uio)) != 0) |
break; |
break; |
if (cookies) |
if (cookies) |
*cookies++ = i + 1; |
*cookies++ = i + 1; |
Line 936 kernfs_readdir(v) |
|
Line 1330 kernfs_readdir(v) |
|
continue; |
continue; |
if (uio->uio_resid < UIO_MX) |
if (uio->uio_resid < UIO_MX) |
break; |
break; |
d.d_fileno = KERNFS_FILENO(kfs->kfs_kt, kfs->kfs_type, |
if ((error = kernfs_setdirentfileno_kt(&d, &ipsecsa_kt, |
kfs->kfs_cookie); |
sav->spi, ap)) != 0) |
|
break; |
d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), |
d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), |
"%u", ntohl(sav->spi)); |
"%u", ntohl(sav->spi)); |
d.d_type = DT_REG; |
d.d_type = DT_REG; |
if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) |
if ((error = uiomove(&d, UIO_MX, uio)) != 0) |
break; |
break; |
if (cookies) |
if (cookies) |
*cookies++ = i + 1; |
*cookies++ = i + 1; |
Line 951 kernfs_readdir(v) |
|
Line 1346 kernfs_readdir(v) |
|
ncookies = n; |
ncookies = n; |
break; |
break; |
|
|
case Pipsecspdir: |
case KFSipsecspdir: |
/* count SP in the system */ |
/* count SP in the system */ |
n = 0; |
n = 0; |
TAILQ_FOREACH(sp, &sptailq, tailq) |
TAILQ_FOREACH(sp, &sptailq, tailq) |
n++; |
n++; |
|
|
if (i >= 2 + n) |
if (i >= nipsecsp_targets + n) |
return (0); |
return (0); |
|
|
if (ap->a_ncookies) { |
if (ap->a_ncookies) { |
Line 971 kernfs_readdir(v) |
|
Line 1366 kernfs_readdir(v) |
|
for (; i < nipsecsp_targets && uio->uio_resid >= UIO_MX; i++) { |
for (; i < nipsecsp_targets && uio->uio_resid >= UIO_MX; i++) { |
kt = &ipsecsp_targets[i]; |
kt = &ipsecsp_targets[i]; |
d.d_namlen = kt->kt_namlen; |
d.d_namlen = kt->kt_namlen; |
d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0); |
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); |
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(&d, UIO_MX, uio)) != 0) |
break; |
break; |
if (cookies) |
if (cookies) |
*cookies++ = i + 1; |
*cookies++ = i + 1; |
Line 988 kernfs_readdir(v) |
|
Line 1385 kernfs_readdir(v) |
|
TAILQ_FOREACH(sp, &sptailq, tailq) { |
TAILQ_FOREACH(sp, &sptailq, tailq) { |
if (uio->uio_resid < UIO_MX) |
if (uio->uio_resid < UIO_MX) |
break; |
break; |
d.d_fileno = KERNFS_FILENO(kfs->kfs_kt, kfs->kfs_type, |
if ((error = kernfs_setdirentfileno_kt(&d, &ipsecsp_kt, |
kfs->kfs_cookie); |
sp->id, ap)) != 0) |
|
break; |
d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), |
d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), |
"%u", sp->id); |
"%u", sp->id); |
d.d_type = DT_REG; |
d.d_type = DT_REG; |
if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) |
if ((error = uiomove(&d, UIO_MX, uio)) != 0) |
break; |
break; |
if (cookies) |
if (cookies) |
*cookies++ = i + 1; |
*cookies++ = i + 1; |
Line 1029 kernfs_inactive(v) |
|
Line 1427 kernfs_inactive(v) |
|
{ |
{ |
struct vop_inactive_args /* { |
struct vop_inactive_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
struct proc *a_p; |
struct lwp *a_l; |
} */ *ap = v; |
} */ *ap = v; |
struct vnode *vp = ap->a_vp; |
struct vnode *vp = ap->a_vp; |
const struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
const struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
Line 1041 kernfs_inactive(v) |
|
Line 1439 kernfs_inactive(v) |
|
VOP_UNLOCK(vp, 0); |
VOP_UNLOCK(vp, 0); |
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
#ifdef IPSEC |
#ifdef IPSEC |
case Pipsecsa: |
case KFSipsecsa: |
m = key_setdumpsa_spi(htonl(kfs->kfs_value)); |
m = key_setdumpsa_spi(htonl(kfs->kfs_value)); |
if (m) |
if (m) |
m_freem(m); |
m_freem(m); |
else { |
else |
/* should never happen as we hold a refcnt */ |
|
vgone(vp); |
vgone(vp); |
} |
|
break; |
break; |
case Pipsecsp: |
case KFSipsecsp: |
sp = key_getspbyid(kfs->kfs_value); |
sp = key_getspbyid(kfs->kfs_value); |
if (sp) |
if (sp) |
key_freesp(sp); |
key_freesp(sp); |
Line 1123 kernfs_pathconf(v) |
|
Line 1519 kernfs_pathconf(v) |
|
*/ |
*/ |
/* ARGSUSED */ |
/* ARGSUSED */ |
int |
int |
kernfs_print(v) |
kernfs_print(void *v __unused) |
void *v; |
|
{ |
{ |
|
|
printf("tag VT_KERNFS, kernfs vnode\n"); |
printf("tag VT_KERNFS, kernfs vnode\n"); |
Line 1132 kernfs_print(v) |
|
Line 1527 kernfs_print(v) |
|
} |
} |
|
|
int |
int |
kernfs_link(v) |
kernfs_link(v) |
void *v; |
void *v; |
{ |
{ |
struct vop_link_args /* { |
struct vop_link_args /* { |
struct vnode *a_dvp; |
struct vnode *a_dvp; |
struct vnode *a_vp; |
struct vnode *a_vp; |
struct componentname *a_cnp; |
struct componentname *a_cnp; |
} */ *ap = v; |
} */ *ap = v; |
|
|
VOP_ABORTOP(ap->a_dvp, ap->a_cnp); |
VOP_ABORTOP(ap->a_dvp, ap->a_cnp); |
vput(ap->a_dvp); |
vput(ap->a_dvp); |
return (EROFS); |
return (EROFS); |
Line 1157 kernfs_symlink(v) |
|
Line 1552 kernfs_symlink(v) |
|
struct vattr *a_vap; |
struct vattr *a_vap; |
char *a_target; |
char *a_target; |
} */ *ap = v; |
} */ *ap = v; |
|
|
VOP_ABORTOP(ap->a_dvp, ap->a_cnp); |
VOP_ABORTOP(ap->a_dvp, ap->a_cnp); |
vput(ap->a_dvp); |
vput(ap->a_dvp); |
return (EROFS); |
return (EROFS); |