xref: /freebsd/sys/fs/devfs/devfs_vnops.c (revision 5b0945b57059d1cde0831d3afea7ec56c7d79508)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2000-2004
5  *	Poul-Henning Kamp.  All rights reserved.
6  * Copyright (c) 1989, 1992-1993, 1995
7  *	The Regents of the University of California.  All rights reserved.
8  *
9  * This code is derived from software donated to Berkeley by
10  * Jan-Simon Pendry.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *	@(#)kernfs_vnops.c	8.15 (Berkeley) 5/21/95
34  * From: FreeBSD: src/sys/miscfs/kernfs/kernfs_vnops.c 1.43
35  *
36  * $FreeBSD$
37  */
38 
39 /*
40  * TODO:
41  *	mkdir: want it ?
42  */
43 
44 #include <sys/param.h>
45 #include <sys/systm.h>
46 #include <sys/conf.h>
47 #include <sys/dirent.h>
48 #include <sys/eventhandler.h>
49 #include <sys/fcntl.h>
50 #include <sys/file.h>
51 #include <sys/filedesc.h>
52 #include <sys/filio.h>
53 #include <sys/jail.h>
54 #include <sys/kernel.h>
55 #include <sys/limits.h>
56 #include <sys/lock.h>
57 #include <sys/malloc.h>
58 #include <sys/mman.h>
59 #include <sys/mount.h>
60 #include <sys/namei.h>
61 #include <sys/priv.h>
62 #include <sys/proc.h>
63 #include <sys/stat.h>
64 #include <sys/sx.h>
65 #include <sys/sysctl.h>
66 #include <sys/time.h>
67 #include <sys/ttycom.h>
68 #include <sys/unistd.h>
69 #include <sys/vnode.h>
70 
71 static struct vop_vector devfs_vnodeops;
72 static struct vop_vector devfs_specops;
73 static struct fileops devfs_ops_f;
74 
75 #include <fs/devfs/devfs.h>
76 #include <fs/devfs/devfs_int.h>
77 
78 #include <security/mac/mac_framework.h>
79 
80 #include <vm/vm.h>
81 #include <vm/vm_extern.h>
82 #include <vm/vm_object.h>
83 
84 static MALLOC_DEFINE(M_CDEVPDATA, "DEVFSP", "Metainfo for cdev-fp data");
85 
86 struct mtx	devfs_de_interlock;
87 MTX_SYSINIT(devfs_de_interlock, &devfs_de_interlock, "devfs interlock", MTX_DEF);
88 struct sx	clone_drain_lock;
89 SX_SYSINIT(clone_drain_lock, &clone_drain_lock, "clone events drain lock");
90 struct mtx	cdevpriv_mtx;
91 MTX_SYSINIT(cdevpriv_mtx, &cdevpriv_mtx, "cdevpriv lock", MTX_DEF);
92 
93 SYSCTL_DECL(_vfs_devfs);
94 
95 static int devfs_dotimes;
96 SYSCTL_INT(_vfs_devfs, OID_AUTO, dotimes, CTLFLAG_RW,
97     &devfs_dotimes, 0, "Update timestamps on DEVFS with default precision");
98 
99 /*
100  * Update devfs node timestamp.  Note that updates are unlocked and
101  * stat(2) could see partially updated times.
102  */
103 static void
104 devfs_timestamp(struct timespec *tsp)
105 {
106 	time_t ts;
107 
108 	if (devfs_dotimes) {
109 		vfs_timestamp(tsp);
110 	} else {
111 		ts = time_second;
112 		if (tsp->tv_sec != ts) {
113 			tsp->tv_sec = ts;
114 			tsp->tv_nsec = 0;
115 		}
116 	}
117 }
118 
119 static int
120 devfs_fp_check(struct file *fp, struct cdev **devp, struct cdevsw **dswp,
121     int *ref)
122 {
123 
124 	*dswp = devvn_refthread(fp->f_vnode, devp, ref);
125 	if (*devp != fp->f_data) {
126 		if (*dswp != NULL)
127 			dev_relthread(*devp, *ref);
128 		return (ENXIO);
129 	}
130 	KASSERT((*devp)->si_refcount > 0,
131 	    ("devfs: un-referenced struct cdev *(%s)", devtoname(*devp)));
132 	if (*dswp == NULL)
133 		return (ENXIO);
134 	curthread->td_fpop = fp;
135 	return (0);
136 }
137 
138 int
139 devfs_get_cdevpriv(void **datap)
140 {
141 	struct file *fp;
142 	struct cdev_privdata *p;
143 	int error;
144 
145 	fp = curthread->td_fpop;
146 	if (fp == NULL)
147 		return (EBADF);
148 	p = fp->f_cdevpriv;
149 	if (p != NULL) {
150 		error = 0;
151 		*datap = p->cdpd_data;
152 	} else
153 		error = ENOENT;
154 	return (error);
155 }
156 
157 int
158 devfs_set_cdevpriv(void *priv, d_priv_dtor_t *priv_dtr)
159 {
160 	struct file *fp;
161 	struct cdev_priv *cdp;
162 	struct cdev_privdata *p;
163 	int error;
164 
165 	fp = curthread->td_fpop;
166 	if (fp == NULL)
167 		return (ENOENT);
168 	cdp = cdev2priv((struct cdev *)fp->f_data);
169 	p = malloc(sizeof(struct cdev_privdata), M_CDEVPDATA, M_WAITOK);
170 	p->cdpd_data = priv;
171 	p->cdpd_dtr = priv_dtr;
172 	p->cdpd_fp = fp;
173 	mtx_lock(&cdevpriv_mtx);
174 	if (fp->f_cdevpriv == NULL) {
175 		LIST_INSERT_HEAD(&cdp->cdp_fdpriv, p, cdpd_list);
176 		fp->f_cdevpriv = p;
177 		mtx_unlock(&cdevpriv_mtx);
178 		error = 0;
179 	} else {
180 		mtx_unlock(&cdevpriv_mtx);
181 		free(p, M_CDEVPDATA);
182 		error = EBUSY;
183 	}
184 	return (error);
185 }
186 
187 void
188 devfs_destroy_cdevpriv(struct cdev_privdata *p)
189 {
190 
191 	mtx_assert(&cdevpriv_mtx, MA_OWNED);
192 	KASSERT(p->cdpd_fp->f_cdevpriv == p,
193 	    ("devfs_destoy_cdevpriv %p != %p", p->cdpd_fp->f_cdevpriv, p));
194 	p->cdpd_fp->f_cdevpriv = NULL;
195 	LIST_REMOVE(p, cdpd_list);
196 	mtx_unlock(&cdevpriv_mtx);
197 	(p->cdpd_dtr)(p->cdpd_data);
198 	free(p, M_CDEVPDATA);
199 }
200 
201 static void
202 devfs_fpdrop(struct file *fp)
203 {
204 	struct cdev_privdata *p;
205 
206 	mtx_lock(&cdevpriv_mtx);
207 	if ((p = fp->f_cdevpriv) == NULL) {
208 		mtx_unlock(&cdevpriv_mtx);
209 		return;
210 	}
211 	devfs_destroy_cdevpriv(p);
212 }
213 
214 void
215 devfs_clear_cdevpriv(void)
216 {
217 	struct file *fp;
218 
219 	fp = curthread->td_fpop;
220 	if (fp == NULL)
221 		return;
222 	devfs_fpdrop(fp);
223 }
224 
225 /*
226  * On success devfs_populate_vp() returns with dmp->dm_lock held.
227  */
228 static int
229 devfs_populate_vp(struct vnode *vp)
230 {
231 	struct devfs_dirent *de;
232 	struct devfs_mount *dmp;
233 	int locked;
234 
235 	ASSERT_VOP_LOCKED(vp, "devfs_populate_vp");
236 
237 	dmp = VFSTODEVFS(vp->v_mount);
238 	locked = VOP_ISLOCKED(vp);
239 
240 	sx_xlock(&dmp->dm_lock);
241 	DEVFS_DMP_HOLD(dmp);
242 
243 	/* Can't call devfs_populate() with the vnode lock held. */
244 	VOP_UNLOCK(vp);
245 	devfs_populate(dmp);
246 
247 	sx_xunlock(&dmp->dm_lock);
248 	vn_lock(vp, locked | LK_RETRY);
249 	sx_xlock(&dmp->dm_lock);
250 	if (DEVFS_DMP_DROP(dmp)) {
251 		sx_xunlock(&dmp->dm_lock);
252 		devfs_unmount_final(dmp);
253 		return (ERESTART);
254 	}
255 	if (VN_IS_DOOMED(vp)) {
256 		sx_xunlock(&dmp->dm_lock);
257 		return (ERESTART);
258 	}
259 	de = vp->v_data;
260 	KASSERT(de != NULL,
261 	    ("devfs_populate_vp: vp->v_data == NULL but vnode not doomed"));
262 	if ((de->de_flags & DE_DOOMED) != 0) {
263 		sx_xunlock(&dmp->dm_lock);
264 		return (ERESTART);
265 	}
266 
267 	return (0);
268 }
269 
270 static int
271 devfs_vptocnp(struct vop_vptocnp_args *ap)
272 {
273 	struct vnode *vp = ap->a_vp;
274 	struct vnode **dvp = ap->a_vpp;
275 	struct devfs_mount *dmp;
276 	char *buf = ap->a_buf;
277 	size_t *buflen = ap->a_buflen;
278 	struct devfs_dirent *dd, *de;
279 	int i, error;
280 
281 	dmp = VFSTODEVFS(vp->v_mount);
282 
283 	error = devfs_populate_vp(vp);
284 	if (error != 0)
285 		return (error);
286 
287 	if (vp->v_type != VCHR && vp->v_type != VDIR) {
288 		error = ENOENT;
289 		goto finished;
290 	}
291 
292 	dd = vp->v_data;
293 	if (vp->v_type == VDIR && dd == dmp->dm_rootdir) {
294 		*dvp = vp;
295 		vref(*dvp);
296 		goto finished;
297 	}
298 
299 	i = *buflen;
300 	i -= dd->de_dirent->d_namlen;
301 	if (i < 0) {
302 		error = ENOMEM;
303 		goto finished;
304 	}
305 	bcopy(dd->de_dirent->d_name, buf + i, dd->de_dirent->d_namlen);
306 	*buflen = i;
307 	de = devfs_parent_dirent(dd);
308 	if (de == NULL) {
309 		error = ENOENT;
310 		goto finished;
311 	}
312 	mtx_lock(&devfs_de_interlock);
313 	*dvp = de->de_vnode;
314 	if (*dvp != NULL) {
315 		VI_LOCK(*dvp);
316 		mtx_unlock(&devfs_de_interlock);
317 		vholdl(*dvp);
318 		VI_UNLOCK(*dvp);
319 		vref(*dvp);
320 		vdrop(*dvp);
321 	} else {
322 		mtx_unlock(&devfs_de_interlock);
323 		error = ENOENT;
324 	}
325 finished:
326 	sx_xunlock(&dmp->dm_lock);
327 	return (error);
328 }
329 
330 /*
331  * Construct the fully qualified path name relative to the mountpoint.
332  * If a NULL cnp is provided, no '/' is appended to the resulting path.
333  */
334 char *
335 devfs_fqpn(char *buf, struct devfs_mount *dmp, struct devfs_dirent *dd,
336     struct componentname *cnp)
337 {
338 	int i;
339 	struct devfs_dirent *de;
340 
341 	sx_assert(&dmp->dm_lock, SA_LOCKED);
342 
343 	i = SPECNAMELEN;
344 	buf[i] = '\0';
345 	if (cnp != NULL)
346 		i -= cnp->cn_namelen;
347 	if (i < 0)
348 		 return (NULL);
349 	if (cnp != NULL)
350 		bcopy(cnp->cn_nameptr, buf + i, cnp->cn_namelen);
351 	de = dd;
352 	while (de != dmp->dm_rootdir) {
353 		if (cnp != NULL || i < SPECNAMELEN) {
354 			i--;
355 			if (i < 0)
356 				 return (NULL);
357 			buf[i] = '/';
358 		}
359 		i -= de->de_dirent->d_namlen;
360 		if (i < 0)
361 			 return (NULL);
362 		bcopy(de->de_dirent->d_name, buf + i,
363 		    de->de_dirent->d_namlen);
364 		de = devfs_parent_dirent(de);
365 		if (de == NULL)
366 			return (NULL);
367 	}
368 	return (buf + i);
369 }
370 
371 static int
372 devfs_allocv_drop_refs(int drop_dm_lock, struct devfs_mount *dmp,
373 	struct devfs_dirent *de)
374 {
375 	int not_found;
376 
377 	not_found = 0;
378 	if (de->de_flags & DE_DOOMED)
379 		not_found = 1;
380 	if (DEVFS_DE_DROP(de)) {
381 		KASSERT(not_found == 1, ("DEVFS de dropped but not doomed"));
382 		devfs_dirent_free(de);
383 	}
384 	if (DEVFS_DMP_DROP(dmp)) {
385 		KASSERT(not_found == 1,
386 			("DEVFS mount struct freed before dirent"));
387 		not_found = 2;
388 		sx_xunlock(&dmp->dm_lock);
389 		devfs_unmount_final(dmp);
390 	}
391 	if (not_found == 1 || (drop_dm_lock && not_found != 2))
392 		sx_unlock(&dmp->dm_lock);
393 	return (not_found);
394 }
395 
396 static void
397 devfs_insmntque_dtr(struct vnode *vp, void *arg)
398 {
399 	struct devfs_dirent *de;
400 
401 	de = (struct devfs_dirent *)arg;
402 	mtx_lock(&devfs_de_interlock);
403 	vp->v_data = NULL;
404 	de->de_vnode = NULL;
405 	mtx_unlock(&devfs_de_interlock);
406 	vgone(vp);
407 	vput(vp);
408 }
409 
410 /*
411  * devfs_allocv shall be entered with dmp->dm_lock held, and it drops
412  * it on return.
413  */
414 int
415 devfs_allocv(struct devfs_dirent *de, struct mount *mp, int lockmode,
416     struct vnode **vpp)
417 {
418 	int error;
419 	struct vnode *vp;
420 	struct cdev *dev;
421 	struct devfs_mount *dmp;
422 	struct cdevsw *dsw;
423 
424 	dmp = VFSTODEVFS(mp);
425 	if (de->de_flags & DE_DOOMED) {
426 		sx_xunlock(&dmp->dm_lock);
427 		return (ENOENT);
428 	}
429 loop:
430 	DEVFS_DE_HOLD(de);
431 	DEVFS_DMP_HOLD(dmp);
432 	mtx_lock(&devfs_de_interlock);
433 	vp = de->de_vnode;
434 	if (vp != NULL) {
435 		VI_LOCK(vp);
436 		mtx_unlock(&devfs_de_interlock);
437 		sx_xunlock(&dmp->dm_lock);
438 		vget(vp, lockmode | LK_INTERLOCK | LK_RETRY, curthread);
439 		sx_xlock(&dmp->dm_lock);
440 		if (devfs_allocv_drop_refs(0, dmp, de)) {
441 			vput(vp);
442 			return (ENOENT);
443 		}
444 		else if (VN_IS_DOOMED(vp)) {
445 			mtx_lock(&devfs_de_interlock);
446 			if (de->de_vnode == vp) {
447 				de->de_vnode = NULL;
448 				vp->v_data = NULL;
449 			}
450 			mtx_unlock(&devfs_de_interlock);
451 			vput(vp);
452 			goto loop;
453 		}
454 		sx_xunlock(&dmp->dm_lock);
455 		*vpp = vp;
456 		return (0);
457 	}
458 	mtx_unlock(&devfs_de_interlock);
459 	if (de->de_dirent->d_type == DT_CHR) {
460 		if (!(de->de_cdp->cdp_flags & CDP_ACTIVE)) {
461 			devfs_allocv_drop_refs(1, dmp, de);
462 			return (ENOENT);
463 		}
464 		dev = &de->de_cdp->cdp_c;
465 	} else {
466 		dev = NULL;
467 	}
468 	error = getnewvnode("devfs", mp, &devfs_vnodeops, &vp);
469 	if (error != 0) {
470 		devfs_allocv_drop_refs(1, dmp, de);
471 		printf("devfs_allocv: failed to allocate new vnode\n");
472 		return (error);
473 	}
474 
475 	if (de->de_dirent->d_type == DT_CHR) {
476 		vp->v_type = VCHR;
477 		VI_LOCK(vp);
478 		dev_lock();
479 		dev_refl(dev);
480 		/* XXX: v_rdev should be protect by vnode lock */
481 		vp->v_rdev = dev;
482 		VNPASS(vp->v_usecount == 1, vp);
483 		dev->si_usecount++;
484 		/* Special casing of ttys for deadfs.  Probably redundant. */
485 		dsw = dev->si_devsw;
486 		if (dsw != NULL && (dsw->d_flags & D_TTY) != 0)
487 			vp->v_vflag |= VV_ISTTY;
488 		dev_unlock();
489 		VI_UNLOCK(vp);
490 		if ((dev->si_flags & SI_ETERNAL) != 0)
491 			vp->v_vflag |= VV_ETERNALDEV;
492 		vp->v_op = &devfs_specops;
493 	} else if (de->de_dirent->d_type == DT_DIR) {
494 		vp->v_type = VDIR;
495 	} else if (de->de_dirent->d_type == DT_LNK) {
496 		vp->v_type = VLNK;
497 	} else {
498 		vp->v_type = VBAD;
499 	}
500 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY | LK_NOWITNESS);
501 	VN_LOCK_ASHARE(vp);
502 	mtx_lock(&devfs_de_interlock);
503 	vp->v_data = de;
504 	de->de_vnode = vp;
505 	mtx_unlock(&devfs_de_interlock);
506 	error = insmntque1(vp, mp, devfs_insmntque_dtr, de);
507 	if (error != 0) {
508 		(void) devfs_allocv_drop_refs(1, dmp, de);
509 		return (error);
510 	}
511 	if (devfs_allocv_drop_refs(0, dmp, de)) {
512 		vput(vp);
513 		return (ENOENT);
514 	}
515 #ifdef MAC
516 	mac_devfs_vnode_associate(mp, de, vp);
517 #endif
518 	sx_xunlock(&dmp->dm_lock);
519 	*vpp = vp;
520 	return (0);
521 }
522 
523 static int
524 devfs_access(struct vop_access_args *ap)
525 {
526 	struct vnode *vp = ap->a_vp;
527 	struct devfs_dirent *de;
528 	struct proc *p;
529 	int error;
530 
531 	de = vp->v_data;
532 	if (vp->v_type == VDIR)
533 		de = de->de_dir;
534 
535 	error = vaccess(vp->v_type, de->de_mode, de->de_uid, de->de_gid,
536 	    ap->a_accmode, ap->a_cred, NULL);
537 	if (error == 0)
538 		return (0);
539 	if (error != EACCES)
540 		return (error);
541 	p = ap->a_td->td_proc;
542 	/* We do, however, allow access to the controlling terminal */
543 	PROC_LOCK(p);
544 	if (!(p->p_flag & P_CONTROLT)) {
545 		PROC_UNLOCK(p);
546 		return (error);
547 	}
548 	if (p->p_session->s_ttydp == de->de_cdp)
549 		error = 0;
550 	PROC_UNLOCK(p);
551 	return (error);
552 }
553 
554 _Static_assert(((FMASK | FCNTLFLAGS) & (FLASTCLOSE | FREVOKE)) == 0,
555     "devfs-only flag reuse failed");
556 
557 static int
558 devfs_close(struct vop_close_args *ap)
559 {
560 	struct vnode *vp = ap->a_vp, *oldvp;
561 	struct thread *td = ap->a_td;
562 	struct proc *p;
563 	struct cdev *dev = vp->v_rdev;
564 	struct cdevsw *dsw;
565 	int dflags, error, ref, vp_locked;
566 
567 	/*
568 	 * XXX: Don't call d_close() if we were called because of
569 	 * XXX: insmntque1() failure.
570 	 */
571 	if (vp->v_data == NULL)
572 		return (0);
573 
574 	/*
575 	 * Hack: a tty device that is a controlling terminal
576 	 * has a reference from the session structure.
577 	 * We cannot easily tell that a character device is
578 	 * a controlling terminal, unless it is the closing
579 	 * process' controlling terminal.  In that case,
580 	 * if the reference count is 2 (this last descriptor
581 	 * plus the session), release the reference from the session.
582 	 */
583 	if (vp->v_usecount == 2 && td != NULL) {
584 		p = td->td_proc;
585 		PROC_LOCK(p);
586 		if (vp == p->p_session->s_ttyvp) {
587 			PROC_UNLOCK(p);
588 			oldvp = NULL;
589 			sx_xlock(&proctree_lock);
590 			if (vp == p->p_session->s_ttyvp) {
591 				SESS_LOCK(p->p_session);
592 				VI_LOCK(vp);
593 				if (vp->v_usecount == 2 && vcount(vp) == 1 &&
594 				    !VN_IS_DOOMED(vp)) {
595 					p->p_session->s_ttyvp = NULL;
596 					p->p_session->s_ttydp = NULL;
597 					oldvp = vp;
598 				}
599 				VI_UNLOCK(vp);
600 				SESS_UNLOCK(p->p_session);
601 			}
602 			sx_xunlock(&proctree_lock);
603 			if (oldvp != NULL)
604 				vrele(oldvp);
605 		} else
606 			PROC_UNLOCK(p);
607 	}
608 	/*
609 	 * We do not want to really close the device if it
610 	 * is still in use unless we are trying to close it
611 	 * forcibly. Since every use (buffer, vnode, swap, cmap)
612 	 * holds a reference to the vnode, and because we mark
613 	 * any other vnodes that alias this device, when the
614 	 * sum of the reference counts on all the aliased
615 	 * vnodes descends to one, we are on last close.
616 	 */
617 	dsw = dev_refthread(dev, &ref);
618 	if (dsw == NULL)
619 		return (ENXIO);
620 	dflags = 0;
621 	VI_LOCK(vp);
622 	if (vp->v_usecount == 1 && vcount(vp) == 1)
623 		dflags |= FLASTCLOSE;
624 	if (VN_IS_DOOMED(vp)) {
625 		/* Forced close. */
626 		dflags |= FREVOKE | FNONBLOCK;
627 	} else if (dsw->d_flags & D_TRACKCLOSE) {
628 		/* Keep device updated on status. */
629 	} else if ((dflags & FLASTCLOSE) == 0) {
630 		VI_UNLOCK(vp);
631 		dev_relthread(dev, ref);
632 		return (0);
633 	}
634 	vholdnz(vp);
635 	VI_UNLOCK(vp);
636 	vp_locked = VOP_ISLOCKED(vp);
637 	VOP_UNLOCK(vp);
638 	KASSERT(dev->si_refcount > 0,
639 	    ("devfs_close() on un-referenced struct cdev *(%s)", devtoname(dev)));
640 	error = dsw->d_close(dev, ap->a_fflag | dflags, S_IFCHR, td);
641 	dev_relthread(dev, ref);
642 	vn_lock(vp, vp_locked | LK_RETRY);
643 	vdrop(vp);
644 	return (error);
645 }
646 
647 static int
648 devfs_close_f(struct file *fp, struct thread *td)
649 {
650 	int error;
651 	struct file *fpop;
652 
653 	/*
654 	 * NB: td may be NULL if this descriptor is closed due to
655 	 * garbage collection from a closed UNIX domain socket.
656 	 */
657 	fpop = curthread->td_fpop;
658 	curthread->td_fpop = fp;
659 	error = vnops.fo_close(fp, td);
660 	curthread->td_fpop = fpop;
661 
662 	/*
663 	 * The f_cdevpriv cannot be assigned non-NULL value while we
664 	 * are destroying the file.
665 	 */
666 	if (fp->f_cdevpriv != NULL)
667 		devfs_fpdrop(fp);
668 	return (error);
669 }
670 
671 static int
672 devfs_getattr(struct vop_getattr_args *ap)
673 {
674 	struct vnode *vp = ap->a_vp;
675 	struct vattr *vap = ap->a_vap;
676 	struct devfs_dirent *de;
677 	struct devfs_mount *dmp;
678 	struct cdev *dev;
679 	struct timeval boottime;
680 	int error;
681 
682 	error = devfs_populate_vp(vp);
683 	if (error != 0)
684 		return (error);
685 
686 	dmp = VFSTODEVFS(vp->v_mount);
687 	sx_xunlock(&dmp->dm_lock);
688 
689 	de = vp->v_data;
690 	KASSERT(de != NULL, ("Null dirent in devfs_getattr vp=%p", vp));
691 	if (vp->v_type == VDIR) {
692 		de = de->de_dir;
693 		KASSERT(de != NULL,
694 		    ("Null dir dirent in devfs_getattr vp=%p", vp));
695 	}
696 	vap->va_uid = de->de_uid;
697 	vap->va_gid = de->de_gid;
698 	vap->va_mode = de->de_mode;
699 	if (vp->v_type == VLNK)
700 		vap->va_size = strlen(de->de_symlink);
701 	else if (vp->v_type == VDIR)
702 		vap->va_size = vap->va_bytes = DEV_BSIZE;
703 	else
704 		vap->va_size = 0;
705 	if (vp->v_type != VDIR)
706 		vap->va_bytes = 0;
707 	vap->va_blocksize = DEV_BSIZE;
708 	vap->va_type = vp->v_type;
709 
710 	getboottime(&boottime);
711 #define fix(aa)							\
712 	do {							\
713 		if ((aa).tv_sec <= 3600) {			\
714 			(aa).tv_sec = boottime.tv_sec;		\
715 			(aa).tv_nsec = boottime.tv_usec * 1000; \
716 		}						\
717 	} while (0)
718 
719 	if (vp->v_type != VCHR)  {
720 		fix(de->de_atime);
721 		vap->va_atime = de->de_atime;
722 		fix(de->de_mtime);
723 		vap->va_mtime = de->de_mtime;
724 		fix(de->de_ctime);
725 		vap->va_ctime = de->de_ctime;
726 	} else {
727 		dev = vp->v_rdev;
728 		fix(dev->si_atime);
729 		vap->va_atime = dev->si_atime;
730 		fix(dev->si_mtime);
731 		vap->va_mtime = dev->si_mtime;
732 		fix(dev->si_ctime);
733 		vap->va_ctime = dev->si_ctime;
734 
735 		vap->va_rdev = cdev2priv(dev)->cdp_inode;
736 	}
737 	vap->va_gen = 0;
738 	vap->va_flags = 0;
739 	vap->va_filerev = 0;
740 	vap->va_nlink = de->de_links;
741 	vap->va_fileid = de->de_inode;
742 
743 	return (error);
744 }
745 
746 /* ARGSUSED */
747 static int
748 devfs_ioctl_f(struct file *fp, u_long com, void *data, struct ucred *cred, struct thread *td)
749 {
750 	struct file *fpop;
751 	int error;
752 
753 	fpop = td->td_fpop;
754 	td->td_fpop = fp;
755 	error = vnops.fo_ioctl(fp, com, data, cred, td);
756 	td->td_fpop = fpop;
757 	return (error);
758 }
759 
760 void *
761 fiodgname_buf_get_ptr(void *fgnp, u_long com)
762 {
763 	union {
764 		struct fiodgname_arg	fgn;
765 #ifdef COMPAT_FREEBSD32
766 		struct fiodgname_arg32	fgn32;
767 #endif
768 	} *fgnup;
769 
770 	fgnup = fgnp;
771 	switch (com) {
772 	case FIODGNAME:
773 		return (fgnup->fgn.buf);
774 #ifdef COMPAT_FREEBSD32
775 	case FIODGNAME_32:
776 		return ((void *)(uintptr_t)fgnup->fgn32.buf);
777 #endif
778 	default:
779 		panic("Unhandled ioctl command %ld", com);
780 	}
781 }
782 
783 static int
784 devfs_ioctl(struct vop_ioctl_args *ap)
785 {
786 	struct fiodgname_arg *fgn;
787 	struct vnode *vpold, *vp;
788 	struct cdevsw *dsw;
789 	struct thread *td;
790 	struct session *sess;
791 	struct cdev *dev;
792 	int error, ref, i;
793 	const char *p;
794 	u_long com;
795 
796 	vp = ap->a_vp;
797 	com = ap->a_command;
798 	td = ap->a_td;
799 
800 	dsw = devvn_refthread(vp, &dev, &ref);
801 	if (dsw == NULL)
802 		return (ENXIO);
803 	KASSERT(dev->si_refcount > 0,
804 	    ("devfs: un-referenced struct cdev *(%s)", devtoname(dev)));
805 
806 	switch (com) {
807 	case FIODTYPE:
808 		*(int *)ap->a_data = dsw->d_flags & D_TYPEMASK;
809 		error = 0;
810 		break;
811 	case FIODGNAME:
812 #ifdef	COMPAT_FREEBSD32
813 	case FIODGNAME_32:
814 #endif
815 		fgn = ap->a_data;
816 		p = devtoname(dev);
817 		i = strlen(p) + 1;
818 		if (i > fgn->len)
819 			error = EINVAL;
820 		else
821 			error = copyout(p, fiodgname_buf_get_ptr(fgn, com), i);
822 		break;
823 	default:
824 		error = dsw->d_ioctl(dev, com, ap->a_data, ap->a_fflag, td);
825 	}
826 
827 	dev_relthread(dev, ref);
828 	if (error == ENOIOCTL)
829 		error = ENOTTY;
830 
831 	if (error == 0 && com == TIOCSCTTY) {
832 		/*
833 		 * Do nothing if reassigning same control tty, or if the
834 		 * control tty has already disappeared.  If it disappeared,
835 		 * it's because we were racing with TIOCNOTTY.  TIOCNOTTY
836 		 * already took care of releasing the old vnode and we have
837 		 * nothing left to do.
838 		 */
839 		sx_slock(&proctree_lock);
840 		sess = td->td_proc->p_session;
841 		if (sess->s_ttyvp == vp || sess->s_ttyp == NULL) {
842 			sx_sunlock(&proctree_lock);
843 			return (0);
844 		}
845 
846 		vrefact(vp);
847 		SESS_LOCK(sess);
848 		vpold = sess->s_ttyvp;
849 		sess->s_ttyvp = vp;
850 		sess->s_ttydp = cdev2priv(dev);
851 		SESS_UNLOCK(sess);
852 
853 		sx_sunlock(&proctree_lock);
854 
855 		/* Get rid of reference to old control tty */
856 		if (vpold)
857 			vrele(vpold);
858 	}
859 	return (error);
860 }
861 
862 /* ARGSUSED */
863 static int
864 devfs_kqfilter_f(struct file *fp, struct knote *kn)
865 {
866 	struct cdev *dev;
867 	struct cdevsw *dsw;
868 	int error, ref;
869 	struct file *fpop;
870 	struct thread *td;
871 
872 	td = curthread;
873 	fpop = td->td_fpop;
874 	error = devfs_fp_check(fp, &dev, &dsw, &ref);
875 	if (error)
876 		return (error);
877 	error = dsw->d_kqfilter(dev, kn);
878 	td->td_fpop = fpop;
879 	dev_relthread(dev, ref);
880 	return (error);
881 }
882 
883 static inline int
884 devfs_prison_check(struct devfs_dirent *de, struct thread *td)
885 {
886 	struct cdev_priv *cdp;
887 	struct ucred *dcr;
888 	struct proc *p;
889 	int error;
890 
891 	cdp = de->de_cdp;
892 	if (cdp == NULL)
893 		return (0);
894 	dcr = cdp->cdp_c.si_cred;
895 	if (dcr == NULL)
896 		return (0);
897 
898 	error = prison_check(td->td_ucred, dcr);
899 	if (error == 0)
900 		return (0);
901 	/* We do, however, allow access to the controlling terminal */
902 	p = td->td_proc;
903 	PROC_LOCK(p);
904 	if (!(p->p_flag & P_CONTROLT)) {
905 		PROC_UNLOCK(p);
906 		return (error);
907 	}
908 	if (p->p_session->s_ttydp == cdp)
909 		error = 0;
910 	PROC_UNLOCK(p);
911 	return (error);
912 }
913 
914 static int
915 devfs_lookupx(struct vop_lookup_args *ap, int *dm_unlock)
916 {
917 	struct componentname *cnp;
918 	struct vnode *dvp, **vpp;
919 	struct thread *td;
920 	struct devfs_dirent *de, *dd;
921 	struct devfs_dirent **dde;
922 	struct devfs_mount *dmp;
923 	struct mount *mp;
924 	struct cdev *cdev;
925 	int error, flags, nameiop, dvplocked;
926 	char specname[SPECNAMELEN + 1], *pname;
927 
928 	cnp = ap->a_cnp;
929 	vpp = ap->a_vpp;
930 	dvp = ap->a_dvp;
931 	pname = cnp->cn_nameptr;
932 	td = cnp->cn_thread;
933 	flags = cnp->cn_flags;
934 	nameiop = cnp->cn_nameiop;
935 	mp = dvp->v_mount;
936 	dmp = VFSTODEVFS(mp);
937 	dd = dvp->v_data;
938 	*vpp = NULLVP;
939 
940 	if ((flags & ISLASTCN) && nameiop == RENAME)
941 		return (EOPNOTSUPP);
942 
943 	if (dvp->v_type != VDIR)
944 		return (ENOTDIR);
945 
946 	if ((flags & ISDOTDOT) && (dvp->v_vflag & VV_ROOT))
947 		return (EIO);
948 
949 	error = vn_dir_check_exec(dvp, cnp);
950 	if (error != 0)
951 		return (error);
952 
953 	if (cnp->cn_namelen == 1 && *pname == '.') {
954 		if ((flags & ISLASTCN) && nameiop != LOOKUP)
955 			return (EINVAL);
956 		*vpp = dvp;
957 		VREF(dvp);
958 		return (0);
959 	}
960 
961 	if (flags & ISDOTDOT) {
962 		if ((flags & ISLASTCN) && nameiop != LOOKUP)
963 			return (EINVAL);
964 		de = devfs_parent_dirent(dd);
965 		if (de == NULL)
966 			return (ENOENT);
967 		dvplocked = VOP_ISLOCKED(dvp);
968 		VOP_UNLOCK(dvp);
969 		error = devfs_allocv(de, mp, cnp->cn_lkflags & LK_TYPE_MASK,
970 		    vpp);
971 		*dm_unlock = 0;
972 		vn_lock(dvp, dvplocked | LK_RETRY);
973 		return (error);
974 	}
975 
976 	dd = dvp->v_data;
977 	de = devfs_find(dd, cnp->cn_nameptr, cnp->cn_namelen, 0);
978 	while (de == NULL) {	/* While(...) so we can use break */
979 
980 		if (nameiop == DELETE)
981 			return (ENOENT);
982 
983 		/*
984 		 * OK, we didn't have an entry for the name we were asked for
985 		 * so we try to see if anybody can create it on demand.
986 		 */
987 		pname = devfs_fqpn(specname, dmp, dd, cnp);
988 		if (pname == NULL)
989 			break;
990 
991 		cdev = NULL;
992 		DEVFS_DMP_HOLD(dmp);
993 		sx_xunlock(&dmp->dm_lock);
994 		sx_slock(&clone_drain_lock);
995 		EVENTHANDLER_INVOKE(dev_clone,
996 		    td->td_ucred, pname, strlen(pname), &cdev);
997 		sx_sunlock(&clone_drain_lock);
998 
999 		if (cdev == NULL)
1000 			sx_xlock(&dmp->dm_lock);
1001 		else if (devfs_populate_vp(dvp) != 0) {
1002 			*dm_unlock = 0;
1003 			sx_xlock(&dmp->dm_lock);
1004 			if (DEVFS_DMP_DROP(dmp)) {
1005 				sx_xunlock(&dmp->dm_lock);
1006 				devfs_unmount_final(dmp);
1007 			} else
1008 				sx_xunlock(&dmp->dm_lock);
1009 			dev_rel(cdev);
1010 			return (ENOENT);
1011 		}
1012 		if (DEVFS_DMP_DROP(dmp)) {
1013 			*dm_unlock = 0;
1014 			sx_xunlock(&dmp->dm_lock);
1015 			devfs_unmount_final(dmp);
1016 			if (cdev != NULL)
1017 				dev_rel(cdev);
1018 			return (ENOENT);
1019 		}
1020 
1021 		if (cdev == NULL)
1022 			break;
1023 
1024 		dev_lock();
1025 		dde = &cdev2priv(cdev)->cdp_dirents[dmp->dm_idx];
1026 		if (dde != NULL && *dde != NULL)
1027 			de = *dde;
1028 		dev_unlock();
1029 		dev_rel(cdev);
1030 		break;
1031 	}
1032 
1033 	if (de == NULL || de->de_flags & DE_WHITEOUT) {
1034 		if ((nameiop == CREATE || nameiop == RENAME) &&
1035 		    (flags & (LOCKPARENT | WANTPARENT)) && (flags & ISLASTCN)) {
1036 			cnp->cn_flags |= SAVENAME;
1037 			return (EJUSTRETURN);
1038 		}
1039 		return (ENOENT);
1040 	}
1041 
1042 	if (devfs_prison_check(de, td))
1043 		return (ENOENT);
1044 
1045 	if ((cnp->cn_nameiop == DELETE) && (flags & ISLASTCN)) {
1046 		error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, td);
1047 		if (error)
1048 			return (error);
1049 		if (*vpp == dvp) {
1050 			VREF(dvp);
1051 			*vpp = dvp;
1052 			return (0);
1053 		}
1054 	}
1055 	error = devfs_allocv(de, mp, cnp->cn_lkflags & LK_TYPE_MASK, vpp);
1056 	*dm_unlock = 0;
1057 	return (error);
1058 }
1059 
1060 static int
1061 devfs_lookup(struct vop_lookup_args *ap)
1062 {
1063 	int j;
1064 	struct devfs_mount *dmp;
1065 	int dm_unlock;
1066 
1067 	if (devfs_populate_vp(ap->a_dvp) != 0)
1068 		return (ENOTDIR);
1069 
1070 	dmp = VFSTODEVFS(ap->a_dvp->v_mount);
1071 	dm_unlock = 1;
1072 	j = devfs_lookupx(ap, &dm_unlock);
1073 	if (dm_unlock == 1)
1074 		sx_xunlock(&dmp->dm_lock);
1075 	return (j);
1076 }
1077 
1078 static int
1079 devfs_mknod(struct vop_mknod_args *ap)
1080 {
1081 	struct componentname *cnp;
1082 	struct vnode *dvp, **vpp;
1083 	struct devfs_dirent *dd, *de;
1084 	struct devfs_mount *dmp;
1085 	int error;
1086 
1087 	/*
1088 	 * The only type of node we should be creating here is a
1089 	 * character device, for anything else return EOPNOTSUPP.
1090 	 */
1091 	if (ap->a_vap->va_type != VCHR)
1092 		return (EOPNOTSUPP);
1093 	dvp = ap->a_dvp;
1094 	dmp = VFSTODEVFS(dvp->v_mount);
1095 
1096 	cnp = ap->a_cnp;
1097 	vpp = ap->a_vpp;
1098 	dd = dvp->v_data;
1099 
1100 	error = ENOENT;
1101 	sx_xlock(&dmp->dm_lock);
1102 	TAILQ_FOREACH(de, &dd->de_dlist, de_list) {
1103 		if (cnp->cn_namelen != de->de_dirent->d_namlen)
1104 			continue;
1105 		if (de->de_dirent->d_type == DT_CHR &&
1106 		    (de->de_cdp->cdp_flags & CDP_ACTIVE) == 0)
1107 			continue;
1108 		if (bcmp(cnp->cn_nameptr, de->de_dirent->d_name,
1109 		    de->de_dirent->d_namlen) != 0)
1110 			continue;
1111 		if (de->de_flags & DE_WHITEOUT)
1112 			break;
1113 		goto notfound;
1114 	}
1115 	if (de == NULL)
1116 		goto notfound;
1117 	de->de_flags &= ~DE_WHITEOUT;
1118 	error = devfs_allocv(de, dvp->v_mount, LK_EXCLUSIVE, vpp);
1119 	return (error);
1120 notfound:
1121 	sx_xunlock(&dmp->dm_lock);
1122 	return (error);
1123 }
1124 
1125 /* ARGSUSED */
1126 static int
1127 devfs_open(struct vop_open_args *ap)
1128 {
1129 	struct thread *td = ap->a_td;
1130 	struct vnode *vp = ap->a_vp;
1131 	struct cdev *dev = vp->v_rdev;
1132 	struct file *fp = ap->a_fp;
1133 	int error, ref, vlocked;
1134 	struct cdevsw *dsw;
1135 	struct file *fpop;
1136 
1137 	if (vp->v_type == VBLK)
1138 		return (ENXIO);
1139 
1140 	if (dev == NULL)
1141 		return (ENXIO);
1142 
1143 	/* Make this field valid before any I/O in d_open. */
1144 	if (dev->si_iosize_max == 0)
1145 		dev->si_iosize_max = DFLTPHYS;
1146 
1147 	dsw = dev_refthread(dev, &ref);
1148 	if (dsw == NULL)
1149 		return (ENXIO);
1150 	if (fp == NULL && dsw->d_fdopen != NULL) {
1151 		dev_relthread(dev, ref);
1152 		return (ENXIO);
1153 	}
1154 
1155 	vlocked = VOP_ISLOCKED(vp);
1156 	VOP_UNLOCK(vp);
1157 
1158 	fpop = td->td_fpop;
1159 	td->td_fpop = fp;
1160 	if (fp != NULL) {
1161 		fp->f_data = dev;
1162 		fp->f_vnode = vp;
1163 	}
1164 	if (dsw->d_fdopen != NULL)
1165 		error = dsw->d_fdopen(dev, ap->a_mode, td, fp);
1166 	else
1167 		error = dsw->d_open(dev, ap->a_mode, S_IFCHR, td);
1168 	/* Clean up any cdevpriv upon error. */
1169 	if (error != 0)
1170 		devfs_clear_cdevpriv();
1171 	td->td_fpop = fpop;
1172 
1173 	vn_lock(vp, vlocked | LK_RETRY);
1174 	dev_relthread(dev, ref);
1175 	if (error != 0) {
1176 		if (error == ERESTART)
1177 			error = EINTR;
1178 		return (error);
1179 	}
1180 
1181 #if 0	/* /dev/console */
1182 	KASSERT(fp != NULL, ("Could not vnode bypass device on NULL fp"));
1183 #else
1184 	if (fp == NULL)
1185 		return (error);
1186 #endif
1187 	if (fp->f_ops == &badfileops)
1188 		finit(fp, fp->f_flag, DTYPE_VNODE, dev, &devfs_ops_f);
1189 	return (error);
1190 }
1191 
1192 static int
1193 devfs_pathconf(struct vop_pathconf_args *ap)
1194 {
1195 
1196 	switch (ap->a_name) {
1197 	case _PC_FILESIZEBITS:
1198 		*ap->a_retval = 64;
1199 		return (0);
1200 	case _PC_NAME_MAX:
1201 		*ap->a_retval = NAME_MAX;
1202 		return (0);
1203 	case _PC_LINK_MAX:
1204 		*ap->a_retval = INT_MAX;
1205 		return (0);
1206 	case _PC_SYMLINK_MAX:
1207 		*ap->a_retval = MAXPATHLEN;
1208 		return (0);
1209 	case _PC_MAX_CANON:
1210 		if (ap->a_vp->v_vflag & VV_ISTTY) {
1211 			*ap->a_retval = MAX_CANON;
1212 			return (0);
1213 		}
1214 		return (EINVAL);
1215 	case _PC_MAX_INPUT:
1216 		if (ap->a_vp->v_vflag & VV_ISTTY) {
1217 			*ap->a_retval = MAX_INPUT;
1218 			return (0);
1219 		}
1220 		return (EINVAL);
1221 	case _PC_VDISABLE:
1222 		if (ap->a_vp->v_vflag & VV_ISTTY) {
1223 			*ap->a_retval = _POSIX_VDISABLE;
1224 			return (0);
1225 		}
1226 		return (EINVAL);
1227 	case _PC_MAC_PRESENT:
1228 #ifdef MAC
1229 		/*
1230 		 * If MAC is enabled, devfs automatically supports
1231 		 * trivial non-persistant label storage.
1232 		 */
1233 		*ap->a_retval = 1;
1234 #else
1235 		*ap->a_retval = 0;
1236 #endif
1237 		return (0);
1238 	case _PC_CHOWN_RESTRICTED:
1239 		*ap->a_retval = 1;
1240 		return (0);
1241 	default:
1242 		return (vop_stdpathconf(ap));
1243 	}
1244 	/* NOTREACHED */
1245 }
1246 
1247 /* ARGSUSED */
1248 static int
1249 devfs_poll_f(struct file *fp, int events, struct ucred *cred, struct thread *td)
1250 {
1251 	struct cdev *dev;
1252 	struct cdevsw *dsw;
1253 	int error, ref;
1254 	struct file *fpop;
1255 
1256 	fpop = td->td_fpop;
1257 	error = devfs_fp_check(fp, &dev, &dsw, &ref);
1258 	if (error != 0) {
1259 		error = vnops.fo_poll(fp, events, cred, td);
1260 		return (error);
1261 	}
1262 	error = dsw->d_poll(dev, events, td);
1263 	td->td_fpop = fpop;
1264 	dev_relthread(dev, ref);
1265 	return(error);
1266 }
1267 
1268 /*
1269  * Print out the contents of a special device vnode.
1270  */
1271 static int
1272 devfs_print(struct vop_print_args *ap)
1273 {
1274 
1275 	printf("\tdev %s\n", devtoname(ap->a_vp->v_rdev));
1276 	return (0);
1277 }
1278 
1279 static int
1280 devfs_read_f(struct file *fp, struct uio *uio, struct ucred *cred,
1281     int flags, struct thread *td)
1282 {
1283 	struct cdev *dev;
1284 	int ioflag, error, ref;
1285 	ssize_t resid;
1286 	struct cdevsw *dsw;
1287 	struct file *fpop;
1288 
1289 	if (uio->uio_resid > DEVFS_IOSIZE_MAX)
1290 		return (EINVAL);
1291 	fpop = td->td_fpop;
1292 	error = devfs_fp_check(fp, &dev, &dsw, &ref);
1293 	if (error != 0) {
1294 		error = vnops.fo_read(fp, uio, cred, flags, td);
1295 		return (error);
1296 	}
1297 	resid = uio->uio_resid;
1298 	ioflag = fp->f_flag & (O_NONBLOCK | O_DIRECT);
1299 	if (ioflag & O_DIRECT)
1300 		ioflag |= IO_DIRECT;
1301 
1302 	foffset_lock_uio(fp, uio, flags | FOF_NOLOCK);
1303 	error = dsw->d_read(dev, uio, ioflag);
1304 	if (uio->uio_resid != resid || (error == 0 && resid != 0))
1305 		devfs_timestamp(&dev->si_atime);
1306 	td->td_fpop = fpop;
1307 	dev_relthread(dev, ref);
1308 
1309 	foffset_unlock_uio(fp, uio, flags | FOF_NOLOCK | FOF_NEXTOFF_R);
1310 	return (error);
1311 }
1312 
1313 static int
1314 devfs_readdir(struct vop_readdir_args *ap)
1315 {
1316 	int error;
1317 	struct uio *uio;
1318 	struct dirent *dp;
1319 	struct devfs_dirent *dd;
1320 	struct devfs_dirent *de;
1321 	struct devfs_mount *dmp;
1322 	off_t off;
1323 	int *tmp_ncookies = NULL;
1324 
1325 	if (ap->a_vp->v_type != VDIR)
1326 		return (ENOTDIR);
1327 
1328 	uio = ap->a_uio;
1329 	if (uio->uio_offset < 0)
1330 		return (EINVAL);
1331 
1332 	/*
1333 	 * XXX: This is a temporary hack to get around this filesystem not
1334 	 * supporting cookies. We store the location of the ncookies pointer
1335 	 * in a temporary variable before calling vfs_subr.c:vfs_read_dirent()
1336 	 * and set the number of cookies to 0. We then set the pointer to
1337 	 * NULL so that vfs_read_dirent doesn't try to call realloc() on
1338 	 * ap->a_cookies. Later in this function, we restore the ap->a_ncookies
1339 	 * pointer to its original location before returning to the caller.
1340 	 */
1341 	if (ap->a_ncookies != NULL) {
1342 		tmp_ncookies = ap->a_ncookies;
1343 		*ap->a_ncookies = 0;
1344 		ap->a_ncookies = NULL;
1345 	}
1346 
1347 	dmp = VFSTODEVFS(ap->a_vp->v_mount);
1348 	if (devfs_populate_vp(ap->a_vp) != 0) {
1349 		if (tmp_ncookies != NULL)
1350 			ap->a_ncookies = tmp_ncookies;
1351 		return (EIO);
1352 	}
1353 	error = 0;
1354 	de = ap->a_vp->v_data;
1355 	off = 0;
1356 	TAILQ_FOREACH(dd, &de->de_dlist, de_list) {
1357 		KASSERT(dd->de_cdp != (void *)0xdeadc0de, ("%s %d\n", __func__, __LINE__));
1358 		if (dd->de_flags & (DE_COVERED | DE_WHITEOUT))
1359 			continue;
1360 		if (devfs_prison_check(dd, uio->uio_td))
1361 			continue;
1362 		if (dd->de_dirent->d_type == DT_DIR)
1363 			de = dd->de_dir;
1364 		else
1365 			de = dd;
1366 		dp = dd->de_dirent;
1367 		MPASS(dp->d_reclen == GENERIC_DIRSIZ(dp));
1368 		if (dp->d_reclen > uio->uio_resid)
1369 			break;
1370 		dp->d_fileno = de->de_inode;
1371 		/* NOTE: d_off is the offset for the *next* entry. */
1372 		dp->d_off = off + dp->d_reclen;
1373 		if (off >= uio->uio_offset) {
1374 			error = vfs_read_dirent(ap, dp, off);
1375 			if (error)
1376 				break;
1377 		}
1378 		off += dp->d_reclen;
1379 	}
1380 	sx_xunlock(&dmp->dm_lock);
1381 	uio->uio_offset = off;
1382 
1383 	/*
1384 	 * Restore ap->a_ncookies if it wasn't originally NULL in the first
1385 	 * place.
1386 	 */
1387 	if (tmp_ncookies != NULL)
1388 		ap->a_ncookies = tmp_ncookies;
1389 
1390 	return (error);
1391 }
1392 
1393 static int
1394 devfs_readlink(struct vop_readlink_args *ap)
1395 {
1396 	struct devfs_dirent *de;
1397 
1398 	de = ap->a_vp->v_data;
1399 	return (uiomove(de->de_symlink, strlen(de->de_symlink), ap->a_uio));
1400 }
1401 
1402 static int
1403 devfs_reclaim(struct vop_reclaim_args *ap)
1404 {
1405 	struct vnode *vp;
1406 	struct devfs_dirent *de;
1407 
1408 	vp = ap->a_vp;
1409 	mtx_lock(&devfs_de_interlock);
1410 	de = vp->v_data;
1411 	if (de != NULL) {
1412 		de->de_vnode = NULL;
1413 		vp->v_data = NULL;
1414 	}
1415 	mtx_unlock(&devfs_de_interlock);
1416 	return (0);
1417 }
1418 
1419 static int
1420 devfs_reclaim_vchr(struct vop_reclaim_args *ap)
1421 {
1422 	struct vnode *vp;
1423 	struct cdev *dev;
1424 
1425 	vp = ap->a_vp;
1426 	MPASS(vp->v_type == VCHR);
1427 
1428 	devfs_reclaim(ap);
1429 
1430 	VI_LOCK(vp);
1431 	dev_lock();
1432 	dev = vp->v_rdev;
1433 	vp->v_rdev = NULL;
1434 	if (dev != NULL)
1435 		dev->si_usecount -= (vp->v_usecount > 0);
1436 	dev_unlock();
1437 	VI_UNLOCK(vp);
1438 	if (dev != NULL)
1439 		dev_rel(dev);
1440 	return (0);
1441 }
1442 
1443 static int
1444 devfs_remove(struct vop_remove_args *ap)
1445 {
1446 	struct vnode *dvp = ap->a_dvp;
1447 	struct vnode *vp = ap->a_vp;
1448 	struct devfs_dirent *dd;
1449 	struct devfs_dirent *de, *de_covered;
1450 	struct devfs_mount *dmp = VFSTODEVFS(vp->v_mount);
1451 
1452 	ASSERT_VOP_ELOCKED(dvp, "devfs_remove");
1453 	ASSERT_VOP_ELOCKED(vp, "devfs_remove");
1454 
1455 	sx_xlock(&dmp->dm_lock);
1456 	dd = ap->a_dvp->v_data;
1457 	de = vp->v_data;
1458 	if (de->de_cdp == NULL) {
1459 		TAILQ_REMOVE(&dd->de_dlist, de, de_list);
1460 		if (de->de_dirent->d_type == DT_LNK) {
1461 			de_covered = devfs_find(dd, de->de_dirent->d_name,
1462 			    de->de_dirent->d_namlen, 0);
1463 			if (de_covered != NULL)
1464 				de_covered->de_flags &= ~DE_COVERED;
1465 		}
1466 		/* We need to unlock dvp because devfs_delete() may lock it. */
1467 		VOP_UNLOCK(vp);
1468 		if (dvp != vp)
1469 			VOP_UNLOCK(dvp);
1470 		devfs_delete(dmp, de, 0);
1471 		sx_xunlock(&dmp->dm_lock);
1472 		if (dvp != vp)
1473 			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
1474 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1475 	} else {
1476 		de->de_flags |= DE_WHITEOUT;
1477 		sx_xunlock(&dmp->dm_lock);
1478 	}
1479 	return (0);
1480 }
1481 
1482 /*
1483  * Revoke is called on a tty when a terminal session ends.  The vnode
1484  * is orphaned by setting v_op to deadfs so we need to let go of it
1485  * as well so that we create a new one next time around.
1486  *
1487  */
1488 static int
1489 devfs_revoke(struct vop_revoke_args *ap)
1490 {
1491 	struct vnode *vp = ap->a_vp, *vp2;
1492 	struct cdev *dev;
1493 	struct cdev_priv *cdp;
1494 	struct devfs_dirent *de;
1495 	u_int i;
1496 
1497 	KASSERT((ap->a_flags & REVOKEALL) != 0, ("devfs_revoke !REVOKEALL"));
1498 
1499 	dev = vp->v_rdev;
1500 	cdp = cdev2priv(dev);
1501 
1502 	dev_lock();
1503 	cdp->cdp_inuse++;
1504 	dev_unlock();
1505 
1506 	vhold(vp);
1507 	vgone(vp);
1508 	vdrop(vp);
1509 
1510 	VOP_UNLOCK(vp);
1511  loop:
1512 	for (;;) {
1513 		mtx_lock(&devfs_de_interlock);
1514 		dev_lock();
1515 		vp2 = NULL;
1516 		for (i = 0; i <= cdp->cdp_maxdirent; i++) {
1517 			de = cdp->cdp_dirents[i];
1518 			if (de == NULL)
1519 				continue;
1520 
1521 			vp2 = de->de_vnode;
1522 			if (vp2 != NULL) {
1523 				dev_unlock();
1524 				VI_LOCK(vp2);
1525 				mtx_unlock(&devfs_de_interlock);
1526 				if (vget(vp2, LK_EXCLUSIVE | LK_INTERLOCK,
1527 				    curthread))
1528 					goto loop;
1529 				vhold(vp2);
1530 				vgone(vp2);
1531 				vdrop(vp2);
1532 				vput(vp2);
1533 				break;
1534 			}
1535 		}
1536 		if (vp2 != NULL) {
1537 			continue;
1538 		}
1539 		dev_unlock();
1540 		mtx_unlock(&devfs_de_interlock);
1541 		break;
1542 	}
1543 	dev_lock();
1544 	cdp->cdp_inuse--;
1545 	if (!(cdp->cdp_flags & CDP_ACTIVE) && cdp->cdp_inuse == 0) {
1546 		TAILQ_REMOVE(&cdevp_list, cdp, cdp_list);
1547 		dev_unlock();
1548 		dev_rel(&cdp->cdp_c);
1549 	} else
1550 		dev_unlock();
1551 
1552 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1553 	return (0);
1554 }
1555 
1556 static int
1557 devfs_rioctl(struct vop_ioctl_args *ap)
1558 {
1559 	struct vnode *vp;
1560 	struct devfs_mount *dmp;
1561 	int error;
1562 
1563 	vp = ap->a_vp;
1564 	vn_lock(vp, LK_SHARED | LK_RETRY);
1565 	if (VN_IS_DOOMED(vp)) {
1566 		VOP_UNLOCK(vp);
1567 		return (EBADF);
1568 	}
1569 	dmp = VFSTODEVFS(vp->v_mount);
1570 	sx_xlock(&dmp->dm_lock);
1571 	VOP_UNLOCK(vp);
1572 	DEVFS_DMP_HOLD(dmp);
1573 	devfs_populate(dmp);
1574 	if (DEVFS_DMP_DROP(dmp)) {
1575 		sx_xunlock(&dmp->dm_lock);
1576 		devfs_unmount_final(dmp);
1577 		return (ENOENT);
1578 	}
1579 	error = devfs_rules_ioctl(dmp, ap->a_command, ap->a_data, ap->a_td);
1580 	sx_xunlock(&dmp->dm_lock);
1581 	return (error);
1582 }
1583 
1584 static int
1585 devfs_rread(struct vop_read_args *ap)
1586 {
1587 
1588 	if (ap->a_vp->v_type != VDIR)
1589 		return (EINVAL);
1590 	return (VOP_READDIR(ap->a_vp, ap->a_uio, ap->a_cred, NULL, NULL, NULL));
1591 }
1592 
1593 static int
1594 devfs_setattr(struct vop_setattr_args *ap)
1595 {
1596 	struct devfs_dirent *de;
1597 	struct vattr *vap;
1598 	struct vnode *vp;
1599 	struct thread *td;
1600 	int c, error;
1601 	uid_t uid;
1602 	gid_t gid;
1603 
1604 	vap = ap->a_vap;
1605 	vp = ap->a_vp;
1606 	td = curthread;
1607 	if ((vap->va_type != VNON) ||
1608 	    (vap->va_nlink != VNOVAL) ||
1609 	    (vap->va_fsid != VNOVAL) ||
1610 	    (vap->va_fileid != VNOVAL) ||
1611 	    (vap->va_blocksize != VNOVAL) ||
1612 	    (vap->va_flags != VNOVAL && vap->va_flags != 0) ||
1613 	    (vap->va_rdev != VNOVAL) ||
1614 	    ((int)vap->va_bytes != VNOVAL) ||
1615 	    (vap->va_gen != VNOVAL)) {
1616 		return (EINVAL);
1617 	}
1618 
1619 	error = devfs_populate_vp(vp);
1620 	if (error != 0)
1621 		return (error);
1622 
1623 	de = vp->v_data;
1624 	if (vp->v_type == VDIR)
1625 		de = de->de_dir;
1626 
1627 	c = 0;
1628 	if (vap->va_uid == (uid_t)VNOVAL)
1629 		uid = de->de_uid;
1630 	else
1631 		uid = vap->va_uid;
1632 	if (vap->va_gid == (gid_t)VNOVAL)
1633 		gid = de->de_gid;
1634 	else
1635 		gid = vap->va_gid;
1636 	if (uid != de->de_uid || gid != de->de_gid) {
1637 		if ((ap->a_cred->cr_uid != de->de_uid) || uid != de->de_uid ||
1638 		    (gid != de->de_gid && !groupmember(gid, ap->a_cred))) {
1639 			error = priv_check(td, PRIV_VFS_CHOWN);
1640 			if (error != 0)
1641 				goto ret;
1642 		}
1643 		de->de_uid = uid;
1644 		de->de_gid = gid;
1645 		c = 1;
1646 	}
1647 
1648 	if (vap->va_mode != (mode_t)VNOVAL) {
1649 		if (ap->a_cred->cr_uid != de->de_uid) {
1650 			error = priv_check(td, PRIV_VFS_ADMIN);
1651 			if (error != 0)
1652 				goto ret;
1653 		}
1654 		de->de_mode = vap->va_mode;
1655 		c = 1;
1656 	}
1657 
1658 	if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
1659 		error = vn_utimes_perm(vp, vap, ap->a_cred, td);
1660 		if (error != 0)
1661 			goto ret;
1662 		if (vap->va_atime.tv_sec != VNOVAL) {
1663 			if (vp->v_type == VCHR)
1664 				vp->v_rdev->si_atime = vap->va_atime;
1665 			else
1666 				de->de_atime = vap->va_atime;
1667 		}
1668 		if (vap->va_mtime.tv_sec != VNOVAL) {
1669 			if (vp->v_type == VCHR)
1670 				vp->v_rdev->si_mtime = vap->va_mtime;
1671 			else
1672 				de->de_mtime = vap->va_mtime;
1673 		}
1674 		c = 1;
1675 	}
1676 
1677 	if (c) {
1678 		if (vp->v_type == VCHR)
1679 			vfs_timestamp(&vp->v_rdev->si_ctime);
1680 		else
1681 			vfs_timestamp(&de->de_mtime);
1682 	}
1683 
1684 ret:
1685 	sx_xunlock(&VFSTODEVFS(vp->v_mount)->dm_lock);
1686 	return (error);
1687 }
1688 
1689 #ifdef MAC
1690 static int
1691 devfs_setlabel(struct vop_setlabel_args *ap)
1692 {
1693 	struct vnode *vp;
1694 	struct devfs_dirent *de;
1695 
1696 	vp = ap->a_vp;
1697 	de = vp->v_data;
1698 
1699 	mac_vnode_relabel(ap->a_cred, vp, ap->a_label);
1700 	mac_devfs_update(vp->v_mount, de, vp);
1701 
1702 	return (0);
1703 }
1704 #endif
1705 
1706 static int
1707 devfs_stat_f(struct file *fp, struct stat *sb, struct ucred *cred, struct thread *td)
1708 {
1709 
1710 	return (vnops.fo_stat(fp, sb, cred, td));
1711 }
1712 
1713 static int
1714 devfs_symlink(struct vop_symlink_args *ap)
1715 {
1716 	int i, error;
1717 	struct devfs_dirent *dd;
1718 	struct devfs_dirent *de, *de_covered, *de_dotdot;
1719 	struct devfs_mount *dmp;
1720 
1721 	error = priv_check(curthread, PRIV_DEVFS_SYMLINK);
1722 	if (error)
1723 		return(error);
1724 	dmp = VFSTODEVFS(ap->a_dvp->v_mount);
1725 	if (devfs_populate_vp(ap->a_dvp) != 0)
1726 		return (ENOENT);
1727 
1728 	dd = ap->a_dvp->v_data;
1729 	de = devfs_newdirent(ap->a_cnp->cn_nameptr, ap->a_cnp->cn_namelen);
1730 	de->de_flags = DE_USER;
1731 	de->de_uid = 0;
1732 	de->de_gid = 0;
1733 	de->de_mode = 0755;
1734 	de->de_inode = alloc_unr(devfs_inos);
1735 	de->de_dir = dd;
1736 	de->de_dirent->d_type = DT_LNK;
1737 	i = strlen(ap->a_target) + 1;
1738 	de->de_symlink = malloc(i, M_DEVFS, M_WAITOK);
1739 	bcopy(ap->a_target, de->de_symlink, i);
1740 #ifdef MAC
1741 	mac_devfs_create_symlink(ap->a_cnp->cn_cred, dmp->dm_mount, dd, de);
1742 #endif
1743 	de_covered = devfs_find(dd, de->de_dirent->d_name,
1744 	    de->de_dirent->d_namlen, 0);
1745 	if (de_covered != NULL) {
1746 		if ((de_covered->de_flags & DE_USER) != 0) {
1747 			devfs_delete(dmp, de, DEVFS_DEL_NORECURSE);
1748 			sx_xunlock(&dmp->dm_lock);
1749 			return (EEXIST);
1750 		}
1751 		KASSERT((de_covered->de_flags & DE_COVERED) == 0,
1752 		    ("devfs_symlink: entry %p already covered", de_covered));
1753 		de_covered->de_flags |= DE_COVERED;
1754 	}
1755 
1756 	de_dotdot = TAILQ_FIRST(&dd->de_dlist);		/* "." */
1757 	de_dotdot = TAILQ_NEXT(de_dotdot, de_list);	/* ".." */
1758 	TAILQ_INSERT_AFTER(&dd->de_dlist, de_dotdot, de, de_list);
1759 	devfs_dir_ref_de(dmp, dd);
1760 	devfs_rules_apply(dmp, de);
1761 
1762 	return (devfs_allocv(de, ap->a_dvp->v_mount, LK_EXCLUSIVE, ap->a_vpp));
1763 }
1764 
1765 static int
1766 devfs_truncate_f(struct file *fp, off_t length, struct ucred *cred, struct thread *td)
1767 {
1768 
1769 	return (vnops.fo_truncate(fp, length, cred, td));
1770 }
1771 
1772 static int
1773 devfs_write_f(struct file *fp, struct uio *uio, struct ucred *cred,
1774     int flags, struct thread *td)
1775 {
1776 	struct cdev *dev;
1777 	int error, ioflag, ref;
1778 	ssize_t resid;
1779 	struct cdevsw *dsw;
1780 	struct file *fpop;
1781 
1782 	if (uio->uio_resid > DEVFS_IOSIZE_MAX)
1783 		return (EINVAL);
1784 	fpop = td->td_fpop;
1785 	error = devfs_fp_check(fp, &dev, &dsw, &ref);
1786 	if (error != 0) {
1787 		error = vnops.fo_write(fp, uio, cred, flags, td);
1788 		return (error);
1789 	}
1790 	KASSERT(uio->uio_td == td, ("uio_td %p is not td %p", uio->uio_td, td));
1791 	ioflag = fp->f_flag & (O_NONBLOCK | O_DIRECT | O_FSYNC);
1792 	if (ioflag & O_DIRECT)
1793 		ioflag |= IO_DIRECT;
1794 	foffset_lock_uio(fp, uio, flags | FOF_NOLOCK);
1795 
1796 	resid = uio->uio_resid;
1797 
1798 	error = dsw->d_write(dev, uio, ioflag);
1799 	if (uio->uio_resid != resid || (error == 0 && resid != 0)) {
1800 		devfs_timestamp(&dev->si_ctime);
1801 		dev->si_mtime = dev->si_ctime;
1802 	}
1803 	td->td_fpop = fpop;
1804 	dev_relthread(dev, ref);
1805 
1806 	foffset_unlock_uio(fp, uio, flags | FOF_NOLOCK | FOF_NEXTOFF_W);
1807 	return (error);
1808 }
1809 
1810 static int
1811 devfs_mmap_f(struct file *fp, vm_map_t map, vm_offset_t *addr, vm_size_t size,
1812     vm_prot_t prot, vm_prot_t cap_maxprot, int flags, vm_ooffset_t foff,
1813     struct thread *td)
1814 {
1815 	struct cdev *dev;
1816 	struct cdevsw *dsw;
1817 	struct mount *mp;
1818 	struct vnode *vp;
1819 	struct file *fpop;
1820 	vm_object_t object;
1821 	vm_prot_t maxprot;
1822 	int error, ref;
1823 
1824 	vp = fp->f_vnode;
1825 
1826 	/*
1827 	 * Ensure that file and memory protections are
1828 	 * compatible.
1829 	 */
1830 	mp = vp->v_mount;
1831 	if (mp != NULL && (mp->mnt_flag & MNT_NOEXEC) != 0) {
1832 		maxprot = VM_PROT_NONE;
1833 		if ((prot & VM_PROT_EXECUTE) != 0)
1834 			return (EACCES);
1835 	} else
1836 		maxprot = VM_PROT_EXECUTE;
1837 	if ((fp->f_flag & FREAD) != 0)
1838 		maxprot |= VM_PROT_READ;
1839 	else if ((prot & VM_PROT_READ) != 0)
1840 		return (EACCES);
1841 
1842 	/*
1843 	 * If we are sharing potential changes via MAP_SHARED and we
1844 	 * are trying to get write permission although we opened it
1845 	 * without asking for it, bail out.
1846 	 *
1847 	 * Note that most character devices always share mappings.
1848 	 * The one exception is that D_MMAP_ANON devices
1849 	 * (i.e. /dev/zero) permit private writable mappings.
1850 	 *
1851 	 * Rely on vm_mmap_cdev() to fail invalid MAP_PRIVATE requests
1852 	 * as well as updating maxprot to permit writing for
1853 	 * D_MMAP_ANON devices rather than doing that here.
1854 	 */
1855 	if ((flags & MAP_SHARED) != 0) {
1856 		if ((fp->f_flag & FWRITE) != 0)
1857 			maxprot |= VM_PROT_WRITE;
1858 		else if ((prot & VM_PROT_WRITE) != 0)
1859 			return (EACCES);
1860 	}
1861 	maxprot &= cap_maxprot;
1862 
1863 	fpop = td->td_fpop;
1864 	error = devfs_fp_check(fp, &dev, &dsw, &ref);
1865 	if (error != 0)
1866 		return (error);
1867 
1868 	error = vm_mmap_cdev(td, size, prot, &maxprot, &flags, dev, dsw, &foff,
1869 	    &object);
1870 	td->td_fpop = fpop;
1871 	dev_relthread(dev, ref);
1872 	if (error != 0)
1873 		return (error);
1874 
1875 	error = vm_mmap_object(map, addr, size, prot, maxprot, flags, object,
1876 	    foff, FALSE, td);
1877 	if (error != 0)
1878 		vm_object_deallocate(object);
1879 	return (error);
1880 }
1881 
1882 dev_t
1883 dev2udev(struct cdev *x)
1884 {
1885 	if (x == NULL)
1886 		return (NODEV);
1887 	return (cdev2priv(x)->cdp_inode);
1888 }
1889 
1890 static struct fileops devfs_ops_f = {
1891 	.fo_read =	devfs_read_f,
1892 	.fo_write =	devfs_write_f,
1893 	.fo_truncate =	devfs_truncate_f,
1894 	.fo_ioctl =	devfs_ioctl_f,
1895 	.fo_poll =	devfs_poll_f,
1896 	.fo_kqfilter =	devfs_kqfilter_f,
1897 	.fo_stat =	devfs_stat_f,
1898 	.fo_close =	devfs_close_f,
1899 	.fo_chmod =	vn_chmod,
1900 	.fo_chown =	vn_chown,
1901 	.fo_sendfile =	vn_sendfile,
1902 	.fo_seek =	vn_seek,
1903 	.fo_fill_kinfo = vn_fill_kinfo,
1904 	.fo_mmap =	devfs_mmap_f,
1905 	.fo_flags =	DFLAG_PASSABLE | DFLAG_SEEKABLE
1906 };
1907 
1908 /* Vops for non-CHR vnodes in /dev. */
1909 static struct vop_vector devfs_vnodeops = {
1910 	.vop_default =		&default_vnodeops,
1911 
1912 	.vop_access =		devfs_access,
1913 	.vop_getattr =		devfs_getattr,
1914 	.vop_ioctl =		devfs_rioctl,
1915 	.vop_lookup =		devfs_lookup,
1916 	.vop_mknod =		devfs_mknod,
1917 	.vop_pathconf =		devfs_pathconf,
1918 	.vop_read =		devfs_rread,
1919 	.vop_readdir =		devfs_readdir,
1920 	.vop_readlink =		devfs_readlink,
1921 	.vop_reclaim =		devfs_reclaim,
1922 	.vop_remove =		devfs_remove,
1923 	.vop_revoke =		devfs_revoke,
1924 	.vop_setattr =		devfs_setattr,
1925 #ifdef MAC
1926 	.vop_setlabel =		devfs_setlabel,
1927 #endif
1928 	.vop_symlink =		devfs_symlink,
1929 	.vop_vptocnp =		devfs_vptocnp,
1930 };
1931 VFS_VOP_VECTOR_REGISTER(devfs_vnodeops);
1932 
1933 /* Vops for VCHR vnodes in /dev. */
1934 static struct vop_vector devfs_specops = {
1935 	.vop_default =		&default_vnodeops,
1936 
1937 	.vop_access =		devfs_access,
1938 	.vop_bmap =		VOP_PANIC,
1939 	.vop_close =		devfs_close,
1940 	.vop_create =		VOP_PANIC,
1941 	.vop_fsync =		vop_stdfsync,
1942 	.vop_getattr =		devfs_getattr,
1943 	.vop_ioctl =		devfs_ioctl,
1944 	.vop_link =		VOP_PANIC,
1945 	.vop_mkdir =		VOP_PANIC,
1946 	.vop_mknod =		VOP_PANIC,
1947 	.vop_open =		devfs_open,
1948 	.vop_pathconf =		devfs_pathconf,
1949 	.vop_poll =		dead_poll,
1950 	.vop_print =		devfs_print,
1951 	.vop_read =		dead_read,
1952 	.vop_readdir =		VOP_PANIC,
1953 	.vop_readlink =		VOP_PANIC,
1954 	.vop_reallocblks =	VOP_PANIC,
1955 	.vop_reclaim =		devfs_reclaim_vchr,
1956 	.vop_remove =		devfs_remove,
1957 	.vop_rename =		VOP_PANIC,
1958 	.vop_revoke =		devfs_revoke,
1959 	.vop_rmdir =		VOP_PANIC,
1960 	.vop_setattr =		devfs_setattr,
1961 #ifdef MAC
1962 	.vop_setlabel =		devfs_setlabel,
1963 #endif
1964 	.vop_strategy =		VOP_PANIC,
1965 	.vop_symlink =		VOP_PANIC,
1966 	.vop_vptocnp =		devfs_vptocnp,
1967 	.vop_write =		dead_write,
1968 };
1969 VFS_VOP_VECTOR_REGISTER(devfs_specops);
1970 
1971 /*
1972  * Our calling convention to the device drivers used to be that we passed
1973  * vnode.h IO_* flags to read()/write(), but we're moving to fcntl.h O_
1974  * flags instead since that's what open(), close() and ioctl() takes and
1975  * we don't really want vnode.h in device drivers.
1976  * We solved the source compatibility by redefining some vnode flags to
1977  * be the same as the fcntl ones and by sending down the bitwise OR of
1978  * the respective fcntl/vnode flags.  These CTASSERTS make sure nobody
1979  * pulls the rug out under this.
1980  */
1981 CTASSERT(O_NONBLOCK == IO_NDELAY);
1982 CTASSERT(O_FSYNC == IO_SYNC);
1983