version 1.87, 2003/06/29 18:43:33 |
version 1.94, 2003/09/10 03:56:33 |
|
|
* 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. |
* |
* |
|
|
#include <sys/cdefs.h> |
#include <sys/cdefs.h> |
__KERNEL_RCSID(0, "$NetBSD$"); |
__KERNEL_RCSID(0, "$NetBSD$"); |
|
|
|
#ifdef _KERNEL_OPT |
|
#include "opt_ipsec.h" |
|
#endif |
|
|
#include <sys/param.h> |
#include <sys/param.h> |
#include <sys/systm.h> |
#include <sys/systm.h> |
#include <sys/kernel.h> |
#include <sys/kernel.h> |
Line 64 __KERNEL_RCSID(0, "$NetBSD$"); |
|
Line 64 __KERNEL_RCSID(0, "$NetBSD$"); |
|
#include <miscfs/genfs/genfs.h> |
#include <miscfs/genfs/genfs.h> |
#include <miscfs/kernfs/kernfs.h> |
#include <miscfs/kernfs/kernfs.h> |
|
|
|
#ifdef IPSEC |
|
#include <sys/mbuf.h> |
|
#include <net/route.h> |
|
#include <netinet/in.h> |
|
#include <netinet6/ipsec.h> |
|
#include <netkey/key.h> |
|
#endif |
|
|
#include <uvm/uvm_extern.h> |
#include <uvm/uvm_extern.h> |
|
|
#define KSTRING 256 /* Largest I/O available via this filesystem */ |
#define KSTRING 256 /* Largest I/O available via this filesystem */ |
Line 72 __KERNEL_RCSID(0, "$NetBSD$"); |
|
Line 80 __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 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 |
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 */ |
#define N(s) sizeof(s)-1, s |
|
/* name data tag type ro/rw */ |
/* name data tag type ro/rw */ |
{ DT_DIR, N("."), 0, KTT_NULL, VDIR, DIR_MODE }, |
{ DT_DIR, N("."), 0, Pkern, VDIR, DIR_MODE }, |
{ DT_DIR, N(".."), 0, KTT_NULL, VDIR, DIR_MODE }, |
{ DT_DIR, N(".."), 0, Proot, VDIR, DIR_MODE }, |
{ DT_REG, N("boottime"), &boottime.tv_sec, KTT_INT, VREG, READ_MODE }, |
{ DT_REG, N("boottime"), &boottime.tv_sec, Pint, VREG, READ_MODE }, |
/* XXX cast away const */ |
/* XXX cast away const */ |
{ DT_REG, N("copyright"), (void *)copyright, |
{ DT_REG, N("copyright"), (void *)copyright, |
KTT_STRING, VREG, READ_MODE }, |
Pstring, VREG, READ_MODE }, |
{ DT_REG, N("hostname"), 0, KTT_HOSTNAME, VREG, WRITE_MODE }, |
{ DT_REG, N("hostname"), 0, Phostname, VREG, WRITE_MODE }, |
{ DT_REG, N("hz"), &hz, KTT_INT, VREG, READ_MODE }, |
{ DT_REG, N("hz"), &hz, Pint, VREG, READ_MODE }, |
{ DT_REG, N("loadavg"), 0, KTT_AVENRUN, VREG, READ_MODE }, |
#ifdef IPSEC |
{ DT_REG, N("msgbuf"), 0, KTT_MSGBUF, VREG, READ_MODE }, |
{ DT_DIR, N("ipsecsa"), 0, Pipsecsadir, VDIR, UDIR_MODE }, |
{ DT_REG, N("pagesize"), &uvmexp.pagesize, KTT_INT, VREG, READ_MODE }, |
{ DT_DIR, N("ipsecsp"), 0, Pipsecspdir, VDIR, UDIR_MODE }, |
{ DT_REG, N("physmem"), &physmem, KTT_INT, VREG, READ_MODE }, |
#endif |
|
{ DT_REG, N("loadavg"), 0, Pavenrun, VREG, READ_MODE }, |
|
{ DT_REG, N("msgbuf"), 0, Pmsgbuf, VREG, READ_MODE }, |
|
{ DT_REG, N("pagesize"), &uvmexp.pagesize, Pint, VREG, READ_MODE }, |
|
{ DT_REG, N("physmem"), &physmem, Pint, VREG, READ_MODE }, |
#if 0 |
#if 0 |
{ DT_DIR, N("root"), 0, KTT_NULL, VDIR, DIR_MODE }, |
{ DT_DIR, N("root"), 0, Pnull, VDIR, DIR_MODE }, |
#endif |
#endif |
{ DT_BLK, N("rootdev"), &rootdev, KTT_DEVICE, VBLK, READ_MODE }, |
{ DT_BLK, N("rootdev"), &rootdev, Pdevice, VBLK, READ_MODE }, |
{ DT_CHR, N("rrootdev"), &rrootdev, KTT_DEVICE, VCHR, READ_MODE }, |
{ DT_CHR, N("rrootdev"), &rrootdev, Pdevice, VCHR, READ_MODE }, |
{ DT_REG, N("time"), 0, KTT_TIME, VREG, READ_MODE }, |
{ DT_REG, N("time"), 0, Ptime, VREG, READ_MODE }, |
/* XXX cast away const */ |
/* XXX cast away const */ |
{ DT_REG, N("version"), (void *)version, |
{ DT_REG, N("version"), (void *)version, |
KTT_STRING, VREG, READ_MODE }, |
Pstring, VREG, READ_MODE }, |
#undef N |
}; |
|
#ifdef IPSEC |
|
const struct kern_target ipsecsa_targets[] = { |
|
/* NOTE: The name must be less than UIO_MX-16 chars in length */ |
|
/* name data tag type ro/rw */ |
|
{ DT_DIR, N("."), 0, Pipsecsadir, VDIR, DIR_MODE }, |
|
{ DT_DIR, N(".."), 0, Pkern, VDIR, DIR_MODE }, |
|
}; |
|
const struct kern_target ipsecsp_targets[] = { |
|
/* NOTE: The name must be less than UIO_MX-16 chars in length */ |
|
/* name data tag type ro/rw */ |
|
{ DT_DIR, N("."), 0, Pipsecspdir, VDIR, DIR_MODE }, |
|
{ DT_DIR, N(".."), 0, Pkern, VDIR, DIR_MODE }, |
}; |
}; |
static int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); |
#endif |
|
#undef N |
|
int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); |
|
#ifdef IPSEC |
|
int nipsecsa_targets = sizeof(ipsecsa_targets) / sizeof(ipsecsa_targets[0]); |
|
int nipsecsp_targets = sizeof(ipsecsp_targets) / sizeof(ipsecsp_targets[0]); |
|
#endif |
|
|
|
|
int kernfs_lookup __P((void *)); |
int kernfs_lookup __P((void *)); |
#define kernfs_create genfs_eopnotsupp |
#define kernfs_create genfs_eopnotsupp |
#define kernfs_mknod genfs_eopnotsupp |
#define kernfs_mknod genfs_eopnotsupp |
#define kernfs_open genfs_nullop |
int kernfs_open __P((void *)); |
#define kernfs_close genfs_nullop |
int kernfs_close __P((void *)); |
int kernfs_access __P((void *)); |
int kernfs_access __P((void *)); |
int kernfs_getattr __P((void *)); |
int kernfs_getattr __P((void *)); |
int kernfs_setattr __P((void *)); |
int kernfs_setattr __P((void *)); |
Line 145 int kernfs_pathconf __P((void *)); |
|
Line 177 int kernfs_pathconf __P((void *)); |
|
#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((const struct kern_target *, int, char **, size_t, size_t *)); |
static int kernfs_xread __P((struct kernfs_node *, int, char **, size_t, size_t *)); |
static int kernfs_xwrite __P((const struct kern_target *, char *, size_t)); |
static int kernfs_xwrite __P((const struct kernfs_node *, char *, size_t)); |
|
|
int (**kernfs_vnodeop_p) __P((void *)); |
int (**kernfs_vnodeop_p) __P((void *)); |
const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { |
const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { |
Line 199 const struct vnodeopv_desc kernfs_vnodeo |
|
Line 231 const struct vnodeopv_desc kernfs_vnodeo |
|
{ &kernfs_vnodeop_p, kernfs_vnodeop_entries }; |
{ &kernfs_vnodeop_p, kernfs_vnodeop_entries }; |
|
|
static int |
static int |
kernfs_xread(kt, off, bufp, len, wrlen) |
kernfs_xread(kfs, off, bufp, len, wrlen) |
const struct kern_target *kt; |
struct kernfs_node *kfs; |
int off; |
int off; |
char **bufp; |
char **bufp; |
size_t len; |
size_t len; |
size_t *wrlen; |
size_t *wrlen; |
{ |
{ |
|
const struct kern_target *kt; |
|
#ifdef IPSEC |
|
struct mbuf *m; |
|
#endif |
|
|
switch (kt->kt_tag) { |
kt = kfs->kfs_kt; |
case KTT_TIME: { |
|
|
switch (kfs->kfs_type) { |
|
case Ptime: { |
struct timeval tv; |
struct timeval tv; |
|
|
microtime(&tv); |
microtime(&tv); |
sprintf(*bufp, "%ld %ld\n", tv.tv_sec, tv.tv_usec); |
snprintf(*bufp, len, "%ld %ld\n", tv.tv_sec, tv.tv_usec); |
break; |
break; |
} |
} |
|
|
case KTT_INT: { |
case Pint: { |
int *ip = kt->kt_data; |
int *ip = kt->kt_data; |
|
|
sprintf(*bufp, "%d\n", *ip); |
snprintf(*bufp, len, "%d\n", *ip); |
break; |
break; |
} |
} |
|
|
case KTT_STRING: { |
case Pstring: { |
char *cp = kt->kt_data; |
char *cp = kt->kt_data; |
|
|
*bufp = cp; |
*bufp = cp; |
break; |
break; |
} |
} |
|
|
case KTT_MSGBUF: { |
case Pmsgbuf: { |
long n; |
long n; |
|
|
/* |
/* |
Line 264 kernfs_xread(kt, off, bufp, len, wrlen) |
|
Line 302 kernfs_xread(kt, off, bufp, len, wrlen) |
|
return (0); |
return (0); |
} |
} |
|
|
case KTT_HOSTNAME: { |
case Phostname: { |
char *cp = hostname; |
char *cp = hostname; |
int xlen = hostnamelen; |
int xlen = hostnamelen; |
|
|
if (xlen >= (len-2)) |
if (xlen >= (len - 2)) |
return (EINVAL); |
return (EINVAL); |
|
|
memcpy(*bufp, cp, xlen); |
memcpy(*bufp, cp, xlen); |
(*bufp)[xlen] = '\n'; |
(*bufp)[xlen] = '\n'; |
(*bufp)[xlen+1] = '\0'; |
(*bufp)[xlen+1] = '\0'; |
|
len = strlen(*bufp); |
break; |
break; |
} |
} |
|
|
case KTT_AVENRUN: |
case Pavenrun: |
averunnable.fscale = FSCALE; |
averunnable.fscale = FSCALE; |
sprintf(*bufp, "%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], |
averunnable.ldavg[2], averunnable.fscale); |
averunnable.ldavg[2], averunnable.fscale); |
break; |
break; |
|
|
|
#ifdef IPSEC |
|
case Pipsecsa: |
|
/* |
|
* Note that SA configuration could be changed during the |
|
* read operation, resulting in garbled output. |
|
*/ |
|
m = key_setdumpsa_spi(htonl(kfs->kfs_value)); |
|
if (!m) |
|
return (ENOBUFS); |
|
if (off >= m->m_pkthdr.len) { |
|
*wrlen = 0; |
|
m_freem(m); |
|
return (0); |
|
} |
|
if (len > m->m_pkthdr.len - off) |
|
len = m->m_pkthdr.len - off; |
|
m_copydata(m, off, len, *bufp); |
|
*wrlen = len; |
|
m_freem(m); |
|
return (0); |
|
|
|
case Pipsecsp: |
|
/* |
|
* Note that SP configuration could be changed during the |
|
* read operation, resulting in garbled output. |
|
*/ |
|
if (!kfs->kfs_v) { |
|
struct secpolicy *sp; |
|
|
|
sp = key_getspbyid(kfs->kfs_value); |
|
if (sp) |
|
kfs->kfs_v = sp; |
|
else |
|
return (ENOENT); |
|
} |
|
m = key_setdumpsp((struct secpolicy *)kfs->kfs_v, |
|
SADB_X_SPDGET, 0, 0); |
|
if (!m) |
|
return (ENOBUFS); |
|
if (off >= m->m_pkthdr.len) { |
|
*wrlen = 0; |
|
m_freem(m); |
|
return (0); |
|
} |
|
if (len > m->m_pkthdr.len - off) |
|
len = m->m_pkthdr.len - off; |
|
m_copydata(m, off, len, *bufp); |
|
*wrlen = len; |
|
m_freem(m); |
|
return (0); |
|
#endif |
|
|
default: |
default: |
*wrlen = 0; |
*wrlen = 0; |
return (0); |
return (0); |
Line 300 kernfs_xread(kt, off, bufp, len, wrlen) |
|
Line 391 kernfs_xread(kt, off, bufp, len, wrlen) |
|
} |
} |
|
|
static int |
static int |
kernfs_xwrite(kt, buf, len) |
kernfs_xwrite(kfs, buf, len) |
const struct kern_target *kt; |
const struct kernfs_node *kfs; |
char *buf; |
char *buf; |
size_t len; |
size_t len; |
{ |
{ |
|
|
switch (kt->kt_tag) { |
switch (kfs->kfs_type) { |
case KTT_HOSTNAME: |
case Phostname: |
if (buf[len-1] == '\n') |
if (buf[len-1] == '\n') |
--len; |
--len; |
memcpy(hostname, buf, len); |
memcpy(hostname, buf, len); |
Line 338 kernfs_lookup(v) |
|
Line 429 kernfs_lookup(v) |
|
struct vnode **vpp = ap->a_vpp; |
struct vnode **vpp = ap->a_vpp; |
struct vnode *dvp = ap->a_dvp; |
struct vnode *dvp = ap->a_dvp; |
const char *pname = cnp->cn_nameptr; |
const char *pname = cnp->cn_nameptr; |
|
const struct kernfs_node *kfs; |
const struct kern_target *kt; |
const struct kern_target *kt; |
struct vnode *fvp; |
|
int error, i, wantpunlock; |
int error, i, wantpunlock; |
|
#ifdef IPSEC |
#ifdef KERNFS_DIAGNOSTIC |
char *ep; |
printf("kernfs_lookup(%p)\n", ap); |
u_int32_t id; |
printf("kernfs_lookup(dp = %p, vpp = %p, cnp = %p)\n", dvp, vpp, ap->a_cnp); |
|
printf("kernfs_lookup(%s)\n", pname); |
|
#endif |
#endif |
|
|
*vpp = NULLVP; |
*vpp = NULLVP; |
Line 360 kernfs_lookup(v) |
|
Line 449 kernfs_lookup(v) |
|
return (0); |
return (0); |
} |
} |
|
|
/* |
wantpunlock = (~cnp->cn_flags & (LOCKPARENT | ISLASTCN)); |
* This code only supports a flat directory, so we don't |
kfs = VTOKERN(dvp); |
* need to worry about .. |
switch (kfs->kfs_type) { |
*/ |
case Pkern: |
|
/* |
|
* Shouldn't get here with .. in the root node. |
|
*/ |
|
if (cnp->cn_flags & ISDOTDOT) |
|
return (EIO); |
|
|
#if 0 |
for (i = 0; i < nkern_targets; i++) { |
if (cnp->cn_namelen == 4 && memcmp(pname, "root", 4) == 0) { |
kt = &kern_targets[i]; |
*vpp = rootdir; |
if (cnp->cn_namelen == kt->kt_namlen && |
VREF(rootdir); |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
vn_lock(rootdir, LK_SHARED | LK_RETRY); |
goto found; |
return (0); |
} |
} |
break; |
#endif |
|
|
|
wantpunlock = (~cnp->cn_flags & (LOCKPARENT | ISLASTCN)); |
found: |
|
error = kernfs_allocvp(dvp->v_mount, vpp, kt->kt_tag, kt, 0); |
|
if ((error == 0) && wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
|
return (error); |
|
|
for (kt = kern_targets, i = 0; i < nkern_targets; kt++, i++) { |
#ifdef IPSEC |
if (cnp->cn_namelen == kt->kt_namlen && |
case Pipsecsadir: |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) |
for (i = 0; i < nipsecsa_targets; i++) { |
goto found; |
kt = &ipsecsa_targets[i]; |
} |
if (cnp->cn_namelen == kt->kt_namlen && |
|
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) { |
|
error = kernfs_allocvp(dvp->v_mount, vpp, |
|
kt->kt_tag, kt, 0); |
|
if ((error == 0) && wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
|
return (error); |
|
} |
|
} |
|
|
#ifdef KERNFS_DIAGNOSTIC |
ep = NULL; |
printf("kernfs_lookup: i = %d, failed", i); |
id = strtoul(pname, &ep, 10); |
#endif |
if (!ep || *ep || ep == pname) |
|
break; |
|
|
return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); |
error = kernfs_allocvp(dvp->v_mount, vpp, Pipsecsa, NULL, id); |
|
if ((error == 0) && wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
|
return (error); |
|
|
found: |
case Pipsecspdir: |
if (kt->kt_tag == KTT_DEVICE) { |
for (i = 0; i < nipsecsp_targets; i++) { |
dev_t *dp = kt->kt_data; |
kt = &ipsecsp_targets[i]; |
loop: |
if (cnp->cn_namelen == kt->kt_namlen && |
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) { |
memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) { |
return (ENOENT); |
error = kernfs_allocvp(dvp->v_mount, vpp, |
|
kt->kt_tag, kt, 0); |
|
if ((error == 0) && wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
|
return (error); |
|
} |
} |
} |
*vpp = fvp; |
|
if (vget(fvp, LK_EXCLUSIVE)) |
ep = NULL; |
goto loop; |
id = strtoul(pname, &ep, 10); |
if (wantpunlock) { |
if (!ep || *ep || ep == pname) |
|
break; |
|
|
|
error = kernfs_allocvp(dvp->v_mount, vpp, Pipsecsp, NULL, id); |
|
if ((error == 0) && wantpunlock) { |
VOP_UNLOCK(dvp, 0); |
VOP_UNLOCK(dvp, 0); |
cnp->cn_flags |= PDIRUNLOCK; |
cnp->cn_flags |= PDIRUNLOCK; |
} |
} |
return (0); |
return (error); |
|
#endif |
|
|
|
default: |
|
return (ENOTDIR); |
} |
} |
|
|
#ifdef KERNFS_DIAGNOSTIC |
return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); |
printf("kernfs_lookup: allocate new vnode\n"); |
} |
|
|
|
int |
|
kernfs_open(v) |
|
void *v; |
|
{ |
|
struct vop_open_args /* { |
|
struct vnode *a_vp; |
|
int a_mode; |
|
struct ucred *a_cred; |
|
struct proc *a_p; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
#ifdef IPSEC |
|
struct mbuf *m; |
|
struct secpolicy *sp; |
#endif |
#endif |
error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, &fvp); |
|
if (error) { |
switch (kfs->kfs_type) { |
return (error); |
#ifdef IPSEC |
|
case Pipsecsa: |
|
m = key_setdumpsa_spi(htonl(kfs->kfs_value)); |
|
if (m) { |
|
m_freem(m); |
|
return (0); |
|
} else |
|
return (ENOENT); |
|
|
|
case Pipsecsp: |
|
sp = key_getspbyid(kfs->kfs_value); |
|
if (sp) { |
|
kfs->kfs_v = sp; |
|
return (0); |
|
} else |
|
return (ENOENT); |
|
#endif |
|
|
|
default: |
|
return (0); |
} |
} |
|
} |
|
|
|
int |
|
kernfs_close(v) |
|
void *v; |
|
{ |
|
struct vop_close_args /* { |
|
struct vnode *a_vp; |
|
int a_fflag; |
|
struct ucred *a_cred; |
|
struct proc *a_p; |
|
} */ *ap = v; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
|
switch (kfs->kfs_type) { |
|
#ifdef IPSEC |
|
case Pipsecsp: |
|
key_freesp((struct secpolicy *)kfs->kfs_v); |
|
break; |
|
#endif |
|
|
MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP, |
default: |
M_WAITOK); |
break; |
VTOKERN(fvp)->kf_kt = kt; |
|
fvp->v_type = kt->kt_vtype; |
|
vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY); |
|
*vpp = fvp; |
|
|
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kernfs_lookup: newvp = %p\n", fvp); |
|
#endif |
|
if (wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
} |
|
|
return (0); |
return (0); |
} |
} |
|
|
Line 440 kernfs_access(v) |
|
Line 614 kernfs_access(v) |
|
struct ucred *a_cred; |
struct ucred *a_cred; |
struct proc *a_p; |
struct proc *a_p; |
} */ *ap = v; |
} */ *ap = v; |
struct vnode *vp = ap->a_vp; |
struct vattr va; |
mode_t mode; |
int error; |
|
|
if (vp->v_flag & VROOT) { |
if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_p)) != 0) |
mode = DIR_MODE; |
return (error); |
} else { |
|
const struct kern_target *kt = VTOKERN(vp)->kf_kt; |
|
mode = kt->kt_mode; |
|
} |
|
|
|
return (vaccess(vp->v_type, mode, (uid_t)0, (gid_t)0, ap->a_mode, |
return (vaccess(va.va_type, va.va_mode, va.va_uid, va.va_gid, |
ap->a_cred)); |
ap->a_mode, ap->a_cred)); |
} |
} |
|
|
int |
int |
Line 464 kernfs_getattr(v) |
|
Line 634 kernfs_getattr(v) |
|
struct ucred *a_cred; |
struct ucred *a_cred; |
struct proc *a_p; |
struct proc *a_p; |
} */ *ap = v; |
} */ *ap = v; |
struct vnode *vp = ap->a_vp; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
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], *buf; |
|
size_t nread, total; |
|
|
memset((caddr_t) vap, 0, sizeof(*vap)); |
VATTR_NULL(vap); |
vattr_null(vap); |
vap->va_type = ap->a_vp->v_type; |
vap->va_uid = 0; |
vap->va_uid = 0; |
vap->va_gid = 0; |
vap->va_gid = 0; |
vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; |
vap->va_mode = kfs->kfs_mode; |
|
vap->va_fileid = kfs->kfs_fileno; |
|
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. Avoid microtime(9), it's slow. |
* Make all times be current TOD, except for the "boottime" node. |
|
* Avoid microtime(9), it's slow. |
* We don't guard the read from time(9) with splclock(9) since we |
* We don't guard the read from time(9) with splclock(9) since we |
* don't actually need to be THAT sure the access is atomic. |
* don't actually need to be THAT sure the access is atomic. |
*/ |
*/ |
TIMEVAL_TO_TIMESPEC(&time, &vap->va_ctime); |
if (kfs->kfs_kt->kt_namlen == 8 && |
|
!memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) { |
|
TIMEVAL_TO_TIMESPEC(&boottime, &vap->va_ctime); |
|
} else { |
|
TIMEVAL_TO_TIMESPEC(&time, &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; |
vap->va_rdev = 0; |
vap->va_rdev = 0; |
vap->va_bytes = 0; |
vap->va_bytes = 0; |
|
|
if (vp->v_flag & VROOT) { |
switch (kfs->kfs_type) { |
#ifdef KERNFS_DIAGNOSTIC |
case Pkern: |
printf("kernfs_getattr: stat rootdir\n"); |
vap->va_nlink = 4; |
#endif |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
vap->va_type = VDIR; |
break; |
vap->va_mode = DIR_MODE; |
|
vap->va_nlink = 2; |
case Proot: |
vap->va_fileid = 2; |
vap->va_nlink = 1; |
vap->va_size = DEV_BSIZE; |
vap->va_bytes = vap->va_size = DEV_BSIZE; |
} else { |
break; |
const struct kern_target *kt = VTOKERN(vp)->kf_kt; |
|
size_t nread, total; |
case Pnull: |
#ifdef KERNFS_DIAGNOSTIC |
case Ptime: |
printf("kernfs_getattr: stat target %s\n", kt->kt_name); |
case Pint: |
|
case Pstring: |
|
case Phostname: |
|
case Pavenrun: |
|
case Pdevice: |
|
case Pmsgbuf: |
|
#ifdef IPSEC |
|
case Pipsecsa: |
|
case Pipsecsp: |
#endif |
#endif |
vap->va_type = kt->kt_vtype; |
|
vap->va_mode = kt->kt_mode; |
|
vap->va_nlink = 1; |
vap->va_nlink = 1; |
vap->va_fileid = 1 + (kt - kern_targets); |
|
total = 0; |
total = 0; |
do { |
do { |
buf = strbuf; |
buf = strbuf; |
error = kernfs_xread(kt, total, &buf, |
error = kernfs_xread(kfs, total, &buf, |
sizeof(strbuf), &nread); |
sizeof(strbuf), &nread); |
total += nread; |
total += nread; |
} while (error == 0 && nread != 0); |
} while (error == 0 && nread != 0); |
vap->va_size = total; |
vap->va_bytes = vap->va_size = total; |
} |
break; |
|
|
#ifdef KERNFS_DIAGNOSTIC |
#ifdef IPSEC |
printf("kernfs_getattr: return error %d\n", error); |
case Pipsecsadir: |
|
case Pipsecspdir: |
|
vap->va_nlink = 2; |
|
vap->va_bytes = vap->va_size = DEV_BSIZE; |
|
break; |
#endif |
#endif |
|
|
|
default: |
|
error = EINVAL; |
|
break; |
|
} |
|
|
return (error); |
return (error); |
} |
} |
|
|
|
|
kernfs_setattr(v) |
kernfs_setattr(v) |
void *v; |
void *v; |
{ |
{ |
|
|
/* |
/* |
* Silently ignore attribute changes. |
* Silently ignore attribute changes. |
* This allows for open with truncate to have no |
* This allows for open with truncate to have no |
|
|
int a_ioflag; |
int a_ioflag; |
struct ucred *a_cred; |
struct ucred *a_cred; |
} */ *ap = v; |
} */ *ap = v; |
struct vnode *vp = ap->a_vp; |
|
struct uio *uio = ap->a_uio; |
struct uio *uio = ap->a_uio; |
const struct kern_target *kt; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
char strbuf[KSTRING], *buf; |
char strbuf[KSTRING], *buf; |
off_t off; |
off_t off; |
size_t len; |
size_t len; |
int error; |
int error; |
|
|
if (vp->v_type == VDIR) |
if (ap->a_vp->v_type == VDIR) |
return (EOPNOTSUPP); |
return (EOPNOTSUPP); |
|
|
kt = VTOKERN(vp)->kf_kt; |
|
|
|
#ifdef KERNFS_DIAGNOSTIC |
|
printf("kern_read %s\n", kt->kt_name); |
|
#endif |
|
|
|
off = uio->uio_offset; |
off = uio->uio_offset; |
buf = strbuf; |
buf = strbuf; |
if ((error = kernfs_xread(kt, off, &buf, sizeof(strbuf), &len)) == 0) |
if ((error = kernfs_xread(kfs, off, &buf, sizeof(strbuf), &len)) == 0) |
error = uiomove(buf, len, uio); |
error = uiomove(buf, len, uio); |
return (error); |
return (error); |
} |
} |
|
|
int a_ioflag; |
int a_ioflag; |
struct ucred *a_cred; |
struct ucred *a_cred; |
} */ *ap = v; |
} */ *ap = v; |
struct vnode *vp = ap->a_vp; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
struct uio *uio = ap->a_uio; |
struct uio *uio = ap->a_uio; |
const struct kern_target *kt; |
|
int error, xlen; |
int error, xlen; |
char strbuf[KSTRING]; |
char strbuf[KSTRING]; |
|
|
if (vp->v_type == VDIR) |
|
return (EOPNOTSUPP); |
|
|
|
kt = VTOKERN(vp)->kf_kt; |
|
|
|
if (uio->uio_offset != 0) |
if (uio->uio_offset != 0) |
return (EINVAL); |
return (EINVAL); |
|
|
|
|
|
|
strbuf[xlen] = '\0'; |
strbuf[xlen] = '\0'; |
xlen = strlen(strbuf); |
xlen = strlen(strbuf); |
return (kernfs_xwrite(kt, strbuf, xlen)); |
return (kernfs_xwrite(kfs, strbuf, xlen)); |
} |
} |
|
|
int |
int |
Line 621 kernfs_readdir(v) |
|
Line 803 kernfs_readdir(v) |
|
} */ *ap = v; |
} */ *ap = v; |
struct uio *uio = ap->a_uio; |
struct uio *uio = ap->a_uio; |
struct dirent d; |
struct dirent d; |
|
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
const struct kern_target *kt; |
const struct kern_target *kt; |
off_t i; |
off_t i; |
int error; |
int error; |
off_t *cookies = NULL; |
off_t *cookies = NULL; |
int ncookies = 0, nc = 0; |
int ncookies = 0, n; |
|
#ifdef IPSEC |
if (ap->a_vp->v_type != VDIR) |
struct secasvar *sav, *sav2; |
return (ENOTDIR); |
struct secpolicy *sp; |
|
#endif |
|
|
if (uio->uio_resid < UIO_MX) |
if (uio->uio_resid < UIO_MX) |
return (EINVAL); |
return (EINVAL); |
Line 637 kernfs_readdir(v) |
|
Line 821 kernfs_readdir(v) |
|
|
|
error = 0; |
error = 0; |
i = uio->uio_offset; |
i = uio->uio_offset; |
|
memset(&d, 0, sizeof(d)); |
if (i >= nkern_targets) |
|
return 0; |
|
|
|
memset((caddr_t)&d, 0, UIO_MX); |
|
d.d_reclen = UIO_MX; |
d.d_reclen = UIO_MX; |
|
ncookies = uio->uio_resid / UIO_MX; |
|
|
if (ap->a_ncookies) { |
switch (kfs->kfs_type) { |
nc = uio->uio_resid / UIO_MX; |
case Pkern: |
nc = min(nc, (nkern_targets - i)); |
if (i >= nkern_targets) |
cookies = malloc(nc * sizeof(off_t), M_TEMP, M_WAITOK); |
return (0); |
*ap->a_cookies = cookies; |
|
} |
|
|
|
for (kt = &kern_targets[i]; |
if (ap->a_ncookies) { |
uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) { |
ncookies = min(ncookies, (nkern_targets - i)); |
#ifdef KERNFS_DIAGNOSTIC |
cookies = malloc(ncookies * sizeof(off_t), M_TEMP, |
printf("kernfs_readdir: i = %d\n", (int)i); |
M_WAITOK); |
#endif |
*ap->a_cookies = cookies; |
|
} |
|
|
|
n = 0; |
|
for (; i < nkern_targets && uio->uio_resid >= UIO_MX; i++) { |
|
kt = &kern_targets[i]; |
|
if (kt->kt_tag == Pdevice) { |
|
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 (i < 2) |
|
d.d_fileno = KERNFS_FILENO(&kern_targets[0], |
|
kern_targets[0].kt_tag, 0); |
|
else |
|
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((caddr_t)&d, UIO_MX, uio)) != 0) |
|
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
|
} |
|
ncookies = n; |
|
break; |
|
|
|
case Proot: |
|
if (i >= 2) |
|
return 0; |
|
|
|
if (ap->a_ncookies) { |
|
ncookies = min(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((caddr_t)&d, UIO_MX, uio)) != 0) |
|
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
|
} |
|
ncookies = n; |
|
break; |
|
|
if (kt->kt_tag == KTT_DEVICE) { |
#ifdef IPSEC |
dev_t *dp = kt->kt_data; |
case Pipsecsadir: |
struct vnode *fvp; |
/* count SA in the system */ |
|
n = 0; |
|
TAILQ_FOREACH(sav, &satailq, tailq) { |
|
for (sav2 = TAILQ_FIRST(&satailq); |
|
sav2 != sav; |
|
sav2 = TAILQ_NEXT(sav2, tailq)) { |
|
if (sav->spi == sav2->spi) { |
|
/* multiple SA with same SPI */ |
|
break; |
|
} |
|
} |
|
if (sav == sav2 || sav->spi != sav2->spi) |
|
n++; |
|
} |
|
|
|
if (i >= nipsecsa_targets + n) |
|
return (0); |
|
|
if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) |
if (ap->a_ncookies) { |
|
ncookies = min(ncookies, (n - i)); |
|
cookies = malloc(ncookies * sizeof(off_t), M_TEMP, |
|
M_WAITOK); |
|
*ap->a_cookies = cookies; |
|
} |
|
|
|
n = 0; |
|
for (; i < nipsecsa_targets && uio->uio_resid >= UIO_MX; i++) { |
|
kt = &ipsecsa_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((caddr_t)&d, UIO_MX, uio)) != 0) |
|
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
|
} |
|
if (error) { |
|
ncookies = n; |
|
break; |
|
} |
|
|
|
TAILQ_FOREACH(sav, &satailq, tailq) { |
|
for (sav2 = TAILQ_FIRST(&satailq); |
|
sav2 != sav; |
|
sav2 = TAILQ_NEXT(sav2, tailq)) { |
|
if (sav->spi == sav2->spi) { |
|
/* multiple SA with same SPI */ |
|
break; |
|
} |
|
} |
|
if (sav != sav2 && sav->spi == sav2->spi) |
continue; |
continue; |
|
if (uio->uio_resid < UIO_MX) |
|
break; |
|
d.d_fileno = KERNFS_FILENO(kfs->kfs_kt, kfs->kfs_type, |
|
kfs->kfs_cookie); |
|
d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), |
|
"%u", ntohl(sav->spi)); |
|
d.d_type = DT_REG; |
|
if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) |
|
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
|
i++; |
} |
} |
|
ncookies = n; |
|
break; |
|
|
|
case Pipsecspdir: |
|
/* count SP in the system */ |
|
n = 0; |
|
TAILQ_FOREACH(sp, &sptailq, tailq) |
|
n++; |
|
|
|
if (i >= 2 + n) |
|
return (0); |
|
|
d.d_fileno = i + 3; |
if (ap->a_ncookies) { |
d.d_namlen = kt->kt_namlen; |
ncookies = min(ncookies, (n - i)); |
memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); |
cookies = malloc(ncookies * sizeof(off_t), M_TEMP, |
d.d_type = kt->kt_type; |
M_WAITOK); |
|
*ap->a_cookies = cookies; |
|
} |
|
|
if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) |
n = 0; |
|
for (; i < nipsecsp_targets && uio->uio_resid >= UIO_MX; i++) { |
|
kt = &ipsecsp_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((caddr_t)&d, UIO_MX, uio)) != 0) |
|
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
|
} |
|
if (error) { |
|
ncookies = n; |
break; |
break; |
if (cookies) { |
|
*cookies++ = i + 1; |
|
ncookies++; |
|
} |
} |
|
|
|
TAILQ_FOREACH(sp, &sptailq, tailq) { |
|
if (uio->uio_resid < UIO_MX) |
|
break; |
|
d.d_fileno = KERNFS_FILENO(kfs->kfs_kt, kfs->kfs_type, |
|
kfs->kfs_cookie); |
|
d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), |
|
"%u", sp->id); |
|
d.d_type = DT_REG; |
|
if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) |
|
break; |
|
if (cookies) |
|
*cookies++ = i + 1; |
|
n++; |
|
i++; |
|
} |
|
ncookies = n; |
|
break; |
|
#endif |
|
|
|
default: |
|
error = ENOTDIR; |
|
break; |
} |
} |
|
|
if (ap->a_ncookies) { |
if (ap->a_ncookies) { |
if (error) { |
if (error) { |
free(*ap->a_cookies, M_TEMP); |
if (cookies) |
|
free(*ap->a_cookies, M_TEMP); |
*ap->a_ncookies = 0; |
*ap->a_ncookies = 0; |
*ap->a_cookies = NULL; |
*ap->a_cookies = NULL; |
} else |
} else |
Line 700 kernfs_inactive(v) |
|
Line 1046 kernfs_inactive(v) |
|
struct proc *a_p; |
struct proc *a_p; |
} */ *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); |
#ifdef KERNFS_DIAGNOSTIC |
#ifdef IPSEC |
printf("kernfs_inactive(%p)\n", vp); |
struct mbuf *m; |
|
struct secpolicy *sp; |
#endif |
#endif |
/* |
|
* Clear out the v_type field to avoid |
|
* nasty things happening in vgone(). |
|
*/ |
|
VOP_UNLOCK(vp, 0); |
VOP_UNLOCK(vp, 0); |
vp->v_type = VNON; |
switch (kfs->kfs_type) { |
|
#ifdef IPSEC |
|
case Pipsecsa: |
|
m = key_setdumpsa_spi(htonl(kfs->kfs_value)); |
|
if (m) |
|
m_freem(m); |
|
else |
|
vgone(vp); |
|
break; |
|
case Pipsecsp: |
|
sp = key_getspbyid(kfs->kfs_value); |
|
if (sp) |
|
key_freesp(sp); |
|
else { |
|
/* should never happen as we hold a refcnt */ |
|
vgone(vp); |
|
} |
|
break; |
|
#endif |
|
default: |
|
break; |
|
} |
return (0); |
return (0); |
} |
} |
|
|
Line 720 kernfs_reclaim(v) |
|
Line 1085 kernfs_reclaim(v) |
|
struct vop_reclaim_args /* { |
struct vop_reclaim_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
} */ *ap = v; |
} */ *ap = v; |
struct vnode *vp = ap->a_vp; |
|
|
|
#ifdef KERNFS_DIAGNOSTIC |
return (kernfs_freevp(ap->a_vp)); |
printf("kernfs_reclaim(%p)\n", vp); |
|
#endif |
|
if (vp->v_data) { |
|
FREE(vp->v_data, M_TEMP); |
|
vp->v_data = 0; |
|
} |
|
return (0); |
|
} |
} |
|
|
/* |
/* |