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*68730Smckusick  *	@(#)kernfs_vnops.c	8.11 (Berkeley) 04/03/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;
17767387Spendry 	struct kern_target *kt;
17865446Sbostic 	struct vnode *fvp;
17965446Sbostic 	int error, i;
18055344Spendry 
18155344Spendry #ifdef KERNFS_DIAGNOSTIC
18255344Spendry 	printf("kernfs_lookup(%x)\n", ap);
18355344Spendry 	printf("kernfs_lookup(dp = %x, vpp = %x, cnp = %x)\n", dvp, vpp, ap->a_cnp);
18455344Spendry 	printf("kernfs_lookup(%s)\n", pname);
18555344Spendry #endif
18667387Spendry 
18755344Spendry 	if (cnp->cn_namelen == 1 && *pname == '.') {
18855344Spendry 		*vpp = dvp;
18955350Spendry 		VREF(dvp);
19055344Spendry 		/*VOP_LOCK(dvp);*/
19155344Spendry 		return (0);
19255344Spendry 	}
19355344Spendry 
19459556Spendry #if 0
19555344Spendry 	if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) {
19655344Spendry 		*vpp = rootdir;
19755344Spendry 		VREF(rootdir);
19855344Spendry 		VOP_LOCK(rootdir);
19955344Spendry 		return (0);
20055344Spendry 	}
20159556Spendry #endif
20255350Spendry 
20367388Spendry 	*vpp = NULLVP;
20467388Spendry 
20567387Spendry 	for (error = ENOENT, kt = kern_targets, i = 0; i < nkern_targets;
20667387Spendry 	     kt++, i++) {
20767387Spendry 		if (cnp->cn_namelen == kt->kt_namlen &&
20855344Spendry 		    bcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) {
20955344Spendry 			error = 0;
21055344Spendry 			break;
21155344Spendry 		}
21255344Spendry 	}
21355344Spendry 
21455344Spendry #ifdef KERNFS_DIAGNOSTIC
21555344Spendry 	printf("kernfs_lookup: i = %d, error = %d\n", i, error);
21655344Spendry #endif
21755344Spendry 
21855344Spendry 	if (error)
21967387Spendry 		return (error);
22055344Spendry 
22167387Spendry 	if (kt->kt_tag == KTT_DEVICE) {
22267387Spendry 		dev_t *dp = kt->kt_data;
22367387Spendry 	loop:
22467387Spendry 		if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp))
22567387Spendry 			return (ENOENT);
22667387Spendry 		*vpp = fvp;
22767387Spendry 		if (vget(fvp, 1))
22867387Spendry 			goto loop;
22967387Spendry 		return (0);
23067387Spendry 	}
23167387Spendry 
23255344Spendry #ifdef KERNFS_DIAGNOSTIC
23355344Spendry 	printf("kernfs_lookup: allocate new vnode\n");
23455344Spendry #endif
23567387Spendry 	if (error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p,
23667387Spendry 	    &fvp))
23767387Spendry 		return (error);
23867387Spendry 
23967387Spendry 	MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP,
24067387Spendry 	    M_WAITOK);
24167387Spendry 	VTOKERN(fvp)->kf_kt = kt;
24267387Spendry 	fvp->v_type = kt->kt_vtype;
24355344Spendry 	*vpp = fvp;
24467387Spendry 
24555344Spendry #ifdef KERNFS_DIAGNOSTIC
24655344Spendry 	printf("kernfs_lookup: newvp = %x\n", fvp);
24755344Spendry #endif
24855344Spendry 	return (0);
24955344Spendry }
25055344Spendry 
25155344Spendry kernfs_open(ap)
25255344Spendry 	struct vop_open_args /* {
25355344Spendry 		struct vnode *a_vp;
25455344Spendry 		int  a_mode;
25555344Spendry 		struct ucred *a_cred;
25655344Spendry 		struct proc *a_p;
25755344Spendry 	} */ *ap;
25855344Spendry {
25955344Spendry 
26067387Spendry 	/* Only need to check access permissions. */
26155344Spendry 	return (0);
26255344Spendry }
26355344Spendry 
26455344Spendry static int
26555344Spendry kernfs_access(ap)
26655344Spendry 	struct vop_access_args /* {
26755344Spendry 		struct vnode *a_vp;
26855344Spendry 		int  a_mode;
26955344Spendry 		struct ucred *a_cred;
27055344Spendry 		struct proc *a_p;
27155344Spendry 	} */ *ap;
27255344Spendry {
27367387Spendry 	register struct vnode *vp = ap->a_vp;
27467387Spendry 	register struct ucred *cred = ap->a_cred;
27567387Spendry 	mode_t amode = ap->a_mode;
27667387Spendry 	mode_t fmode =
27767387Spendry 	    (vp->v_flag & VROOT) ? DIR_MODE : VTOKERN(vp)->kf_kt->kt_mode;
27867387Spendry 	mode_t mask = 0;
27967387Spendry 	register gid_t *gp;
28067387Spendry 	int i;
28155344Spendry 
28267387Spendry 	/* Some files are simply not modifiable. */
28367387Spendry 	if ((amode & VWRITE) && (fmode & (S_IWUSR|S_IWGRP|S_IWOTH)) == 0)
28467387Spendry 		return (EPERM);
28555344Spendry 
28667387Spendry 	/* Root can do anything else. */
28767387Spendry 	if (cred->cr_uid == 0)
28867387Spendry 		return (0);
28956497Smckusick 
29067387Spendry 	/* Check for group 0 (wheel) permissions. */
29167387Spendry 	for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++)
29267387Spendry 		if (*gp == 0) {
29367387Spendry 			if (amode & VEXEC)
29467387Spendry 				mask |= S_IXGRP;
29567387Spendry 			if (amode & VREAD)
29667387Spendry 				mask |= S_IRGRP;
29767387Spendry 			if (amode & VWRITE)
29867387Spendry 				mask |= S_IWGRP;
29967387Spendry 			return ((fmode & mask) == mask ?  0 : EACCES);
30056497Smckusick 		}
30155344Spendry 
30267387Spendry         /* Otherwise, check everyone else. */
30367387Spendry 	if (amode & VEXEC)
30467387Spendry 		mask |= S_IXOTH;
30567387Spendry 	if (amode & VREAD)
30667387Spendry 		mask |= S_IROTH;
30767387Spendry 	if (amode & VWRITE)
30867387Spendry 		mask |= S_IWOTH;
30967387Spendry 	return ((fmode & mask) == mask ? 0 : EACCES);
31055344Spendry }
31155344Spendry 
31255344Spendry kernfs_getattr(ap)
31355344Spendry 	struct vop_getattr_args /* {
31455344Spendry 		struct vnode *a_vp;
31555344Spendry 		struct vattr *a_vap;
31655344Spendry 		struct ucred *a_cred;
31755344Spendry 		struct proc *a_p;
31855344Spendry 	} */ *ap;
31955344Spendry {
32055344Spendry 	struct vnode *vp = ap->a_vp;
32155344Spendry 	struct vattr *vap = ap->a_vap;
32268173Scgd 	struct timeval tv;
32355344Spendry 	int error = 0;
32455344Spendry 	char strbuf[KSTRING];
32555344Spendry 
32655344Spendry 	bzero((caddr_t) vap, sizeof(*vap));
32755344Spendry 	vattr_null(vap);
32855344Spendry 	vap->va_uid = 0;
32955344Spendry 	vap->va_gid = 0;
33055344Spendry 	vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
33167387Spendry 	vap->va_size = 0;
33255344Spendry 	vap->va_blocksize = DEV_BSIZE;
33368173Scgd 	microtime(&tv);
33468173Scgd 	TIMEVAL_TO_TIMESPEC(&tv, &vap->va_atime);
33555344Spendry 	vap->va_mtime = vap->va_atime;
33655344Spendry 	vap->va_ctime = vap->va_ctime;
33755344Spendry 	vap->va_gen = 0;
33855344Spendry 	vap->va_flags = 0;
33955344Spendry 	vap->va_rdev = 0;
34055344Spendry 	vap->va_bytes = 0;
34155344Spendry 
34255344Spendry 	if (vp->v_flag & VROOT) {
34355344Spendry #ifdef KERNFS_DIAGNOSTIC
34455344Spendry 		printf("kernfs_getattr: stat rootdir\n");
34555344Spendry #endif
34655344Spendry 		vap->va_type = VDIR;
34755356Spendry 		vap->va_mode = DIR_MODE;
34855344Spendry 		vap->va_nlink = 2;
34955344Spendry 		vap->va_fileid = 2;
35055344Spendry 		vap->va_size = DEV_BSIZE;
35155344Spendry 	} else {
35256497Smckusick 		struct kern_target *kt = VTOKERN(vp)->kf_kt;
35355344Spendry 		int nbytes;
35455344Spendry #ifdef KERNFS_DIAGNOSTIC
35555344Spendry 		printf("kernfs_getattr: stat target %s\n", kt->kt_name);
35655344Spendry #endif
35755344Spendry 		vap->va_type = kt->kt_vtype;
35867387Spendry 		vap->va_mode = kt->kt_mode;
35955344Spendry 		vap->va_nlink = 1;
36067387Spendry 		vap->va_fileid = 1 + (kt - kern_targets) / sizeof(*kt);
36155344Spendry 		error = kernfs_xread(kt, strbuf, sizeof(strbuf), &nbytes);
36255344Spendry 		vap->va_size = nbytes;
36355344Spendry 	}
36455344Spendry 
36555344Spendry #ifdef KERNFS_DIAGNOSTIC
36655344Spendry 	printf("kernfs_getattr: return error %d\n", error);
36755344Spendry #endif
36855344Spendry 	return (error);
36955344Spendry }
37055344Spendry 
37155344Spendry kernfs_setattr(ap)
37255344Spendry 	struct vop_setattr_args /* {
37355344Spendry 		struct vnode *a_vp;
37455344Spendry 		struct vattr *a_vap;
37555344Spendry 		struct ucred *a_cred;
37655344Spendry 		struct proc *a_p;
37755344Spendry 	} */ *ap;
37855344Spendry {
37955344Spendry 
38055344Spendry 	/*
38155344Spendry 	 * Silently ignore attribute changes.
38255344Spendry 	 * This allows for open with truncate to have no
38355344Spendry 	 * effect until some data is written.  I want to
38455344Spendry 	 * do it this way because all writes are atomic.
38555344Spendry 	 */
38655344Spendry 	return (0);
38755344Spendry }
38855344Spendry 
38955344Spendry static int
39055344Spendry kernfs_read(ap)
39155344Spendry 	struct vop_read_args /* {
39255344Spendry 		struct vnode *a_vp;
39355344Spendry 		struct uio *a_uio;
39455344Spendry 		int  a_ioflag;
39555344Spendry 		struct ucred *a_cred;
39655344Spendry 	} */ *ap;
39755344Spendry {
39855344Spendry 	struct vnode *vp = ap->a_vp;
39955344Spendry 	struct uio *uio = ap->a_uio;
40056497Smckusick 	struct kern_target *kt;
40155344Spendry 	char strbuf[KSTRING];
40255344Spendry 	int off = uio->uio_offset;
40365446Sbostic 	int error, len;
40465446Sbostic 	char *cp;
40556497Smckusick 
40667387Spendry 	if (vp->v_type == VDIR)
40766052Spendry 		return (EOPNOTSUPP);
40856497Smckusick 
40956497Smckusick 	kt = VTOKERN(vp)->kf_kt;
41056497Smckusick 
41155344Spendry #ifdef KERNFS_DIAGNOSTIC
41255344Spendry 	printf("kern_read %s\n", kt->kt_name);
41355344Spendry #endif
41455344Spendry 
41565446Sbostic 	len = 0;
41667387Spendry 	if (error = kernfs_xread(kt, strbuf, sizeof(strbuf), &len))
41755344Spendry 		return (error);
41867387Spendry 	if (len <= off)
41967387Spendry 		return (0);
42067387Spendry 	return (uiomove(&strbuf[off], len - off, uio));
42155344Spendry }
42255344Spendry 
42355344Spendry static int
42455344Spendry kernfs_write(ap)
42555344Spendry 	struct vop_write_args /* {
42655344Spendry 		struct vnode *a_vp;
42755344Spendry 		struct uio *a_uio;
42855344Spendry 		int  a_ioflag;
42955344Spendry 		struct ucred *a_cred;
43055344Spendry 	} */ *ap;
43155344Spendry {
43255344Spendry 	struct vnode *vp = ap->a_vp;
43355344Spendry 	struct uio *uio = ap->a_uio;
43456497Smckusick 	struct kern_target *kt;
43565446Sbostic 	int error, xlen;
43655344Spendry 	char strbuf[KSTRING];
43755344Spendry 
43867387Spendry 	if (vp->v_type == VDIR)
43967387Spendry 		return (EOPNOTSUPP);
44056497Smckusick 
44156497Smckusick 	kt = VTOKERN(vp)->kf_kt;
44256497Smckusick 
44355344Spendry 	if (uio->uio_offset != 0)
44455344Spendry 		return (EINVAL);
44555344Spendry 
44655344Spendry 	xlen = min(uio->uio_resid, KSTRING-1);
44767387Spendry 	if (error = uiomove(strbuf, xlen, uio))
44855344Spendry 		return (error);
44955344Spendry 
45055344Spendry 	if (uio->uio_resid != 0)
45155344Spendry 		return (EIO);
45255344Spendry 
45355344Spendry 	strbuf[xlen] = '\0';
45459556Spendry 	xlen = strlen(strbuf);
45555344Spendry 	return (kernfs_xwrite(kt, strbuf, xlen));
45655344Spendry }
45755344Spendry 
45855344Spendry kernfs_readdir(ap)
45955344Spendry 	struct vop_readdir_args /* {
46055344Spendry 		struct vnode *a_vp;
46155344Spendry 		struct uio *a_uio;
46255344Spendry 		struct ucred *a_cred;
46367365Smckusick 		int *a_eofflag;
46467365Smckusick 		u_long *a_cookies;
46567365Smckusick 		int a_ncookies;
46655344Spendry 	} */ *ap;
46755344Spendry {
46867387Spendry 	int error, i;
46955344Spendry 	struct uio *uio = ap->a_uio;
47067387Spendry 	struct kern_target *kt;
47167387Spendry 	struct dirent d;
47255344Spendry 
47367387Spendry 	if (ap->a_vp->v_type != VDIR)
47467387Spendry 		return (ENOTDIR);
47567387Spendry 
47667365Smckusick 	/*
47767365Smckusick 	 * We don't allow exporting kernfs mounts, and currently local
47867365Smckusick 	 * requests do not need cookies.
47967365Smckusick 	 */
48067387Spendry 	if (ap->a_ncookies != NULL)
48167365Smckusick 		panic("kernfs_readdir: not hungry");
48267365Smckusick 
48355344Spendry 	i = uio->uio_offset / UIO_MX;
48455344Spendry 	error = 0;
48567387Spendry 	for (kt = &kern_targets[i];
48667387Spendry 		uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) {
48755344Spendry 		struct dirent *dp = &d;
48855344Spendry #ifdef KERNFS_DIAGNOSTIC
48955344Spendry 		printf("kernfs_readdir: i = %d\n", i);
49055344Spendry #endif
49155344Spendry 
49267387Spendry 		if (kt->kt_tag == KTT_DEVICE) {
49367387Spendry 			dev_t *dp = kt->kt_data;
49467387Spendry 			struct vnode *fvp;
49555344Spendry 
49667387Spendry 			if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp))
49767387Spendry 				continue;
49867387Spendry 		}
49955344Spendry 
50067387Spendry 		bzero((caddr_t)dp, UIO_MX);
50167387Spendry 		dp->d_namlen = kt->kt_namlen;
50267387Spendry 		bcopy(kt->kt_name, dp->d_name, kt->kt_namlen+1);
50367387Spendry 
50455344Spendry #ifdef KERNFS_DIAGNOSTIC
50555344Spendry 		printf("kernfs_readdir: name = %s, len = %d\n",
50655344Spendry 				dp->d_name, dp->d_namlen);
50755344Spendry #endif
50855344Spendry 		/*
50955344Spendry 		 * Fill in the remaining fields
51055344Spendry 		 */
51155344Spendry 		dp->d_reclen = UIO_MX;
51255344Spendry 		dp->d_fileno = i + 3;
51367387Spendry 		dp->d_type = kt->kt_type;
51455344Spendry 		/*
51555344Spendry 		 * And ship to userland
51655344Spendry 		 */
51767387Spendry 		if (error = uiomove((caddr_t)dp, UIO_MX, uio))
51855344Spendry 			break;
51955344Spendry 	}
52055344Spendry 
52155344Spendry 	uio->uio_offset = i * UIO_MX;
52255344Spendry 
52355344Spendry 	return (error);
52455344Spendry }
52555344Spendry 
52655344Spendry kernfs_inactive(ap)
52755344Spendry 	struct vop_inactive_args /* {
52855344Spendry 		struct vnode *a_vp;
52955344Spendry 	} */ *ap;
53055344Spendry {
53155344Spendry 	struct vnode *vp = ap->a_vp;
53255344Spendry 
53367387Spendry #ifdef KERNFS_DIAGNOSTIC
53467387Spendry 	printf("kernfs_inactive(%x)\n", vp);
53567387Spendry #endif
53655344Spendry 	/*
53755344Spendry 	 * Clear out the v_type field to avoid
53855344Spendry 	 * nasty things happening in vgone().
53955344Spendry 	 */
54055344Spendry 	vp->v_type = VNON;
54155344Spendry 	return (0);
54255344Spendry }
54355344Spendry 
54455344Spendry kernfs_reclaim(ap)
54555344Spendry 	struct vop_reclaim_args /* {
54655344Spendry 		struct vnode *a_vp;
54755344Spendry 	} */ *ap;
54855344Spendry {
54955344Spendry 	struct vnode *vp = ap->a_vp;
55067387Spendry 
55160618Smckusick #ifdef KERNFS_DIAGNOSTIC
55255344Spendry 	printf("kernfs_reclaim(%x)\n", vp);
55360618Smckusick #endif
55455344Spendry 	if (vp->v_data) {
55555344Spendry 		FREE(vp->v_data, M_TEMP);
55655344Spendry 		vp->v_data = 0;
55755344Spendry 	}
55855344Spendry 	return (0);
55955344Spendry }
56055344Spendry 
56155344Spendry /*
56265742Spendry  * Return POSIX pathconf information applicable to special devices.
56365742Spendry  */
56465742Spendry kernfs_pathconf(ap)
56565742Spendry 	struct vop_pathconf_args /* {
56665742Spendry 		struct vnode *a_vp;
56765742Spendry 		int a_name;
56865742Spendry 		int *a_retval;
56965742Spendry 	} */ *ap;
57065742Spendry {
57165742Spendry 
57265742Spendry 	switch (ap->a_name) {
57365742Spendry 	case _PC_LINK_MAX:
57465742Spendry 		*ap->a_retval = LINK_MAX;
57565742Spendry 		return (0);
57665742Spendry 	case _PC_MAX_CANON:
57765742Spendry 		*ap->a_retval = MAX_CANON;
57865742Spendry 		return (0);
57965742Spendry 	case _PC_MAX_INPUT:
58065742Spendry 		*ap->a_retval = MAX_INPUT;
58165742Spendry 		return (0);
58265742Spendry 	case _PC_PIPE_BUF:
58365742Spendry 		*ap->a_retval = PIPE_BUF;
58465742Spendry 		return (0);
58565742Spendry 	case _PC_CHOWN_RESTRICTED:
58665742Spendry 		*ap->a_retval = 1;
58765742Spendry 		return (0);
58865742Spendry 	case _PC_VDISABLE:
58965742Spendry 		*ap->a_retval = _POSIX_VDISABLE;
59065742Spendry 		return (0);
59165742Spendry 	default:
59265742Spendry 		return (EINVAL);
59365742Spendry 	}
59465742Spendry 	/* NOTREACHED */
59565742Spendry }
59665742Spendry 
59765742Spendry /*
59855344Spendry  * Print out the contents of a /dev/fd vnode.
59955344Spendry  */
60055344Spendry /* ARGSUSED */
60155344Spendry kernfs_print(ap)
60255344Spendry 	struct vop_print_args /* {
60355344Spendry 		struct vnode *a_vp;
60455344Spendry 	} */ *ap;
60555344Spendry {
60655344Spendry 
60765380Spendry 	printf("tag VT_KERNFS, kernfs vnode\n");
60855344Spendry 	return (0);
60955344Spendry }
61055344Spendry 
61155344Spendry /*void*/
61255344Spendry kernfs_vfree(ap)
61355344Spendry 	struct vop_vfree_args /* {
61455344Spendry 		struct vnode *a_pvp;
61555344Spendry 		ino_t a_ino;
61655344Spendry 		int a_mode;
61755344Spendry 	} */ *ap;
61855344Spendry {
61955344Spendry 
62055344Spendry 	return (0);
62155344Spendry }
62255344Spendry 
62355344Spendry /*
62455344Spendry  * /dev/fd "should never get here" operation
62555344Spendry  */
62655344Spendry kernfs_badop()
62755344Spendry {
62855344Spendry 
62955344Spendry 	panic("kernfs: bad op");
63055344Spendry 	/* NOTREACHED */
63155344Spendry }
63255344Spendry 
63355344Spendry /*
63455350Spendry  * kernfs vnode null operation
63555344Spendry  */
63655344Spendry kernfs_nullop()
63755344Spendry {
63855344Spendry 
63955344Spendry 	return (0);
64055344Spendry }
64155344Spendry 
642*68730Smckusick #define kernfs_create ((int (*) __P((struct  vop_create_args *)))eopnotsupp)
643*68730Smckusick #define kernfs_mknod ((int (*) __P((struct  vop_mknod_args *)))eopnotsupp)
64455344Spendry #define kernfs_close ((int (*) __P((struct  vop_close_args *)))nullop)
645*68730Smckusick #define kernfs_ioctl ((int (*) __P((struct  vop_ioctl_args *)))eopnotsupp)
646*68730Smckusick #define kernfs_select ((int (*) __P((struct  vop_select_args *)))eopnotsupp)
647*68730Smckusick #define kernfs_revoke vop_revoke
648*68730Smckusick #define kernfs_mmap ((int (*) __P((struct  vop_mmap_args *)))eopnotsupp)
64955344Spendry #define kernfs_fsync ((int (*) __P((struct  vop_fsync_args *)))nullop)
65055344Spendry #define kernfs_seek ((int (*) __P((struct  vop_seek_args *)))nullop)
651*68730Smckusick #define kernfs_remove ((int (*) __P((struct  vop_remove_args *)))eopnotsupp)
652*68730Smckusick #define kernfs_link ((int (*) __P((struct  vop_link_args *)))eopnotsupp)
653*68730Smckusick #define kernfs_rename ((int (*) __P((struct  vop_rename_args *)))eopnotsupp)
654*68730Smckusick #define kernfs_mkdir ((int (*) __P((struct  vop_mkdir_args *)))eopnotsupp)
655*68730Smckusick #define kernfs_rmdir ((int (*) __P((struct  vop_rmdir_args *)))eopnotsupp)
656*68730Smckusick #define kernfs_symlink ((int (*) __P((struct vop_symlink_args *)))eopnotsupp)
657*68730Smckusick #define kernfs_readlink ((int (*) __P((struct  vop_readlink_args *)))eopnotsupp)
65855344Spendry #define kernfs_abortop ((int (*) __P((struct  vop_abortop_args *)))nullop)
65955344Spendry #define kernfs_lock ((int (*) __P((struct  vop_lock_args *)))nullop)
66055344Spendry #define kernfs_unlock ((int (*) __P((struct  vop_unlock_args *)))nullop)
66155344Spendry #define kernfs_bmap ((int (*) __P((struct  vop_bmap_args *)))kernfs_badop)
662*68730Smckusick #define kernfs_strategy \
663*68730Smckusick 	((int (*) __P((struct  vop_strategy_args *)))kernfs_badop)
66455344Spendry #define kernfs_islocked ((int (*) __P((struct  vop_islocked_args *)))nullop)
665*68730Smckusick #define kernfs_advlock ((int (*) __P((struct vop_advlock_args *)))eopnotsupp)
666*68730Smckusick #define kernfs_blkatoff ((int (*) __P((struct  vop_blkatoff_args *)))eopnotsupp)
66755344Spendry #define kernfs_valloc ((int(*) __P(( \
66855344Spendry 		struct vnode *pvp, \
66955344Spendry 		int mode, \
67055344Spendry 		struct ucred *cred, \
671*68730Smckusick 		struct vnode **vpp))) eopnotsupp)
672*68730Smckusick #define kernfs_truncate ((int (*) __P((struct  vop_truncate_args *)))eopnotsupp)
673*68730Smckusick #define kernfs_update ((int (*) __P((struct  vop_update_args *)))eopnotsupp)
674*68730Smckusick #define kernfs_bwrite ((int (*) __P((struct  vop_bwrite_args *)))eopnotsupp)
67555344Spendry 
67655344Spendry int (**kernfs_vnodeop_p)();
67755344Spendry struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = {
67855344Spendry 	{ &vop_default_desc, vn_default_error },
67955344Spendry 	{ &vop_lookup_desc, kernfs_lookup },	/* lookup */
68055344Spendry 	{ &vop_create_desc, kernfs_create },	/* create */
68155344Spendry 	{ &vop_mknod_desc, kernfs_mknod },	/* mknod */
68265742Spendry 	{ &vop_open_desc, kernfs_open },	/* open */
68355344Spendry 	{ &vop_close_desc, kernfs_close },	/* close */
68455344Spendry 	{ &vop_access_desc, kernfs_access },	/* access */
68555344Spendry 	{ &vop_getattr_desc, kernfs_getattr },	/* getattr */
68655344Spendry 	{ &vop_setattr_desc, kernfs_setattr },	/* setattr */
68765742Spendry 	{ &vop_read_desc, kernfs_read },	/* read */
68855344Spendry 	{ &vop_write_desc, kernfs_write },	/* write */
68955344Spendry 	{ &vop_ioctl_desc, kernfs_ioctl },	/* ioctl */
69055344Spendry 	{ &vop_select_desc, kernfs_select },	/* select */
691*68730Smckusick 	{ &vop_revoke_desc, kernfs_revoke },	/* revoke */
69265742Spendry 	{ &vop_mmap_desc, kernfs_mmap },	/* mmap */
69355344Spendry 	{ &vop_fsync_desc, kernfs_fsync },	/* fsync */
69465742Spendry 	{ &vop_seek_desc, kernfs_seek },	/* seek */
69555344Spendry 	{ &vop_remove_desc, kernfs_remove },	/* remove */
69665742Spendry 	{ &vop_link_desc, kernfs_link },	/* link */
69755344Spendry 	{ &vop_rename_desc, kernfs_rename },	/* rename */
69855344Spendry 	{ &vop_mkdir_desc, kernfs_mkdir },	/* mkdir */
69955344Spendry 	{ &vop_rmdir_desc, kernfs_rmdir },	/* rmdir */
70055344Spendry 	{ &vop_symlink_desc, kernfs_symlink },	/* symlink */
70155344Spendry 	{ &vop_readdir_desc, kernfs_readdir },	/* readdir */
70265742Spendry 	{ &vop_readlink_desc, kernfs_readlink },/* readlink */
70355344Spendry 	{ &vop_abortop_desc, kernfs_abortop },	/* abortop */
70465742Spendry 	{ &vop_inactive_desc, kernfs_inactive },/* inactive */
70555344Spendry 	{ &vop_reclaim_desc, kernfs_reclaim },	/* reclaim */
70665742Spendry 	{ &vop_lock_desc, kernfs_lock },	/* lock */
70755344Spendry 	{ &vop_unlock_desc, kernfs_unlock },	/* unlock */
70865742Spendry 	{ &vop_bmap_desc, kernfs_bmap },	/* bmap */
70965742Spendry 	{ &vop_strategy_desc, kernfs_strategy },/* strategy */
71055344Spendry 	{ &vop_print_desc, kernfs_print },	/* print */
71165742Spendry 	{ &vop_islocked_desc, kernfs_islocked },/* islocked */
71265742Spendry 	{ &vop_pathconf_desc, kernfs_pathconf },/* pathconf */
71355344Spendry 	{ &vop_advlock_desc, kernfs_advlock },	/* advlock */
71465742Spendry 	{ &vop_blkatoff_desc, kernfs_blkatoff },/* blkatoff */
71555344Spendry 	{ &vop_valloc_desc, kernfs_valloc },	/* valloc */
71655344Spendry 	{ &vop_vfree_desc, kernfs_vfree },	/* vfree */
71765742Spendry 	{ &vop_truncate_desc, kernfs_truncate },/* truncate */
71855344Spendry 	{ &vop_update_desc, kernfs_update },	/* update */
71955344Spendry 	{ &vop_bwrite_desc, kernfs_bwrite },	/* bwrite */
72055344Spendry 	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
72155344Spendry };
72255344Spendry struct vnodeopv_desc kernfs_vnodeop_opv_desc =
72355344Spendry 	{ &kernfs_vnodeop_p, kernfs_vnodeop_entries };
724