version 1.124, 2006/06/23 20:30:11 |
version 1.137, 2009/06/23 19:36:40 |
Line 166 const struct kernfs_fileop kernfs_defaul |
|
Line 166 const struct kernfs_fileop kernfs_defaul |
|
{ .kf_fileop = KERNFS_XWRITE }, |
{ .kf_fileop = KERNFS_XWRITE }, |
{ .kf_fileop = KERNFS_FILEOP_OPEN }, |
{ .kf_fileop = KERNFS_FILEOP_OPEN }, |
{ .kf_fileop = KERNFS_FILEOP_GETATTR, |
{ .kf_fileop = KERNFS_FILEOP_GETATTR, |
.kf_genop = {kernfs_default_fileop_getattr} }, |
.kf_vop = kernfs_default_fileop_getattr }, |
{ .kf_fileop = KERNFS_FILEOP_IOCTL }, |
{ .kf_fileop = KERNFS_FILEOP_IOCTL }, |
{ .kf_fileop = KERNFS_FILEOP_CLOSE }, |
{ .kf_fileop = KERNFS_FILEOP_CLOSE }, |
{ .kf_fileop = KERNFS_FILEOP_READ, .kf_genop = {kernfs_default_xread} }, |
{ .kf_fileop = KERNFS_FILEOP_READ, |
{ .kf_fileop = KERNFS_FILEOP_WRITE, .kf_genop = {kernfs_default_xwrite} }, |
.kf_vop = kernfs_default_xread }, |
|
{ .kf_fileop = KERNFS_FILEOP_WRITE, |
|
.kf_vop = kernfs_default_xwrite }, |
}; |
}; |
|
|
int kernfs_lookup(void *); |
int kernfs_lookup(void *); |
Line 301 kernfs_alloctype(int nkf, const struct k |
|
Line 303 kernfs_alloctype(int nkf, const struct k |
|
skf.kf_type = nextfreetype; |
skf.kf_type = nextfreetype; |
skf.kf_fileop = kf[i].kf_fileop; |
skf.kf_fileop = kf[i].kf_fileop; |
if ((fkf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) |
if ((fkf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) |
fkf->kf_genop = kf[i].kf_genop; |
fkf->kf_vop = kf[i].kf_vop; |
} |
} |
|
|
return nextfreetype++; |
return nextfreetype++; |
Line 378 kernfs_addentry(kernfs_parentdir_t *pkt, |
|
Line 380 kernfs_addentry(kernfs_parentdir_t *pkt, |
|
} |
} |
|
|
static int |
static int |
kernfs_xread(kfs, off, bufp, len, wrlen) |
kernfs_xread(struct kernfs_node *kfs, int off, char **bufp, size_t len, size_t *wrlen) |
struct kernfs_node *kfs; |
|
int off; |
|
char **bufp; |
|
size_t len; |
|
size_t *wrlen; |
|
{ |
{ |
const struct kern_target *kt; |
const struct kern_target *kt; |
#ifdef IPSEC |
#ifdef IPSEC |
Line 398 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 395 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
struct timeval tv; |
struct timeval tv; |
|
|
microtime(&tv); |
microtime(&tv); |
snprintf(*bufp, len, "%ld %ld\n", tv.tv_sec, tv.tv_usec); |
snprintf(*bufp, len, "%lld %ld\n", (long long)tv.tv_sec, |
|
(long)tv.tv_usec); |
break; |
break; |
} |
} |
|
|
Line 452 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 450 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
|
|
case KFShostname: { |
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 473 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 471 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
|
|
#ifdef IPSEC |
#ifdef IPSEC |
case KFSipsecsa: |
case KFSipsecsa: |
|
if (key_setdumpsa_spi == NULL) |
|
return 0; |
/* |
/* |
* 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 497 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 497 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
* 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. |
*/ |
*/ |
|
if (key_getspbyid == NULL) |
|
return 0; |
if (!kfs->kfs_v) { |
if (!kfs->kfs_v) { |
struct secpolicy *sp; |
struct secpolicy *sp; |
|
|
Line 541 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
Line 543 kernfs_xread(kfs, off, bufp, len, wrlen) |
|
} |
} |
|
|
static int |
static int |
kernfs_xwrite(kfs, bf, len) |
kernfs_xwrite(const struct kernfs_node *kfs, char *bf, size_t len) |
const struct kernfs_node *kfs; |
|
char *bf; |
|
size_t len; |
|
{ |
{ |
|
|
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
Line 567 kernfs_xwrite(kfs, bf, len) |
|
Line 566 kernfs_xwrite(kfs, bf, len) |
|
* ndp is the name to locate in that directory... |
* ndp is the name to locate in that directory... |
*/ |
*/ |
int |
int |
kernfs_lookup(v) |
kernfs_lookup(void *v) |
void *v; |
|
{ |
{ |
struct vop_lookup_args /* { |
struct vop_lookup_args /* { |
struct vnode * a_dvp; |
struct vnode * a_dvp; |
Line 583 kernfs_lookup(v) |
|
Line 581 kernfs_lookup(v) |
|
const struct kern_target *kt; |
const struct kern_target *kt; |
const struct dyn_kern_target *dkt; |
const struct dyn_kern_target *dkt; |
const struct kernfs_subdir *ks; |
const struct kernfs_subdir *ks; |
int error, i, wantpunlock; |
int error, i; |
#ifdef IPSEC |
#ifdef IPSEC |
char *ep; |
char *ep; |
u_int32_t id; |
u_int32_t id; |
#endif |
#endif |
|
|
*vpp = NULLVP; |
*vpp = NULLVP; |
cnp->cn_flags &= ~PDIRUNLOCK; |
|
|
|
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) |
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) |
return (EROFS); |
return (EROFS); |
Line 601 kernfs_lookup(v) |
|
Line 598 kernfs_lookup(v) |
|
return (0); |
return (0); |
} |
} |
|
|
wantpunlock = (~cnp->cn_flags & (LOCKPARENT | ISLASTCN)); |
|
kfs = VTOKERN(dvp); |
kfs = VTOKERN(dvp); |
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
case KFSkern: |
case KFSkern: |
Line 628 kernfs_lookup(v) |
|
Line 624 kernfs_lookup(v) |
|
|
|
found: |
found: |
error = kernfs_allocvp(dvp->v_mount, vpp, kt->kt_tag, kt, 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); |
return (error); |
|
|
case KFSsubdir: |
case KFSsubdir: |
Line 670 kernfs_lookup(v) |
|
Line 662 kernfs_lookup(v) |
|
break; |
break; |
|
|
error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsa, &ipsecsa_kt, id); |
error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsa, &ipsecsa_kt, id); |
if ((error == 0) && wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
|
return (error); |
return (error); |
|
|
case KFSipsecspdir: |
case KFSipsecspdir: |
Line 695 kernfs_lookup(v) |
|
Line 683 kernfs_lookup(v) |
|
break; |
break; |
|
|
error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsp, &ipsecsp_kt, id); |
error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsp, &ipsecsp_kt, id); |
if ((error == 0) && wantpunlock) { |
|
VOP_UNLOCK(dvp, 0); |
|
cnp->cn_flags |= PDIRUNLOCK; |
|
} |
|
return (error); |
return (error); |
#endif |
#endif |
|
|
Line 710 kernfs_lookup(v) |
|
Line 694 kernfs_lookup(v) |
|
} |
} |
|
|
int |
int |
kernfs_open(v) |
kernfs_open(void *v) |
void *v; |
|
{ |
{ |
struct vop_open_args /* { |
struct vop_open_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
int a_mode; |
int a_mode; |
kauth_cred_t a_cred; |
kauth_cred_t a_cred; |
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 KFSipsecsa: |
case KFSipsecsa: |
|
if (key_setdumpsa_spi == NULL) |
|
return 0; |
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); |
|
|
return (ENOENT); |
return (ENOENT); |
|
|
case KFSipsecsp: |
case KFSipsecsp: |
|
if (key_getspbyid == NULL) |
|
return 0; |
sp = key_getspbyid(kfs->kfs_value); |
sp = key_getspbyid(kfs->kfs_value); |
if (sp) { |
if (sp) { |
kfs->kfs_v = sp; |
kfs->kfs_v = sp; |
|
|
} |
} |
|
|
int |
int |
kernfs_close(v) |
kernfs_close(void *v) |
void *v; |
|
{ |
{ |
struct vop_close_args /* { |
struct vop_close_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
int a_fflag; |
int a_fflag; |
kauth_cred_t a_cred; |
kauth_cred_t a_cred; |
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 KFSipsecsp: |
case KFSipsecsp: |
|
if (key_freesp == NULL) |
|
return 0; |
key_freesp((struct secpolicy *)kfs->kfs_v); |
key_freesp((struct secpolicy *)kfs->kfs_v); |
break; |
break; |
#endif |
#endif |
|
|
} |
} |
|
|
int |
int |
kernfs_access(v) |
kernfs_access(void *v) |
void *v; |
|
{ |
{ |
struct vop_access_args /* { |
struct vop_access_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
int a_mode; |
int a_mode; |
kauth_cred_t a_cred; |
kauth_cred_t a_cred; |
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_l)) != 0) |
if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0) |
return (error); |
return (error); |
|
|
return (vaccess(va.va_type, va.va_mode, va.va_uid, va.va_gid, |
return (genfs_can_access(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 |
static int |
kernfs_default_fileop_getattr(v) |
kernfs_default_fileop_getattr(void *v) |
void *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; |
kauth_cred_t a_cred; |
kauth_cred_t a_cred; |
struct lwp *a_l; |
|
} */ *ap = v; |
} */ *ap = v; |
struct vattr *vap = ap->a_vap; |
struct vattr *vap = ap->a_vap; |
|
|
Line 816 kernfs_default_fileop_getattr(v) |
|
Line 798 kernfs_default_fileop_getattr(v) |
|
} |
} |
|
|
int |
int |
kernfs_getattr(v) |
kernfs_getattr(void *v) |
void *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; |
kauth_cred_t a_cred; |
kauth_cred_t a_cred; |
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 kernfs_subdir *ks; |
Line 842 kernfs_getattr(v) |
|
Line 822 kernfs_getattr(v) |
|
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, except for the "boottime" node. */ |
if (kfs->kfs_kt && kfs->kfs_kt->kt_namlen == 8 && |
if (kfs->kfs_kt->kt_namlen == 8 && |
!memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) { |
!memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) { |
TIMEVAL_TO_TIMESPEC(&boottime, &vap->va_ctime); |
vap->va_ctime = boottime; |
} else { |
} else { |
getnanotime(&vap->va_ctime); |
getnanotime(&vap->va_ctime); |
} |
} |
Line 913 kernfs_getattr(v) |
|
Line 893 kernfs_getattr(v) |
|
|
|
/*ARGSUSED*/ |
/*ARGSUSED*/ |
int |
int |
kernfs_setattr(v) |
kernfs_setattr(void *v) |
void *v; |
|
{ |
{ |
|
|
/* |
/* |
Line 927 kernfs_setattr(v) |
|
Line 906 kernfs_setattr(v) |
|
} |
} |
|
|
int |
int |
kernfs_default_xread(v) |
kernfs_default_xread(void *v) |
void *v; |
|
{ |
{ |
struct vop_read_args /* { |
struct vop_read_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
Line 958 kernfs_default_xread(v) |
|
Line 936 kernfs_default_xread(v) |
|
} |
} |
|
|
int |
int |
kernfs_read(v) |
kernfs_read(void *v) |
void *v; |
|
{ |
{ |
struct vop_read_args /* { |
struct vop_read_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
|
|
} |
} |
|
|
static int |
static int |
kernfs_default_xwrite(v) |
kernfs_default_xwrite(void *v) |
void *v; |
|
{ |
{ |
struct vop_write_args /* { |
struct vop_write_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
Line 989 kernfs_default_xwrite(v) |
|
Line 965 kernfs_default_xwrite(v) |
|
} */ *ap = v; |
} */ *ap = v; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
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 1008 kernfs_default_xwrite(v) |
|
Line 985 kernfs_default_xwrite(v) |
|
} |
} |
|
|
int |
int |
kernfs_write(v) |
kernfs_write(void *v) |
void *v; |
|
{ |
{ |
struct vop_write_args /* { |
struct vop_write_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
Line 1028 kernfs_write(v) |
|
Line 1004 kernfs_write(v) |
|
} |
} |
|
|
int |
int |
kernfs_ioctl(v) |
kernfs_ioctl(void *v) |
void *v; |
|
{ |
{ |
struct vop_ioctl_args /* { |
struct vop_ioctl_args /* { |
const struct vnodeop_desc *a_desc; |
const struct vnodeop_desc *a_desc; |
Line 1038 kernfs_ioctl(v) |
|
Line 1013 kernfs_ioctl(v) |
|
void *a_data; |
void *a_data; |
int a_fflag; |
int a_fflag; |
kauth_cred_t a_cred; |
kauth_cred_t a_cred; |
struct lwp *a_l; |
|
} */ *ap = v; |
} */ *ap = v; |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
struct kernfs_node *kfs = VTOKERN(ap->a_vp); |
|
|
Line 1060 kernfs_setdirentfileno_kt(struct dirent |
|
Line 1034 kernfs_setdirentfileno_kt(struct dirent |
|
if (kt->kt_tag == KFSdevice) { |
if (kt->kt_tag == KFSdevice) { |
struct vattr va; |
struct vattr va; |
|
|
error = VOP_GETATTR(vp, &va, ap->a_cred, curlwp); |
error = VOP_GETATTR(vp, &va, ap->a_cred); |
if (error != 0) { |
if (error != 0) { |
return error; |
return error; |
} |
} |
Line 1101 kernfs_setdirentfileno(struct dirent *d, |
|
Line 1075 kernfs_setdirentfileno(struct dirent *d, |
|
} |
} |
|
|
int |
int |
kernfs_readdir(v) |
kernfs_readdir(void *v) |
void *v; |
|
{ |
{ |
struct vop_readdir_args /* { |
struct vop_readdir_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
Line 1272 kernfs_readdir(v) |
|
Line 1245 kernfs_readdir(v) |
|
case KFSipsecsadir: |
case KFSipsecsadir: |
/* count SA in the system */ |
/* count SA in the system */ |
n = 0; |
n = 0; |
|
if (&satailq == NULL) |
|
return 0; |
TAILQ_FOREACH(sav, &satailq, tailq) { |
TAILQ_FOREACH(sav, &satailq, tailq) { |
for (sav2 = TAILQ_FIRST(&satailq); |
for (sav2 = TAILQ_FIRST(&satailq); |
sav2 != sav; |
sav2 != sav; |
Line 1346 kernfs_readdir(v) |
|
Line 1321 kernfs_readdir(v) |
|
|
|
case KFSipsecspdir: |
case KFSipsecspdir: |
/* count SP in the system */ |
/* count SP in the system */ |
|
if (&sptailq == NULL) |
|
return 0; |
|
|
n = 0; |
n = 0; |
TAILQ_FOREACH(sp, &sptailq, tailq) |
TAILQ_FOREACH(sp, &sptailq, tailq) |
n++; |
n++; |
Line 1420 kernfs_readdir(v) |
|
Line 1398 kernfs_readdir(v) |
|
} |
} |
|
|
int |
int |
kernfs_inactive(v) |
kernfs_inactive(void *v) |
void *v; |
|
{ |
{ |
struct vop_inactive_args /* { |
struct vop_inactive_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
struct lwp *a_l; |
bool *a_recycle; |
} */ *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 1434 kernfs_inactive(v) |
|
Line 1411 kernfs_inactive(v) |
|
struct secpolicy *sp; |
struct secpolicy *sp; |
#endif |
#endif |
|
|
VOP_UNLOCK(vp, 0); |
*ap->a_recycle = false; |
switch (kfs->kfs_type) { |
switch (kfs->kfs_type) { |
#ifdef IPSEC |
#ifdef IPSEC |
case KFSipsecsa: |
case KFSipsecsa: |
|
if (key_setdumpsa_spi == NULL) |
|
return 0; |
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 |
vgone(vp); |
*ap->a_recycle = true; |
break; |
break; |
case KFSipsecsp: |
case KFSipsecsp: |
|
if (key_getspbyid == NULL) |
|
return 0; |
sp = key_getspbyid(kfs->kfs_value); |
sp = key_getspbyid(kfs->kfs_value); |
if (sp) |
if (sp) |
key_freesp(sp); |
key_freesp(sp); |
else { |
else { |
/* should never happen as we hold a refcnt */ |
*ap->a_recycle = true; |
vgone(vp); |
|
} |
} |
break; |
break; |
#endif |
#endif |
default: |
default: |
break; |
break; |
} |
} |
|
VOP_UNLOCK(vp, 0); |
return (0); |
return (0); |
} |
} |
|
|
int |
int |
kernfs_reclaim(v) |
kernfs_reclaim(void *v) |
void *v; |
|
{ |
{ |
struct vop_reclaim_args /* { |
struct vop_reclaim_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
Line 1475 kernfs_reclaim(v) |
|
Line 1455 kernfs_reclaim(v) |
|
* Return POSIX pathconf information applicable to special devices. |
* Return POSIX pathconf information applicable to special devices. |
*/ |
*/ |
int |
int |
kernfs_pathconf(v) |
kernfs_pathconf(void *v) |
void *v; |
|
{ |
{ |
struct vop_pathconf_args /* { |
struct vop_pathconf_args /* { |
struct vnode *a_vp; |
struct vnode *a_vp; |
Line 1517 kernfs_pathconf(v) |
|
Line 1496 kernfs_pathconf(v) |
|
*/ |
*/ |
/* ARGSUSED */ |
/* ARGSUSED */ |
int |
int |
kernfs_print(v) |
kernfs_print(void *v) |
void *v; |
|
{ |
{ |
|
|
printf("tag VT_KERNFS, kernfs vnode\n"); |
printf("tag VT_KERNFS, kernfs vnode\n"); |
Line 1526 kernfs_print(v) |
|
Line 1504 kernfs_print(v) |
|
} |
} |
|
|
int |
int |
kernfs_link(v) |
kernfs_link(void *v) |
void *v; |
|
{ |
{ |
struct vop_link_args /* { |
struct vop_link_args /* { |
struct vnode *a_dvp; |
struct vnode *a_dvp; |
|
|
} |
} |
|
|
int |
int |
kernfs_symlink(v) |
kernfs_symlink(void *v) |
void *v; |
|
{ |
{ |
struct vop_symlink_args /* { |
struct vop_symlink_args /* { |
struct vnode *a_dvp; |
struct vnode *a_dvp; |