155344Spendry /*
263233Sbostic  * Copyright (c) 1992, 1993
363233Sbostic  *	The Regents of the University of California.  All rights reserved.
455344Spendry  *
555344Spendry  * This code is derived from software donated to Berkeley by
655344Spendry  * Jan-Simon Pendry.
755344Spendry  *
855344Spendry  * %sccs.include.redist.c%
955344Spendry  *
10*69436Smckusick  *	@(#)kernfs_vnops.c	8.13 (Berkeley) 05/14/95
1155344Spendry  */
1255344Spendry 
1355344Spendry /*
1455344Spendry  * Kernel parameter filesystem (/kern)
1555344Spendry  */
1655344Spendry 
1755344Spendry #include <sys/param.h>
1855344Spendry #include <sys/systm.h>
1955344Spendry #include <sys/kernel.h>
2055344Spendry #include <sys/vmmeter.h>
2155344Spendry #include <sys/types.h>
2255344Spendry #include <sys/time.h>
2355344Spendry #include <sys/proc.h>
2455344Spendry #include <sys/vnode.h>
2555344Spendry #include <sys/malloc.h>
2655344Spendry #include <sys/file.h>
2755344Spendry #include <sys/stat.h>
2855344Spendry #include <sys/mount.h>
2955344Spendry #include <sys/namei.h>
3055344Spendry #include <sys/buf.h>
3155344Spendry #include <sys/dirent.h>
3255344Spendry #include <miscfs/kernfs/kernfs.h>
3355344Spendry 
3455344Spendry #define KSTRING	256		/* Largest I/O available via this filesystem */
3555344Spendry #define	UIO_MX 32
3655344Spendry 
3755356Spendry #define	READ_MODE	(S_IRUSR|S_IRGRP|S_IROTH)
3855356Spendry #define	WRITE_MODE	(S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH)
3955356Spendry #define DIR_MODE	(S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
4055356Spendry 
4155344Spendry struct kern_target {
4267387Spendry 	u_char kt_type;
4367387Spendry 	u_char kt_namlen;
4455344Spendry 	char *kt_name;
4555344Spendry 	void *kt_data;
4667387Spendry #define	KTT_NULL	 1
4767387Spendry #define	KTT_TIME	 5
4867387Spendry #define KTT_INT		17
4967387Spendry #define	KTT_STRING	31
5067387Spendry #define KTT_HOSTNAME	47
5167387Spendry #define KTT_AVENRUN	53
5267387Spendry #define KTT_DEVICE	71
5367387Spendry 	u_char kt_tag;
5467387Spendry 	u_char kt_vtype;
5567387Spendry 	mode_t kt_mode;
5655344Spendry } kern_targets[] = {
5755344Spendry /* NOTE: The name must be less than UIO_MX-16 chars in length */
5867387Spendry #define N(s) sizeof(s)-1, s
5967387Spendry      /*        name            data          tag           type  ro/rw */
6067387Spendry      { DT_DIR, N("."),         0,            KTT_NULL,     VDIR, DIR_MODE   },
6167387Spendry      { DT_DIR, N(".."),        0,            KTT_NULL,     VDIR, DIR_MODE   },
6267387Spendry      { DT_REG, N("boottime"),  &boottime.tv_sec, KTT_INT,  VREG, READ_MODE  },
6367387Spendry      { DT_REG, N("copyright"), copyright,    KTT_STRING,   VREG, READ_MODE  },
6467387Spendry      { DT_REG, N("hostname"),  0,            KTT_HOSTNAME, VREG, WRITE_MODE },
6567387Spendry      { DT_REG, N("hz"),        &hz,          KTT_INT,      VREG, READ_MODE  },
6667387Spendry      { DT_REG, N("loadavg"),   0,            KTT_AVENRUN,  VREG, READ_MODE  },
6767387Spendry      { DT_REG, N("pagesize"),  &cnt.v_page_size, KTT_INT,  VREG, READ_MODE  },
6867387Spendry      { DT_REG, N("physmem"),   &physmem,     KTT_INT,      VREG, READ_MODE  },
6959556Spendry #if 0
7067387Spendry      { DT_DIR, N("root"),      0,            KTT_NULL,     VDIR, DIR_MODE   },
7159556Spendry #endif
7267387Spendry      { DT_BLK, N("rootdev"),   &rootdev,     KTT_DEVICE,   VBLK, READ_MODE  },
7367387Spendry      { DT_CHR, N("rrootdev"),  &rrootdev,    KTT_DEVICE,   VCHR, READ_MODE  },
7467387Spendry      { DT_REG, N("time"),      0,            KTT_TIME,     VREG, READ_MODE  },
7567387Spendry      { DT_REG, N("version"),   version,      KTT_STRING,   VREG, READ_MODE  },
7667387Spendry #undef N
7755344Spendry };
7855344Spendry static int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);
7955344Spendry 
8055344Spendry static int
8155344Spendry kernfs_xread(kt, buf, len, lenp)
8255344Spendry 	struct kern_target *kt;
8355344Spendry 	char *buf;
8455344Spendry 	int len;
8555344Spendry 	int *lenp;
8655344Spendry {
8767387Spendry 
8855344Spendry 	switch (kt->kt_tag) {
8955344Spendry 	case KTT_TIME: {
9055344Spendry 		struct timeval tv;
9155344Spendry 		microtime(&tv);
9255344Spendry 		sprintf(buf, "%d %d\n", tv.tv_sec, tv.tv_usec);
9355344Spendry 		break;
9455344Spendry 	}
9555344Spendry 
9655344Spendry 	case KTT_INT: {
9755344Spendry 		int *ip = kt->kt_data;
9855344Spendry 		sprintf(buf, "%d\n", *ip);
9955344Spendry 		break;
10055344Spendry 	}
10155344Spendry 
10255344Spendry 	case KTT_STRING: {
10355344Spendry 		char *cp = kt->kt_data;
10455344Spendry 		int xlen = strlen(cp) + 1;
10555344Spendry 
10655344Spendry 		if (xlen >= len)
10755344Spendry 			return (EINVAL);
10855344Spendry 
10955344Spendry 		bcopy(cp, buf, xlen);
11055344Spendry 		break;
11155344Spendry 	}
11255344Spendry 
11355344Spendry 	case KTT_HOSTNAME: {
11455344Spendry 		char *cp = hostname;
11555344Spendry 		int xlen = hostnamelen;
11655344Spendry 
11759556Spendry 		if (xlen >= (len-2))
11855344Spendry 			return (EINVAL);
11955344Spendry 
12059556Spendry 		bcopy(cp, buf, xlen);
12159556Spendry 		buf[xlen] = '\n';
12259556Spendry 		buf[xlen+1] = '\0';
12355344Spendry 		break;
12455344Spendry 	}
12555344Spendry 
12655344Spendry 	case KTT_AVENRUN:
12755344Spendry 		sprintf(buf, "%ld %ld %ld %ld\n",
12867387Spendry 		    averunnable.ldavg[0], averunnable.ldavg[1],
12967387Spendry 		    averunnable.ldavg[2], averunnable.fscale);
13055344Spendry 		break;
13155344Spendry 
13255344Spendry 	default:
13367387Spendry 		return (EIO);
13455344Spendry 	}
13555344Spendry 
13655344Spendry 	*lenp = strlen(buf);
13755344Spendry 	return (0);
13855344Spendry }
13955344Spendry 
14055344Spendry static int
14155344Spendry kernfs_xwrite(kt, buf, len)
14255344Spendry 	struct kern_target *kt;
14355344Spendry 	char *buf;
14455344Spendry 	int len;
14555344Spendry {
14667387Spendry 
14755344Spendry 	switch (kt->kt_tag) {
14867387Spendry 	case KTT_HOSTNAME:
14955344Spendry 		if (buf[len-1] == '\n')
15055344Spendry 			--len;
15155344Spendry 		bcopy(buf, hostname, len);
15259556Spendry 		hostname[len] = '\0';
15359556Spendry 		hostnamelen = len;
15455344Spendry 		return (0);
15555344Spendry 
15655344Spendry 	default:
15755344Spendry 		return (EIO);
15855344Spendry 	}
15955344Spendry }
16055344Spendry 
16155344Spendry 
16255344Spendry /*
16355344Spendry  * vp is the current namei directory
16455344Spendry  * ndp is the name to locate in that directory...
16555344Spendry  */
16655344Spendry kernfs_lookup(ap)
16755344Spendry 	struct vop_lookup_args /* {
16855344Spendry 		struct vnode * a_dvp;
16955344Spendry 		struct vnode ** a_vpp;
17055344Spendry 		struct componentname * a_cnp;
17155344Spendry 	} */ *ap;
17255344Spendry {
17367387Spendry 	struct componentname *cnp = ap->a_cnp;
17455344Spendry 	struct vnode **vpp = ap->a_vpp;
17555344Spendry 	struct vnode *dvp = ap->a_dvp;
17667387Spendry 	char *pname = cnp->cn_nameptr;
177*69436Smckusick 	struct proc *p = cnp->cn_proc;
17867387Spendry 	struct kern_target *kt;
17965446Sbostic 	struct vnode *fvp;
18065446Sbostic 	int error, i;
18155344Spendry 
18255344Spendry #ifdef KERNFS_DIAGNOSTIC
18355344Spendry 	printf("kernfs_lookup(%x)\n", ap);
18455344Spendry 	printf("kernfs_lookup(dp = %x, vpp = %x, cnp = %x)\n", dvp, vpp, ap->a_cnp);
18555344Spendry 	printf("kernfs_lookup(%s)\n", pname);
18655344Spendry #endif
18767387Spendry 
18869349Smckusick 	*vpp = NULLVP;
18969349Smckusick 
19069349Smckusick 	if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
19169349Smckusick 		return (EROFS);
19269349Smckusick 
19355344Spendry 	if (cnp->cn_namelen == 1 && *pname == '.') {
19455344Spendry 		*vpp = dvp;
19555350Spendry 		VREF(dvp);
19655344Spendry 		/*VOP_LOCK(dvp);*/
19755344Spendry 		return (0);
19855344Spendry 	}
19955344Spendry 
20059556Spendry #if 0
20155344Spendry 	if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) {
20255344Spendry 		*vpp = rootdir;
20355344Spendry 		VREF(rootdir);
204*69436Smckusick 		vn_lock(rootdir, LK_EXCLUSIVE | LK_RETRY, p)
20555344Spendry 		return (0);
20655344Spendry 	}
20759556Spendry #endif
20855350Spendry 
20969349Smckusick 	for (kt = kern_targets, i = 0; i < nkern_targets; kt++, i++) {
21067387Spendry 		if (cnp->cn_namelen == kt->kt_namlen &&
21169349Smckusick 		    bcmp(kt->kt_name, pname, cnp->cn_namelen) == 0)
21269349Smckusick 			goto found;
21355344Spendry 	}
21455344Spendry 
21555344Spendry #ifdef KERNFS_DIAGNOSTIC
21669349Smckusick 	printf("kernfs_lookup: i = %d, failed", i);
21755344Spendry #endif
21855344Spendry 
21969349Smckusick 	return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);
22055344Spendry 
22169349Smckusick found:
22267387Spendry 	if (kt->kt_tag == KTT_DEVICE) {
22367387Spendry 		dev_t *dp = kt->kt_data;
22467387Spendry 	loop:
22567387Spendry 		if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp))
22667387Spendry 			return (ENOENT);
22767387Spendry 		*vpp = fvp;
228*69436Smckusick 		if (vget(fvp, LK_EXCLUSIVE, p))
22967387Spendry 			goto loop;
23067387Spendry 		return (0);
23167387Spendry 	}
23267387Spendry 
23355344Spendry #ifdef KERNFS_DIAGNOSTIC
23455344Spendry 	printf("kernfs_lookup: allocate new vnode\n");
23555344Spendry #endif
23667387Spendry 	if (error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p,
23767387Spendry 	    &fvp))
23867387Spendry 		return (error);
23967387Spendry 
24067387Spendry 	MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP,
24167387Spendry 	    M_WAITOK);
24267387Spendry 	VTOKERN(fvp)->kf_kt = kt;
24367387Spendry 	fvp->v_type = kt->kt_vtype;
24455344Spendry 	*vpp = fvp;
24567387Spendry 
24655344Spendry #ifdef KERNFS_DIAGNOSTIC
24755344Spendry 	printf("kernfs_lookup: newvp = %x\n", fvp);
24855344Spendry #endif
24955344Spendry 	return (0);
25055344Spendry }
25155344Spendry 
25255344Spendry kernfs_open(ap)
25355344Spendry 	struct vop_open_args /* {
25455344Spendry 		struct vnode *a_vp;
25555344Spendry 		int  a_mode;
25655344Spendry 		struct ucred *a_cred;
25755344Spendry 		struct proc *a_p;
25855344Spendry 	} */ *ap;
25955344Spendry {
26055344Spendry 
26167387Spendry 	/* Only need to check access permissions. */
26255344Spendry 	return (0);
26355344Spendry }
26455344Spendry 
26555344Spendry static int
26655344Spendry kernfs_access(ap)
26755344Spendry 	struct vop_access_args /* {
26855344Spendry 		struct vnode *a_vp;
26955344Spendry 		int  a_mode;
27055344Spendry 		struct ucred *a_cred;
27155344Spendry 		struct proc *a_p;
27255344Spendry 	} */ *ap;
27355344Spendry {
27467387Spendry 	register struct vnode *vp = ap->a_vp;
27567387Spendry 	register struct ucred *cred = ap->a_cred;
27667387Spendry 	mode_t amode = ap->a_mode;
27767387Spendry 	mode_t fmode =
27867387Spendry 	    (vp->v_flag & VROOT) ? DIR_MODE : VTOKERN(vp)->kf_kt->kt_mode;
27967387Spendry 	mode_t mask = 0;
28067387Spendry 	register gid_t *gp;
28167387Spendry 	int i;
28255344Spendry 
28367387Spendry 	/* Some files are simply not modifiable. */
28467387Spendry 	if ((amode & VWRITE) && (fmode & (S_IWUSR|S_IWGRP|S_IWOTH)) == 0)
28567387Spendry 		return (EPERM);
28655344Spendry 
28767387Spendry 	/* Root can do anything else. */
28867387Spendry 	if (cred->cr_uid == 0)
28967387Spendry 		return (0);
29056497Smckusick 
29167387Spendry 	/* Check for group 0 (wheel) permissions. */
29267387Spendry 	for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++)
29367387Spendry 		if (*gp == 0) {
29467387Spendry 			if (amode & VEXEC)
29567387Spendry 				mask |= S_IXGRP;
29667387Spendry 			if (amode & VREAD)
29767387Spendry 				mask |= S_IRGRP;
29867387Spendry 			if (amode & VWRITE)
29967387Spendry 				mask |= S_IWGRP;
30067387Spendry 			return ((fmode & mask) == mask ?  0 : EACCES);
30156497Smckusick 		}
30255344Spendry 
30367387Spendry         /* Otherwise, check everyone else. */
30467387Spendry 	if (amode & VEXEC)
30567387Spendry 		mask |= S_IXOTH;
30667387Spendry 	if (amode & VREAD)
30767387Spendry 		mask |= S_IROTH;
30867387Spendry 	if (amode & VWRITE)
30967387Spendry 		mask |= S_IWOTH;
31067387Spendry 	return ((fmode & mask) == mask ? 0 : EACCES);
31155344Spendry }
31255344Spendry 
31355344Spendry kernfs_getattr(ap)
31455344Spendry 	struct vop_getattr_args /* {
31555344Spendry 		struct vnode *a_vp;
31655344Spendry 		struct vattr *a_vap;
31755344Spendry 		struct ucred *a_cred;
31855344Spendry 		struct proc *a_p;
31955344Spendry 	} */ *ap;
32055344Spendry {
32155344Spendry 	struct vnode *vp = ap->a_vp;
32255344Spendry 	struct vattr *vap = ap->a_vap;
32368173Scgd 	struct timeval tv;
32455344Spendry 	int error = 0;
32555344Spendry 	char strbuf[KSTRING];
32655344Spendry 
32755344Spendry 	bzero((caddr_t) vap, sizeof(*vap));
32855344Spendry 	vattr_null(vap);
32955344Spendry 	vap->va_uid = 0;
33055344Spendry 	vap->va_gid = 0;
33155344Spendry 	vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
33267387Spendry 	vap->va_size = 0;
33355344Spendry 	vap->va_blocksize = DEV_BSIZE;
33468173Scgd 	microtime(&tv);
33568173Scgd 	TIMEVAL_TO_TIMESPEC(&tv, &vap->va_atime);
33655344Spendry 	vap->va_mtime = vap->va_atime;
33755344Spendry 	vap->va_ctime = vap->va_ctime;
33855344Spendry 	vap->va_gen = 0;
33955344Spendry 	vap->va_flags = 0;
34055344Spendry 	vap->va_rdev = 0;
34155344Spendry 	vap->va_bytes = 0;
34255344Spendry 
34355344Spendry 	if (vp->v_flag & VROOT) {
34455344Spendry #ifdef KERNFS_DIAGNOSTIC
34555344Spendry 		printf("kernfs_getattr: stat rootdir\n");
34655344Spendry #endif
34755344Spendry 		vap->va_type = VDIR;
34855356Spendry 		vap->va_mode = DIR_MODE;
34955344Spendry 		vap->va_nlink = 2;
35055344Spendry 		vap->va_fileid = 2;
35155344Spendry 		vap->va_size = DEV_BSIZE;
35255344Spendry 	} else {
35356497Smckusick 		struct kern_target *kt = VTOKERN(vp)->kf_kt;
35455344Spendry 		int nbytes;
35555344Spendry #ifdef KERNFS_DIAGNOSTIC
35655344Spendry 		printf("kernfs_getattr: stat target %s\n", kt->kt_name);
35755344Spendry #endif
35855344Spendry 		vap->va_type = kt->kt_vtype;
35967387Spendry 		vap->va_mode = kt->kt_mode;
36055344Spendry 		vap->va_nlink = 1;
36167387Spendry 		vap->va_fileid = 1 + (kt - kern_targets) / sizeof(*kt);
36255344Spendry 		error = kernfs_xread(kt, strbuf, sizeof(strbuf), &nbytes);
36355344Spendry 		vap->va_size = nbytes;
36455344Spendry 	}
36555344Spendry 
36655344Spendry #ifdef KERNFS_DIAGNOSTIC
36755344Spendry 	printf("kernfs_getattr: return error %d\n", error);
36855344Spendry #endif
36955344Spendry 	return (error);
37055344Spendry }
37155344Spendry 
37255344Spendry kernfs_setattr(ap)
37355344Spendry 	struct vop_setattr_args /* {
37455344Spendry 		struct vnode *a_vp;
37555344Spendry 		struct vattr *a_vap;
37655344Spendry 		struct ucred *a_cred;
37755344Spendry 		struct proc *a_p;
37855344Spendry 	} */ *ap;
37955344Spendry {
38055344Spendry 
38155344Spendry 	/*
38255344Spendry 	 * Silently ignore attribute changes.
38355344Spendry 	 * This allows for open with truncate to have no
38455344Spendry 	 * effect until some data is written.  I want to
38555344Spendry 	 * do it this way because all writes are atomic.
38655344Spendry 	 */
38755344Spendry 	return (0);
38855344Spendry }
38955344Spendry 
39055344Spendry static int
39155344Spendry kernfs_read(ap)
39255344Spendry 	struct vop_read_args /* {
39355344Spendry 		struct vnode *a_vp;
39455344Spendry 		struct uio *a_uio;
39555344Spendry 		int  a_ioflag;
39655344Spendry 		struct ucred *a_cred;
39755344Spendry 	} */ *ap;
39855344Spendry {
39955344Spendry 	struct vnode *vp = ap->a_vp;
40055344Spendry 	struct uio *uio = ap->a_uio;
40156497Smckusick 	struct kern_target *kt;
40255344Spendry 	char strbuf[KSTRING];
40355344Spendry 	int off = uio->uio_offset;
40465446Sbostic 	int error, len;
40565446Sbostic 	char *cp;
40656497Smckusick 
40767387Spendry 	if (vp->v_type == VDIR)
40866052Spendry 		return (EOPNOTSUPP);
40956497Smckusick 
41056497Smckusick 	kt = VTOKERN(vp)->kf_kt;
41156497Smckusick 
41255344Spendry #ifdef KERNFS_DIAGNOSTIC
41355344Spendry 	printf("kern_read %s\n", kt->kt_name);
41455344Spendry #endif
41555344Spendry 
41665446Sbostic 	len = 0;
41767387Spendry 	if (error = kernfs_xread(kt, strbuf, sizeof(strbuf), &len))
41855344Spendry 		return (error);
41967387Spendry 	if (len <= off)
42067387Spendry 		return (0);
42167387Spendry 	return (uiomove(&strbuf[off], len - off, uio));
42255344Spendry }
42355344Spendry 
42455344Spendry static int
42555344Spendry kernfs_write(ap)
42655344Spendry 	struct vop_write_args /* {
42755344Spendry 		struct vnode *a_vp;
42855344Spendry 		struct uio *a_uio;
42955344Spendry 		int  a_ioflag;
43055344Spendry 		struct ucred *a_cred;
43155344Spendry 	} */ *ap;
43255344Spendry {
43355344Spendry 	struct vnode *vp = ap->a_vp;
43455344Spendry 	struct uio *uio = ap->a_uio;
43556497Smckusick 	struct kern_target *kt;
43665446Sbostic 	int error, xlen;
43755344Spendry 	char strbuf[KSTRING];
43855344Spendry 
43967387Spendry 	if (vp->v_type == VDIR)
44067387Spendry 		return (EOPNOTSUPP);
44156497Smckusick 
44256497Smckusick 	kt = VTOKERN(vp)->kf_kt;
44356497Smckusick 
44455344Spendry 	if (uio->uio_offset != 0)
44555344Spendry 		return (EINVAL);
44655344Spendry 
44755344Spendry 	xlen = min(uio->uio_resid, KSTRING-1);
44867387Spendry 	if (error = uiomove(strbuf, xlen, uio))
44955344Spendry 		return (error);
45055344Spendry 
45155344Spendry 	if (uio->uio_resid != 0)
45255344Spendry 		return (EIO);
45355344Spendry 
45455344Spendry 	strbuf[xlen] = '\0';
45559556Spendry 	xlen = strlen(strbuf);
45655344Spendry 	return (kernfs_xwrite(kt, strbuf, xlen));
45755344Spendry }
45855344Spendry 
45955344Spendry kernfs_readdir(ap)
46055344Spendry 	struct vop_readdir_args /* {
46155344Spendry 		struct vnode *a_vp;
46255344Spendry 		struct uio *a_uio;
46355344Spendry 		struct ucred *a_cred;
46467365Smckusick 		int *a_eofflag;
46567365Smckusick 		u_long *a_cookies;
46667365Smckusick 		int a_ncookies;
46755344Spendry 	} */ *ap;
46855344Spendry {
46967387Spendry 	int error, i;
47055344Spendry 	struct uio *uio = ap->a_uio;
47167387Spendry 	struct kern_target *kt;
47267387Spendry 	struct dirent d;
47355344Spendry 
47467387Spendry 	if (ap->a_vp->v_type != VDIR)
47567387Spendry 		return (ENOTDIR);
47667387Spendry 
47767365Smckusick 	/*
47867365Smckusick 	 * We don't allow exporting kernfs mounts, and currently local
47967365Smckusick 	 * requests do not need cookies.
48067365Smckusick 	 */
48167387Spendry 	if (ap->a_ncookies != NULL)
48267365Smckusick 		panic("kernfs_readdir: not hungry");
48367365Smckusick 
48455344Spendry 	i = uio->uio_offset / UIO_MX;
48555344Spendry 	error = 0;
48667387Spendry 	for (kt = &kern_targets[i];
48767387Spendry 		uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) {
48855344Spendry 		struct dirent *dp = &d;
48955344Spendry #ifdef KERNFS_DIAGNOSTIC
49055344Spendry 		printf("kernfs_readdir: i = %d\n", i);
49155344Spendry #endif
49255344Spendry 
49367387Spendry 		if (kt->kt_tag == KTT_DEVICE) {
49467387Spendry 			dev_t *dp = kt->kt_data;
49567387Spendry 			struct vnode *fvp;
49655344Spendry 
49767387Spendry 			if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp))
49867387Spendry 				continue;
49967387Spendry 		}
50055344Spendry 
50167387Spendry 		bzero((caddr_t)dp, UIO_MX);
50267387Spendry 		dp->d_namlen = kt->kt_namlen;
50367387Spendry 		bcopy(kt->kt_name, dp->d_name, kt->kt_namlen+1);
50467387Spendry 
50555344Spendry #ifdef KERNFS_DIAGNOSTIC
50655344Spendry 		printf("kernfs_readdir: name = %s, len = %d\n",
50755344Spendry 				dp->d_name, dp->d_namlen);
50855344Spendry #endif
50955344Spendry 		/*
51055344Spendry 		 * Fill in the remaining fields
51155344Spendry 		 */
51255344Spendry 		dp->d_reclen = UIO_MX;
51355344Spendry 		dp->d_fileno = i + 3;
51467387Spendry 		dp->d_type = kt->kt_type;
51555344Spendry 		/*
51655344Spendry 		 * And ship to userland
51755344Spendry 		 */
51867387Spendry 		if (error = uiomove((caddr_t)dp, UIO_MX, uio))
51955344Spendry 			break;
52055344Spendry 	}
52155344Spendry 
52255344Spendry 	uio->uio_offset = i * UIO_MX;
52355344Spendry 
52455344Spendry 	return (error);
52555344Spendry }
52655344Spendry 
52755344Spendry kernfs_inactive(ap)
52855344Spendry 	struct vop_inactive_args /* {
52955344Spendry 		struct vnode *a_vp;
53055344Spendry 	} */ *ap;
53155344Spendry {
53255344Spendry 	struct vnode *vp = ap->a_vp;
53355344Spendry 
53467387Spendry #ifdef KERNFS_DIAGNOSTIC
53567387Spendry 	printf("kernfs_inactive(%x)\n", vp);
53667387Spendry #endif
53755344Spendry 	/*
53855344Spendry 	 * Clear out the v_type field to avoid
53955344Spendry 	 * nasty things happening in vgone().
54055344Spendry 	 */
54155344Spendry 	vp->v_type = VNON;
54255344Spendry 	return (0);
54355344Spendry }
54455344Spendry 
54555344Spendry kernfs_reclaim(ap)
54655344Spendry 	struct vop_reclaim_args /* {
54755344Spendry 		struct vnode *a_vp;
54855344Spendry 	} */ *ap;
54955344Spendry {
55055344Spendry 	struct vnode *vp = ap->a_vp;
55167387Spendry 
55260618Smckusick #ifdef KERNFS_DIAGNOSTIC
55355344Spendry 	printf("kernfs_reclaim(%x)\n", vp);
55460618Smckusick #endif
55555344Spendry 	if (vp->v_data) {
55655344Spendry 		FREE(vp->v_data, M_TEMP);
55755344Spendry 		vp->v_data = 0;
55855344Spendry 	}
55955344Spendry 	return (0);
56055344Spendry }
56155344Spendry 
56255344Spendry /*
56365742Spendry  * Return POSIX pathconf information applicable to special devices.
56465742Spendry  */
56565742Spendry kernfs_pathconf(ap)
56665742Spendry 	struct vop_pathconf_args /* {
56765742Spendry 		struct vnode *a_vp;
56865742Spendry 		int a_name;
56965742Spendry 		int *a_retval;
57065742Spendry 	} */ *ap;
57165742Spendry {
57265742Spendry 
57365742Spendry 	switch (ap->a_name) {
57465742Spendry 	case _PC_LINK_MAX:
57565742Spendry 		*ap->a_retval = LINK_MAX;
57665742Spendry 		return (0);
57765742Spendry 	case _PC_MAX_CANON:
57865742Spendry 		*ap->a_retval = MAX_CANON;
57965742Spendry 		return (0);
58065742Spendry 	case _PC_MAX_INPUT:
58165742Spendry 		*ap->a_retval = MAX_INPUT;
58265742Spendry 		return (0);
58365742Spendry 	case _PC_PIPE_BUF:
58465742Spendry 		*ap->a_retval = PIPE_BUF;
58565742Spendry 		return (0);
58665742Spendry 	case _PC_CHOWN_RESTRICTED:
58765742Spendry 		*ap->a_retval = 1;
58865742Spendry 		return (0);
58965742Spendry 	case _PC_VDISABLE:
59065742Spendry 		*ap->a_retval = _POSIX_VDISABLE;
59165742Spendry 		return (0);
59265742Spendry 	default:
59365742Spendry 		return (EINVAL);
59465742Spendry 	}
59565742Spendry 	/* NOTREACHED */
59665742Spendry }
59765742Spendry 
59865742Spendry /*
59955344Spendry  * Print out the contents of a /dev/fd vnode.
60055344Spendry  */
60155344Spendry /* ARGSUSED */
60255344Spendry kernfs_print(ap)
60355344Spendry 	struct vop_print_args /* {
60455344Spendry 		struct vnode *a_vp;
60555344Spendry 	} */ *ap;
60655344Spendry {
60755344Spendry 
60865380Spendry 	printf("tag VT_KERNFS, kernfs vnode\n");
60955344Spendry 	return (0);
61055344Spendry }
61155344Spendry 
61255344Spendry /*void*/
61355344Spendry kernfs_vfree(ap)
61455344Spendry 	struct vop_vfree_args /* {
61555344Spendry 		struct vnode *a_pvp;
61655344Spendry 		ino_t a_ino;
61755344Spendry 		int a_mode;
61855344Spendry 	} */ *ap;
61955344Spendry {
62055344Spendry 
62155344Spendry 	return (0);
62255344Spendry }
62355344Spendry 
62455344Spendry /*
62555344Spendry  * /dev/fd "should never get here" operation
62655344Spendry  */
62755344Spendry kernfs_badop()
62855344Spendry {
62955344Spendry 
63055344Spendry 	panic("kernfs: bad op");
63155344Spendry 	/* NOTREACHED */
63255344Spendry }
63355344Spendry 
63455344Spendry /*
63555350Spendry  * kernfs vnode null operation
63655344Spendry  */
63755344Spendry kernfs_nullop()
63855344Spendry {
63955344Spendry 
64055344Spendry 	return (0);
64155344Spendry }
64255344Spendry 
64368730Smckusick #define kernfs_create ((int (*) __P((struct  vop_create_args *)))eopnotsupp)
64468730Smckusick #define kernfs_mknod ((int (*) __P((struct  vop_mknod_args *)))eopnotsupp)
64555344Spendry #define kernfs_close ((int (*) __P((struct  vop_close_args *)))nullop)
64668730Smckusick #define kernfs_ioctl ((int (*) __P((struct  vop_ioctl_args *)))eopnotsupp)
64768730Smckusick #define kernfs_select ((int (*) __P((struct  vop_select_args *)))eopnotsupp)
64868730Smckusick #define kernfs_revoke vop_revoke
64968730Smckusick #define kernfs_mmap ((int (*) __P((struct  vop_mmap_args *)))eopnotsupp)
65055344Spendry #define kernfs_fsync ((int (*) __P((struct  vop_fsync_args *)))nullop)
65155344Spendry #define kernfs_seek ((int (*) __P((struct  vop_seek_args *)))nullop)
65268730Smckusick #define kernfs_remove ((int (*) __P((struct  vop_remove_args *)))eopnotsupp)
65368730Smckusick #define kernfs_link ((int (*) __P((struct  vop_link_args *)))eopnotsupp)
65468730Smckusick #define kernfs_rename ((int (*) __P((struct  vop_rename_args *)))eopnotsupp)
65568730Smckusick #define kernfs_mkdir ((int (*) __P((struct  vop_mkdir_args *)))eopnotsupp)
65668730Smckusick #define kernfs_rmdir ((int (*) __P((struct  vop_rmdir_args *)))eopnotsupp)
65768730Smckusick #define kernfs_symlink ((int (*) __P((struct vop_symlink_args *)))eopnotsupp)
65868730Smckusick #define kernfs_readlink ((int (*) __P((struct  vop_readlink_args *)))eopnotsupp)
65955344Spendry #define kernfs_abortop ((int (*) __P((struct  vop_abortop_args *)))nullop)
660*69436Smckusick #define kernfs_lock ((int (*) __P((struct  vop_lock_args *)))vop_nolock)
661*69436Smckusick #define kernfs_unlock ((int (*) __P((struct  vop_unlock_args *)))vop_nounlock)
66255344Spendry #define kernfs_bmap ((int (*) __P((struct  vop_bmap_args *)))kernfs_badop)
66368730Smckusick #define kernfs_strategy \
66468730Smckusick 	((int (*) __P((struct  vop_strategy_args *)))kernfs_badop)
665*69436Smckusick #define kernfs_islocked \
666*69436Smckusick 	((int (*) __P((struct vop_islocked_args *)))vop_noislocked)
66768730Smckusick #define kernfs_advlock ((int (*) __P((struct vop_advlock_args *)))eopnotsupp)
66868730Smckusick #define kernfs_blkatoff ((int (*) __P((struct  vop_blkatoff_args *)))eopnotsupp)
66955344Spendry #define kernfs_valloc ((int(*) __P(( \
67055344Spendry 		struct vnode *pvp, \
67155344Spendry 		int mode, \
67255344Spendry 		struct ucred *cred, \
67368730Smckusick 		struct vnode **vpp))) eopnotsupp)
67468730Smckusick #define kernfs_truncate ((int (*) __P((struct  vop_truncate_args *)))eopnotsupp)
67568730Smckusick #define kernfs_update ((int (*) __P((struct  vop_update_args *)))eopnotsupp)
67668730Smckusick #define kernfs_bwrite ((int (*) __P((struct  vop_bwrite_args *)))eopnotsupp)
67755344Spendry 
67855344Spendry int (**kernfs_vnodeop_p)();
67955344Spendry struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = {
68055344Spendry 	{ &vop_default_desc, vn_default_error },
68155344Spendry 	{ &vop_lookup_desc, kernfs_lookup },	/* lookup */
68255344Spendry 	{ &vop_create_desc, kernfs_create },	/* create */
68355344Spendry 	{ &vop_mknod_desc, kernfs_mknod },	/* mknod */
68465742Spendry 	{ &vop_open_desc, kernfs_open },	/* open */
68555344Spendry 	{ &vop_close_desc, kernfs_close },	/* close */
68655344Spendry 	{ &vop_access_desc, kernfs_access },	/* access */
68755344Spendry 	{ &vop_getattr_desc, kernfs_getattr },	/* getattr */
68855344Spendry 	{ &vop_setattr_desc, kernfs_setattr },	/* setattr */
68965742Spendry 	{ &vop_read_desc, kernfs_read },	/* read */
69055344Spendry 	{ &vop_write_desc, kernfs_write },	/* write */
69155344Spendry 	{ &vop_ioctl_desc, kernfs_ioctl },	/* ioctl */
69255344Spendry 	{ &vop_select_desc, kernfs_select },	/* select */
69368730Smckusick 	{ &vop_revoke_desc, kernfs_revoke },	/* revoke */
69465742Spendry 	{ &vop_mmap_desc, kernfs_mmap },	/* mmap */
69555344Spendry 	{ &vop_fsync_desc, kernfs_fsync },	/* fsync */
69665742Spendry 	{ &vop_seek_desc, kernfs_seek },	/* seek */
69755344Spendry 	{ &vop_remove_desc, kernfs_remove },	/* remove */
69865742Spendry 	{ &vop_link_desc, kernfs_link },	/* link */
69955344Spendry 	{ &vop_rename_desc, kernfs_rename },	/* rename */
70055344Spendry 	{ &vop_mkdir_desc, kernfs_mkdir },	/* mkdir */
70155344Spendry 	{ &vop_rmdir_desc, kernfs_rmdir },	/* rmdir */
70255344Spendry 	{ &vop_symlink_desc, kernfs_symlink },	/* symlink */
70355344Spendry 	{ &vop_readdir_desc, kernfs_readdir },	/* readdir */
70465742Spendry 	{ &vop_readlink_desc, kernfs_readlink },/* readlink */
70555344Spendry 	{ &vop_abortop_desc, kernfs_abortop },	/* abortop */
70665742Spendry 	{ &vop_inactive_desc, kernfs_inactive },/* inactive */
70755344Spendry 	{ &vop_reclaim_desc, kernfs_reclaim },	/* reclaim */
70865742Spendry 	{ &vop_lock_desc, kernfs_lock },	/* lock */
70955344Spendry 	{ &vop_unlock_desc, kernfs_unlock },	/* unlock */
71065742Spendry 	{ &vop_bmap_desc, kernfs_bmap },	/* bmap */
71165742Spendry 	{ &vop_strategy_desc, kernfs_strategy },/* strategy */
71255344Spendry 	{ &vop_print_desc, kernfs_print },	/* print */
71365742Spendry 	{ &vop_islocked_desc, kernfs_islocked },/* islocked */
71465742Spendry 	{ &vop_pathconf_desc, kernfs_pathconf },/* pathconf */
71555344Spendry 	{ &vop_advlock_desc, kernfs_advlock },	/* advlock */
71665742Spendry 	{ &vop_blkatoff_desc, kernfs_blkatoff },/* blkatoff */
71755344Spendry 	{ &vop_valloc_desc, kernfs_valloc },	/* valloc */
71855344Spendry 	{ &vop_vfree_desc, kernfs_vfree },	/* vfree */
71965742Spendry 	{ &vop_truncate_desc, kernfs_truncate },/* truncate */
72055344Spendry 	{ &vop_update_desc, kernfs_update },	/* update */
72155344Spendry 	{ &vop_bwrite_desc, kernfs_bwrite },	/* bwrite */
72255344Spendry 	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
72355344Spendry };
72455344Spendry struct vnodeopv_desc kernfs_vnodeop_opv_desc =
72555344Spendry 	{ &kernfs_vnodeop_p, kernfs_vnodeop_entries };
726