xref: /freebsd/sys/kern/vfs_default.c (revision a96ef4501919d7ac08e94e98dc34b0bdd744802b)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1989, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed
8  * to Berkeley by John Heidemann of the UCLA Ficus project.
9  *
10  * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
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. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  * 3. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  */
36 
37 #include <sys/cdefs.h>
38 __FBSDID("$FreeBSD$");
39 
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/bio.h>
43 #include <sys/buf.h>
44 #include <sys/conf.h>
45 #include <sys/event.h>
46 #include <sys/filio.h>
47 #include <sys/kernel.h>
48 #include <sys/limits.h>
49 #include <sys/lock.h>
50 #include <sys/lockf.h>
51 #include <sys/malloc.h>
52 #include <sys/mount.h>
53 #include <sys/namei.h>
54 #include <sys/rwlock.h>
55 #include <sys/fcntl.h>
56 #include <sys/unistd.h>
57 #include <sys/vnode.h>
58 #include <sys/dirent.h>
59 #include <sys/poll.h>
60 #include <sys/stat.h>
61 #include <security/audit/audit.h>
62 #include <sys/priv.h>
63 
64 #include <security/mac/mac_framework.h>
65 
66 #include <vm/vm.h>
67 #include <vm/vm_object.h>
68 #include <vm/vm_extern.h>
69 #include <vm/pmap.h>
70 #include <vm/vm_map.h>
71 #include <vm/vm_page.h>
72 #include <vm/vm_pager.h>
73 #include <vm/vnode_pager.h>
74 
75 static int	vop_nolookup(struct vop_lookup_args *);
76 static int	vop_norename(struct vop_rename_args *);
77 static int	vop_nostrategy(struct vop_strategy_args *);
78 static int	get_next_dirent(struct vnode *vp, struct dirent **dpp,
79 				char *dirbuf, int dirbuflen, off_t *off,
80 				char **cpos, int *len, int *eofflag,
81 				struct thread *td);
82 static int	dirent_exists(struct vnode *vp, const char *dirname,
83 			      struct thread *td);
84 
85 #define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4)
86 
87 static int vop_stdis_text(struct vop_is_text_args *ap);
88 static int vop_stdunset_text(struct vop_unset_text_args *ap);
89 static int vop_stdadd_writecount(struct vop_add_writecount_args *ap);
90 static int vop_stdcopy_file_range(struct vop_copy_file_range_args *ap);
91 static int vop_stdfdatasync(struct vop_fdatasync_args *ap);
92 static int vop_stdgetpages_async(struct vop_getpages_async_args *ap);
93 static int vop_stdread_pgcache(struct vop_read_pgcache_args *ap);
94 static int vop_stdstat(struct vop_stat_args *ap);
95 static int vop_stdvput_pair(struct vop_vput_pair_args *ap);
96 
97 /*
98  * This vnode table stores what we want to do if the filesystem doesn't
99  * implement a particular VOP.
100  *
101  * If there is no specific entry here, we will return EOPNOTSUPP.
102  *
103  * Note that every filesystem has to implement either vop_access
104  * or vop_accessx; failing to do so will result in immediate crash
105  * due to stack overflow, as vop_stdaccess() calls vop_stdaccessx(),
106  * which calls vop_stdaccess() etc.
107  */
108 
109 struct vop_vector default_vnodeops = {
110 	.vop_default =		NULL,
111 	.vop_bypass =		VOP_EOPNOTSUPP,
112 
113 	.vop_access =		vop_stdaccess,
114 	.vop_accessx =		vop_stdaccessx,
115 	.vop_advise =		vop_stdadvise,
116 	.vop_advlock =		vop_stdadvlock,
117 	.vop_advlockasync =	vop_stdadvlockasync,
118 	.vop_advlockpurge =	vop_stdadvlockpurge,
119 	.vop_allocate =		vop_stdallocate,
120 	.vop_bmap =		vop_stdbmap,
121 	.vop_close =		VOP_NULL,
122 	.vop_fsync =		VOP_NULL,
123 	.vop_stat =		vop_stdstat,
124 	.vop_fdatasync =	vop_stdfdatasync,
125 	.vop_getpages =		vop_stdgetpages,
126 	.vop_getpages_async =	vop_stdgetpages_async,
127 	.vop_getwritemount = 	vop_stdgetwritemount,
128 	.vop_inactive =		VOP_NULL,
129 	.vop_need_inactive =	vop_stdneed_inactive,
130 	.vop_ioctl =		vop_stdioctl,
131 	.vop_kqfilter =		vop_stdkqfilter,
132 	.vop_islocked =		vop_stdislocked,
133 	.vop_lock1 =		vop_stdlock,
134 	.vop_lookup =		vop_nolookup,
135 	.vop_open =		VOP_NULL,
136 	.vop_pathconf =		VOP_EINVAL,
137 	.vop_poll =		vop_nopoll,
138 	.vop_putpages =		vop_stdputpages,
139 	.vop_readlink =		VOP_EINVAL,
140 	.vop_read_pgcache =	vop_stdread_pgcache,
141 	.vop_rename =		vop_norename,
142 	.vop_revoke =		VOP_PANIC,
143 	.vop_strategy =		vop_nostrategy,
144 	.vop_unlock =		vop_stdunlock,
145 	.vop_vptocnp =		vop_stdvptocnp,
146 	.vop_vptofh =		vop_stdvptofh,
147 	.vop_unp_bind =		vop_stdunp_bind,
148 	.vop_unp_connect =	vop_stdunp_connect,
149 	.vop_unp_detach =	vop_stdunp_detach,
150 	.vop_is_text =		vop_stdis_text,
151 	.vop_set_text =		vop_stdset_text,
152 	.vop_unset_text =	vop_stdunset_text,
153 	.vop_add_writecount =	vop_stdadd_writecount,
154 	.vop_copy_file_range =	vop_stdcopy_file_range,
155 	.vop_vput_pair =	vop_stdvput_pair,
156 };
157 VFS_VOP_VECTOR_REGISTER(default_vnodeops);
158 
159 /*
160  * Series of placeholder functions for various error returns for
161  * VOPs.
162  */
163 
164 int
165 vop_eopnotsupp(struct vop_generic_args *ap)
166 {
167 	/*
168 	printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name);
169 	*/
170 
171 	return (EOPNOTSUPP);
172 }
173 
174 int
175 vop_ebadf(struct vop_generic_args *ap)
176 {
177 
178 	return (EBADF);
179 }
180 
181 int
182 vop_enotty(struct vop_generic_args *ap)
183 {
184 
185 	return (ENOTTY);
186 }
187 
188 int
189 vop_einval(struct vop_generic_args *ap)
190 {
191 
192 	return (EINVAL);
193 }
194 
195 int
196 vop_enoent(struct vop_generic_args *ap)
197 {
198 
199 	return (ENOENT);
200 }
201 
202 int
203 vop_eagain(struct vop_generic_args *ap)
204 {
205 
206 	return (EAGAIN);
207 }
208 
209 int
210 vop_null(struct vop_generic_args *ap)
211 {
212 
213 	return (0);
214 }
215 
216 /*
217  * Helper function to panic on some bad VOPs in some filesystems.
218  */
219 int
220 vop_panic(struct vop_generic_args *ap)
221 {
222 
223 	panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
224 }
225 
226 /*
227  * vop_std<something> and vop_no<something> are default functions for use by
228  * filesystems that need the "default reasonable" implementation for a
229  * particular operation.
230  *
231  * The documentation for the operations they implement exists (if it exists)
232  * in the VOP_<SOMETHING>(9) manpage (all uppercase).
233  */
234 
235 /*
236  * Default vop for filesystems that do not support name lookup
237  */
238 static int
239 vop_nolookup(ap)
240 	struct vop_lookup_args /* {
241 		struct vnode *a_dvp;
242 		struct vnode **a_vpp;
243 		struct componentname *a_cnp;
244 	} */ *ap;
245 {
246 
247 	*ap->a_vpp = NULL;
248 	return (ENOTDIR);
249 }
250 
251 /*
252  * vop_norename:
253  *
254  * Handle unlock and reference counting for arguments of vop_rename
255  * for filesystems that do not implement rename operation.
256  */
257 static int
258 vop_norename(struct vop_rename_args *ap)
259 {
260 
261 	vop_rename_fail(ap);
262 	return (EOPNOTSUPP);
263 }
264 
265 /*
266  *	vop_nostrategy:
267  *
268  *	Strategy routine for VFS devices that have none.
269  *
270  *	BIO_ERROR and B_INVAL must be cleared prior to calling any strategy
271  *	routine.  Typically this is done for a BIO_READ strategy call.
272  *	Typically B_INVAL is assumed to already be clear prior to a write
273  *	and should not be cleared manually unless you just made the buffer
274  *	invalid.  BIO_ERROR should be cleared either way.
275  */
276 
277 static int
278 vop_nostrategy (struct vop_strategy_args *ap)
279 {
280 	printf("No strategy for buffer at %p\n", ap->a_bp);
281 	vn_printf(ap->a_vp, "vnode ");
282 	ap->a_bp->b_ioflags |= BIO_ERROR;
283 	ap->a_bp->b_error = EOPNOTSUPP;
284 	bufdone(ap->a_bp);
285 	return (EOPNOTSUPP);
286 }
287 
288 static int
289 get_next_dirent(struct vnode *vp, struct dirent **dpp, char *dirbuf,
290 		int dirbuflen, off_t *off, char **cpos, int *len,
291 		int *eofflag, struct thread *td)
292 {
293 	int error, reclen;
294 	struct uio uio;
295 	struct iovec iov;
296 	struct dirent *dp;
297 
298 	KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
299 	KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
300 
301 	if (*len == 0) {
302 		iov.iov_base = dirbuf;
303 		iov.iov_len = dirbuflen;
304 
305 		uio.uio_iov = &iov;
306 		uio.uio_iovcnt = 1;
307 		uio.uio_offset = *off;
308 		uio.uio_resid = dirbuflen;
309 		uio.uio_segflg = UIO_SYSSPACE;
310 		uio.uio_rw = UIO_READ;
311 		uio.uio_td = td;
312 
313 		*eofflag = 0;
314 
315 #ifdef MAC
316 		error = mac_vnode_check_readdir(td->td_ucred, vp);
317 		if (error == 0)
318 #endif
319 			error = VOP_READDIR(vp, &uio, td->td_ucred, eofflag,
320 		    		NULL, NULL);
321 		if (error)
322 			return (error);
323 
324 		*off = uio.uio_offset;
325 
326 		*cpos = dirbuf;
327 		*len = (dirbuflen - uio.uio_resid);
328 
329 		if (*len == 0)
330 			return (ENOENT);
331 	}
332 
333 	dp = (struct dirent *)(*cpos);
334 	reclen = dp->d_reclen;
335 	*dpp = dp;
336 
337 	/* check for malformed directory.. */
338 	if (reclen < DIRENT_MINSIZE)
339 		return (EINVAL);
340 
341 	*cpos += reclen;
342 	*len -= reclen;
343 
344 	return (0);
345 }
346 
347 /*
348  * Check if a named file exists in a given directory vnode.
349  */
350 static int
351 dirent_exists(struct vnode *vp, const char *dirname, struct thread *td)
352 {
353 	char *dirbuf, *cpos;
354 	int error, eofflag, dirbuflen, len, found;
355 	off_t off;
356 	struct dirent *dp;
357 	struct vattr va;
358 
359 	KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
360 	KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
361 
362 	found = 0;
363 
364 	error = VOP_GETATTR(vp, &va, td->td_ucred);
365 	if (error)
366 		return (found);
367 
368 	dirbuflen = DEV_BSIZE;
369 	if (dirbuflen < va.va_blocksize)
370 		dirbuflen = va.va_blocksize;
371 	dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
372 
373 	off = 0;
374 	len = 0;
375 	do {
376 		error = get_next_dirent(vp, &dp, dirbuf, dirbuflen, &off,
377 					&cpos, &len, &eofflag, td);
378 		if (error)
379 			goto out;
380 
381 		if (dp->d_type != DT_WHT && dp->d_fileno != 0 &&
382 		    strcmp(dp->d_name, dirname) == 0) {
383 			found = 1;
384 			goto out;
385 		}
386 	} while (len > 0 || !eofflag);
387 
388 out:
389 	free(dirbuf, M_TEMP);
390 	return (found);
391 }
392 
393 int
394 vop_stdaccess(struct vop_access_args *ap)
395 {
396 
397 	KASSERT((ap->a_accmode & ~(VEXEC | VWRITE | VREAD | VADMIN |
398 	    VAPPEND)) == 0, ("invalid bit in accmode"));
399 
400 	return (VOP_ACCESSX(ap->a_vp, ap->a_accmode, ap->a_cred, ap->a_td));
401 }
402 
403 int
404 vop_stdaccessx(struct vop_accessx_args *ap)
405 {
406 	int error;
407 	accmode_t accmode = ap->a_accmode;
408 
409 	error = vfs_unixify_accmode(&accmode);
410 	if (error != 0)
411 		return (error);
412 
413 	if (accmode == 0)
414 		return (0);
415 
416 	return (VOP_ACCESS(ap->a_vp, accmode, ap->a_cred, ap->a_td));
417 }
418 
419 /*
420  * Advisory record locking support
421  */
422 int
423 vop_stdadvlock(struct vop_advlock_args *ap)
424 {
425 	struct vnode *vp;
426 	struct mount *mp;
427 	struct vattr vattr;
428 	int error;
429 
430 	vp = ap->a_vp;
431 
432 	/*
433 	 * Provide atomicity of open(O_CREAT | O_EXCL | O_EXLOCK) for
434 	 * local filesystems.  See vn_open_cred() for reciprocal part.
435 	 */
436 	mp = vp->v_mount;
437 	if (mp != NULL && (mp->mnt_flag & MNT_LOCAL) != 0 &&
438 	    ap->a_op == F_SETLK && (ap->a_flags & F_FIRSTOPEN) == 0) {
439 		VI_LOCK(vp);
440 		while ((vp->v_iflag & VI_FOPENING) != 0)
441 			msleep(vp, VI_MTX(vp), PLOCK, "lockfo", 0);
442 		VI_UNLOCK(vp);
443 	}
444 
445 	if (ap->a_fl->l_whence == SEEK_END) {
446 		/*
447 		 * The NFSv4 server must avoid doing a vn_lock() here, since it
448 		 * can deadlock the nfsd threads, due to a LOR.  Fortunately
449 		 * the NFSv4 server always uses SEEK_SET and this code is
450 		 * only required for the SEEK_END case.
451 		 */
452 		vn_lock(vp, LK_SHARED | LK_RETRY);
453 		error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
454 		VOP_UNLOCK(vp);
455 		if (error)
456 			return (error);
457 	} else
458 		vattr.va_size = 0;
459 
460 	return (lf_advlock(ap, &(vp->v_lockf), vattr.va_size));
461 }
462 
463 int
464 vop_stdadvlockasync(struct vop_advlockasync_args *ap)
465 {
466 	struct vnode *vp;
467 	struct vattr vattr;
468 	int error;
469 
470 	vp = ap->a_vp;
471 	if (ap->a_fl->l_whence == SEEK_END) {
472 		/* The size argument is only needed for SEEK_END. */
473 		vn_lock(vp, LK_SHARED | LK_RETRY);
474 		error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
475 		VOP_UNLOCK(vp);
476 		if (error)
477 			return (error);
478 	} else
479 		vattr.va_size = 0;
480 
481 	return (lf_advlockasync(ap, &(vp->v_lockf), vattr.va_size));
482 }
483 
484 int
485 vop_stdadvlockpurge(struct vop_advlockpurge_args *ap)
486 {
487 	struct vnode *vp;
488 
489 	vp = ap->a_vp;
490 	lf_purgelocks(vp, &vp->v_lockf);
491 	return (0);
492 }
493 
494 /*
495  * vop_stdpathconf:
496  *
497  * Standard implementation of POSIX pathconf, to get information about limits
498  * for a filesystem.
499  * Override per filesystem for the case where the filesystem has smaller
500  * limits.
501  */
502 int
503 vop_stdpathconf(ap)
504 	struct vop_pathconf_args /* {
505 	struct vnode *a_vp;
506 	int a_name;
507 	int *a_retval;
508 	} */ *ap;
509 {
510 
511 	switch (ap->a_name) {
512 		case _PC_ASYNC_IO:
513 			*ap->a_retval = _POSIX_ASYNCHRONOUS_IO;
514 			return (0);
515 		case _PC_PATH_MAX:
516 			*ap->a_retval = PATH_MAX;
517 			return (0);
518 		case _PC_ACL_EXTENDED:
519 		case _PC_ACL_NFS4:
520 		case _PC_CAP_PRESENT:
521 		case _PC_INF_PRESENT:
522 		case _PC_MAC_PRESENT:
523 			*ap->a_retval = 0;
524 			return (0);
525 		default:
526 			return (EINVAL);
527 	}
528 	/* NOTREACHED */
529 }
530 
531 /*
532  * Standard lock, unlock and islocked functions.
533  */
534 int
535 vop_stdlock(ap)
536 	struct vop_lock1_args /* {
537 		struct vnode *a_vp;
538 		int a_flags;
539 		char *file;
540 		int line;
541 	} */ *ap;
542 {
543 	struct vnode *vp = ap->a_vp;
544 	struct mtx *ilk;
545 
546 	ilk = VI_MTX(vp);
547 	return (lockmgr_lock_flags(vp->v_vnlock, ap->a_flags,
548 	    &ilk->lock_object, ap->a_file, ap->a_line));
549 }
550 
551 /* See above. */
552 int
553 vop_stdunlock(ap)
554 	struct vop_unlock_args /* {
555 		struct vnode *a_vp;
556 	} */ *ap;
557 {
558 	struct vnode *vp = ap->a_vp;
559 
560 	return (lockmgr_unlock(vp->v_vnlock));
561 }
562 
563 /* See above. */
564 int
565 vop_stdislocked(ap)
566 	struct vop_islocked_args /* {
567 		struct vnode *a_vp;
568 	} */ *ap;
569 {
570 
571 	return (lockstatus(ap->a_vp->v_vnlock));
572 }
573 
574 /*
575  * Variants of the above set.
576  *
577  * Differences are:
578  * - shared locking disablement is not supported
579  * - v_vnlock pointer is not honored
580  */
581 int
582 vop_lock(ap)
583 	struct vop_lock1_args /* {
584 		struct vnode *a_vp;
585 		int a_flags;
586 		char *file;
587 		int line;
588 	} */ *ap;
589 {
590 	struct vnode *vp = ap->a_vp;
591 	int flags = ap->a_flags;
592 	struct mtx *ilk;
593 
594 	MPASS(vp->v_vnlock == &vp->v_lock);
595 
596 	if (__predict_false((flags & ~(LK_TYPE_MASK | LK_NODDLKTREAT | LK_RETRY)) != 0))
597 		goto other;
598 
599 	switch (flags & LK_TYPE_MASK) {
600 	case LK_SHARED:
601 		return (lockmgr_slock(&vp->v_lock, flags, ap->a_file, ap->a_line));
602 	case LK_EXCLUSIVE:
603 		return (lockmgr_xlock(&vp->v_lock, flags, ap->a_file, ap->a_line));
604 	}
605 other:
606 	ilk = VI_MTX(vp);
607 	return (lockmgr_lock_flags(&vp->v_lock, flags,
608 	    &ilk->lock_object, ap->a_file, ap->a_line));
609 }
610 
611 int
612 vop_unlock(ap)
613 	struct vop_unlock_args /* {
614 		struct vnode *a_vp;
615 	} */ *ap;
616 {
617 	struct vnode *vp = ap->a_vp;
618 
619 	MPASS(vp->v_vnlock == &vp->v_lock);
620 
621 	return (lockmgr_unlock(&vp->v_lock));
622 }
623 
624 int
625 vop_islocked(ap)
626 	struct vop_islocked_args /* {
627 		struct vnode *a_vp;
628 	} */ *ap;
629 {
630 	struct vnode *vp = ap->a_vp;
631 
632 	MPASS(vp->v_vnlock == &vp->v_lock);
633 
634 	return (lockstatus(&vp->v_lock));
635 }
636 
637 /*
638  * Return true for select/poll.
639  */
640 int
641 vop_nopoll(ap)
642 	struct vop_poll_args /* {
643 		struct vnode *a_vp;
644 		int  a_events;
645 		struct ucred *a_cred;
646 		struct thread *a_td;
647 	} */ *ap;
648 {
649 
650 	if (ap->a_events & ~POLLSTANDARD)
651 		return (POLLNVAL);
652 	return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
653 }
654 
655 /*
656  * Implement poll for local filesystems that support it.
657  */
658 int
659 vop_stdpoll(ap)
660 	struct vop_poll_args /* {
661 		struct vnode *a_vp;
662 		int  a_events;
663 		struct ucred *a_cred;
664 		struct thread *a_td;
665 	} */ *ap;
666 {
667 	if (ap->a_events & ~POLLSTANDARD)
668 		return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
669 	return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
670 }
671 
672 /*
673  * Return our mount point, as we will take charge of the writes.
674  */
675 int
676 vop_stdgetwritemount(ap)
677 	struct vop_getwritemount_args /* {
678 		struct vnode *a_vp;
679 		struct mount **a_mpp;
680 	} */ *ap;
681 {
682 	struct mount *mp;
683 	struct vnode *vp;
684 
685 	/*
686 	 * Note that having a reference does not prevent forced unmount from
687 	 * setting ->v_mount to NULL after the lock gets released. This is of
688 	 * no consequence for typical consumers (most notably vn_start_write)
689 	 * since in this case the vnode is VIRF_DOOMED. Unmount might have
690 	 * progressed far enough that its completion is only delayed by the
691 	 * reference obtained here. The consumer only needs to concern itself
692 	 * with releasing it.
693 	 */
694 	vp = ap->a_vp;
695 	mp = vfs_ref_from_vp(vp);
696 	*(ap->a_mpp) = mp;
697 	return (0);
698 }
699 
700 /*
701  * If the file system doesn't implement VOP_BMAP, then return sensible defaults:
702  * - Return the vnode's bufobj instead of any underlying device's bufobj
703  * - Calculate the physical block number as if there were equal size
704  *   consecutive blocks, but
705  * - Report no contiguous runs of blocks.
706  */
707 int
708 vop_stdbmap(ap)
709 	struct vop_bmap_args /* {
710 		struct vnode *a_vp;
711 		daddr_t  a_bn;
712 		struct bufobj **a_bop;
713 		daddr_t *a_bnp;
714 		int *a_runp;
715 		int *a_runb;
716 	} */ *ap;
717 {
718 
719 	if (ap->a_bop != NULL)
720 		*ap->a_bop = &ap->a_vp->v_bufobj;
721 	if (ap->a_bnp != NULL)
722 		*ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize);
723 	if (ap->a_runp != NULL)
724 		*ap->a_runp = 0;
725 	if (ap->a_runb != NULL)
726 		*ap->a_runb = 0;
727 	return (0);
728 }
729 
730 int
731 vop_stdfsync(ap)
732 	struct vop_fsync_args /* {
733 		struct vnode *a_vp;
734 		int a_waitfor;
735 		struct thread *a_td;
736 	} */ *ap;
737 {
738 
739 	return (vn_fsync_buf(ap->a_vp, ap->a_waitfor));
740 }
741 
742 static int
743 vop_stdfdatasync(struct vop_fdatasync_args *ap)
744 {
745 
746 	return (VOP_FSYNC(ap->a_vp, MNT_WAIT, ap->a_td));
747 }
748 
749 int
750 vop_stdfdatasync_buf(struct vop_fdatasync_args *ap)
751 {
752 
753 	return (vn_fsync_buf(ap->a_vp, MNT_WAIT));
754 }
755 
756 /* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */
757 int
758 vop_stdgetpages(ap)
759 	struct vop_getpages_args /* {
760 		struct vnode *a_vp;
761 		vm_page_t *a_m;
762 		int a_count;
763 		int *a_rbehind;
764 		int *a_rahead;
765 	} */ *ap;
766 {
767 
768 	return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
769 	    ap->a_count, ap->a_rbehind, ap->a_rahead, NULL, NULL);
770 }
771 
772 static int
773 vop_stdgetpages_async(struct vop_getpages_async_args *ap)
774 {
775 	int error;
776 
777 	error = VOP_GETPAGES(ap->a_vp, ap->a_m, ap->a_count, ap->a_rbehind,
778 	    ap->a_rahead);
779 	if (ap->a_iodone != NULL)
780 		ap->a_iodone(ap->a_arg, ap->a_m, ap->a_count, error);
781 	return (error);
782 }
783 
784 int
785 vop_stdkqfilter(struct vop_kqfilter_args *ap)
786 {
787 	return vfs_kqfilter(ap);
788 }
789 
790 /* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */
791 int
792 vop_stdputpages(ap)
793 	struct vop_putpages_args /* {
794 		struct vnode *a_vp;
795 		vm_page_t *a_m;
796 		int a_count;
797 		int a_sync;
798 		int *a_rtvals;
799 	} */ *ap;
800 {
801 
802 	return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
803 	     ap->a_sync, ap->a_rtvals);
804 }
805 
806 int
807 vop_stdvptofh(struct vop_vptofh_args *ap)
808 {
809 	return (EOPNOTSUPP);
810 }
811 
812 int
813 vop_stdvptocnp(struct vop_vptocnp_args *ap)
814 {
815 	struct vnode *vp = ap->a_vp;
816 	struct vnode **dvp = ap->a_vpp;
817 	struct ucred *cred;
818 	char *buf = ap->a_buf;
819 	size_t *buflen = ap->a_buflen;
820 	char *dirbuf, *cpos;
821 	int i, error, eofflag, dirbuflen, flags, locked, len, covered;
822 	off_t off;
823 	ino_t fileno;
824 	struct vattr va;
825 	struct nameidata nd;
826 	struct thread *td;
827 	struct dirent *dp;
828 	struct vnode *mvp;
829 
830 	i = *buflen;
831 	error = 0;
832 	covered = 0;
833 	td = curthread;
834 	cred = td->td_ucred;
835 
836 	if (vp->v_type != VDIR)
837 		return (ENOENT);
838 
839 	error = VOP_GETATTR(vp, &va, cred);
840 	if (error)
841 		return (error);
842 
843 	VREF(vp);
844 	locked = VOP_ISLOCKED(vp);
845 	VOP_UNLOCK(vp);
846 	NDINIT_ATVP(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF, UIO_SYSSPACE,
847 	    "..", vp, td);
848 	flags = FREAD;
849 	error = vn_open_cred(&nd, &flags, 0, VN_OPEN_NOAUDIT, cred, NULL);
850 	if (error) {
851 		vn_lock(vp, locked | LK_RETRY);
852 		return (error);
853 	}
854 	NDFREE(&nd, NDF_ONLY_PNBUF);
855 
856 	mvp = *dvp = nd.ni_vp;
857 
858 	if (vp->v_mount != (*dvp)->v_mount &&
859 	    ((*dvp)->v_vflag & VV_ROOT) &&
860 	    ((*dvp)->v_mount->mnt_flag & MNT_UNION)) {
861 		*dvp = (*dvp)->v_mount->mnt_vnodecovered;
862 		VREF(mvp);
863 		VOP_UNLOCK(mvp);
864 		vn_close(mvp, FREAD, cred, td);
865 		VREF(*dvp);
866 		vn_lock(*dvp, LK_SHARED | LK_RETRY);
867 		covered = 1;
868 	}
869 
870 	fileno = va.va_fileid;
871 
872 	dirbuflen = DEV_BSIZE;
873 	if (dirbuflen < va.va_blocksize)
874 		dirbuflen = va.va_blocksize;
875 	dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
876 
877 	if ((*dvp)->v_type != VDIR) {
878 		error = ENOENT;
879 		goto out;
880 	}
881 
882 	off = 0;
883 	len = 0;
884 	do {
885 		/* call VOP_READDIR of parent */
886 		error = get_next_dirent(*dvp, &dp, dirbuf, dirbuflen, &off,
887 					&cpos, &len, &eofflag, td);
888 		if (error)
889 			goto out;
890 
891 		if ((dp->d_type != DT_WHT) &&
892 		    (dp->d_fileno == fileno)) {
893 			if (covered) {
894 				VOP_UNLOCK(*dvp);
895 				vn_lock(mvp, LK_SHARED | LK_RETRY);
896 				if (dirent_exists(mvp, dp->d_name, td)) {
897 					error = ENOENT;
898 					VOP_UNLOCK(mvp);
899 					vn_lock(*dvp, LK_SHARED | LK_RETRY);
900 					goto out;
901 				}
902 				VOP_UNLOCK(mvp);
903 				vn_lock(*dvp, LK_SHARED | LK_RETRY);
904 			}
905 			i -= dp->d_namlen;
906 
907 			if (i < 0) {
908 				error = ENOMEM;
909 				goto out;
910 			}
911 			if (dp->d_namlen == 1 && dp->d_name[0] == '.') {
912 				error = ENOENT;
913 			} else {
914 				bcopy(dp->d_name, buf + i, dp->d_namlen);
915 				error = 0;
916 			}
917 			goto out;
918 		}
919 	} while (len > 0 || !eofflag);
920 	error = ENOENT;
921 
922 out:
923 	free(dirbuf, M_TEMP);
924 	if (!error) {
925 		*buflen = i;
926 		vref(*dvp);
927 	}
928 	if (covered) {
929 		vput(*dvp);
930 		vrele(mvp);
931 	} else {
932 		VOP_UNLOCK(mvp);
933 		vn_close(mvp, FREAD, cred, td);
934 	}
935 	vn_lock(vp, locked | LK_RETRY);
936 	return (error);
937 }
938 
939 int
940 vop_stdallocate(struct vop_allocate_args *ap)
941 {
942 #ifdef __notyet__
943 	struct statfs *sfs;
944 	off_t maxfilesize = 0;
945 #endif
946 	struct iovec aiov;
947 	struct vattr vattr, *vap;
948 	struct uio auio;
949 	off_t fsize, len, cur, offset;
950 	uint8_t *buf;
951 	struct thread *td;
952 	struct vnode *vp;
953 	size_t iosize;
954 	int error;
955 
956 	buf = NULL;
957 	error = 0;
958 	td = curthread;
959 	vap = &vattr;
960 	vp = ap->a_vp;
961 	len = *ap->a_len;
962 	offset = *ap->a_offset;
963 
964 	error = VOP_GETATTR(vp, vap, td->td_ucred);
965 	if (error != 0)
966 		goto out;
967 	fsize = vap->va_size;
968 	iosize = vap->va_blocksize;
969 	if (iosize == 0)
970 		iosize = BLKDEV_IOSIZE;
971 	if (iosize > maxphys)
972 		iosize = maxphys;
973 	buf = malloc(iosize, M_TEMP, M_WAITOK);
974 
975 #ifdef __notyet__
976 	/*
977 	 * Check if the filesystem sets f_maxfilesize; if not use
978 	 * VOP_SETATTR to perform the check.
979 	 */
980 	sfs = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
981 	error = VFS_STATFS(vp->v_mount, sfs, td);
982 	if (error == 0)
983 		maxfilesize = sfs->f_maxfilesize;
984 	free(sfs, M_STATFS);
985 	if (error != 0)
986 		goto out;
987 	if (maxfilesize) {
988 		if (offset > maxfilesize || len > maxfilesize ||
989 		    offset + len > maxfilesize) {
990 			error = EFBIG;
991 			goto out;
992 		}
993 	} else
994 #endif
995 	if (offset + len > vap->va_size) {
996 		/*
997 		 * Test offset + len against the filesystem's maxfilesize.
998 		 */
999 		VATTR_NULL(vap);
1000 		vap->va_size = offset + len;
1001 		error = VOP_SETATTR(vp, vap, td->td_ucred);
1002 		if (error != 0)
1003 			goto out;
1004 		VATTR_NULL(vap);
1005 		vap->va_size = fsize;
1006 		error = VOP_SETATTR(vp, vap, td->td_ucred);
1007 		if (error != 0)
1008 			goto out;
1009 	}
1010 
1011 	for (;;) {
1012 		/*
1013 		 * Read and write back anything below the nominal file
1014 		 * size.  There's currently no way outside the filesystem
1015 		 * to know whether this area is sparse or not.
1016 		 */
1017 		cur = iosize;
1018 		if ((offset % iosize) != 0)
1019 			cur -= (offset % iosize);
1020 		if (cur > len)
1021 			cur = len;
1022 		if (offset < fsize) {
1023 			aiov.iov_base = buf;
1024 			aiov.iov_len = cur;
1025 			auio.uio_iov = &aiov;
1026 			auio.uio_iovcnt = 1;
1027 			auio.uio_offset = offset;
1028 			auio.uio_resid = cur;
1029 			auio.uio_segflg = UIO_SYSSPACE;
1030 			auio.uio_rw = UIO_READ;
1031 			auio.uio_td = td;
1032 			error = VOP_READ(vp, &auio, 0, td->td_ucred);
1033 			if (error != 0)
1034 				break;
1035 			if (auio.uio_resid > 0) {
1036 				bzero(buf + cur - auio.uio_resid,
1037 				    auio.uio_resid);
1038 			}
1039 		} else {
1040 			bzero(buf, cur);
1041 		}
1042 
1043 		aiov.iov_base = buf;
1044 		aiov.iov_len = cur;
1045 		auio.uio_iov = &aiov;
1046 		auio.uio_iovcnt = 1;
1047 		auio.uio_offset = offset;
1048 		auio.uio_resid = cur;
1049 		auio.uio_segflg = UIO_SYSSPACE;
1050 		auio.uio_rw = UIO_WRITE;
1051 		auio.uio_td = td;
1052 
1053 		error = VOP_WRITE(vp, &auio, 0, td->td_ucred);
1054 		if (error != 0)
1055 			break;
1056 
1057 		len -= cur;
1058 		offset += cur;
1059 		if (len == 0)
1060 			break;
1061 		if (should_yield())
1062 			break;
1063 	}
1064 
1065  out:
1066 	*ap->a_len = len;
1067 	*ap->a_offset = offset;
1068 	free(buf, M_TEMP);
1069 	return (error);
1070 }
1071 
1072 int
1073 vop_stdadvise(struct vop_advise_args *ap)
1074 {
1075 	struct vnode *vp;
1076 	struct bufobj *bo;
1077 	daddr_t startn, endn;
1078 	off_t bstart, bend, start, end;
1079 	int bsize, error;
1080 
1081 	vp = ap->a_vp;
1082 	switch (ap->a_advice) {
1083 	case POSIX_FADV_WILLNEED:
1084 		/*
1085 		 * Do nothing for now.  Filesystems should provide a
1086 		 * custom method which starts an asynchronous read of
1087 		 * the requested region.
1088 		 */
1089 		error = 0;
1090 		break;
1091 	case POSIX_FADV_DONTNEED:
1092 		error = 0;
1093 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1094 		if (VN_IS_DOOMED(vp)) {
1095 			VOP_UNLOCK(vp);
1096 			break;
1097 		}
1098 
1099 		/*
1100 		 * Round to block boundaries (and later possibly further to
1101 		 * page boundaries).  Applications cannot reasonably be aware
1102 		 * of the boundaries, and the rounding must be to expand at
1103 		 * both extremities to cover enough.  It still doesn't cover
1104 		 * read-ahead.  For partial blocks, this gives unnecessary
1105 		 * discarding of buffers but is efficient enough since the
1106 		 * pages usually remain in VMIO for some time.
1107 		 */
1108 		bsize = vp->v_bufobj.bo_bsize;
1109 		bstart = rounddown(ap->a_start, bsize);
1110 		bend = roundup(ap->a_end, bsize);
1111 
1112 		/*
1113 		 * Deactivate pages in the specified range from the backing VM
1114 		 * object.  Pages that are resident in the buffer cache will
1115 		 * remain wired until their corresponding buffers are released
1116 		 * below.
1117 		 */
1118 		if (vp->v_object != NULL) {
1119 			start = trunc_page(bstart);
1120 			end = round_page(bend);
1121 			VM_OBJECT_RLOCK(vp->v_object);
1122 			vm_object_page_noreuse(vp->v_object, OFF_TO_IDX(start),
1123 			    OFF_TO_IDX(end));
1124 			VM_OBJECT_RUNLOCK(vp->v_object);
1125 		}
1126 
1127 		bo = &vp->v_bufobj;
1128 		BO_RLOCK(bo);
1129 		startn = bstart / bsize;
1130 		endn = bend / bsize;
1131 		error = bnoreuselist(&bo->bo_clean, bo, startn, endn);
1132 		if (error == 0)
1133 			error = bnoreuselist(&bo->bo_dirty, bo, startn, endn);
1134 		BO_RUNLOCK(bo);
1135 		VOP_UNLOCK(vp);
1136 		break;
1137 	default:
1138 		error = EINVAL;
1139 		break;
1140 	}
1141 	return (error);
1142 }
1143 
1144 int
1145 vop_stdunp_bind(struct vop_unp_bind_args *ap)
1146 {
1147 
1148 	ap->a_vp->v_unpcb = ap->a_unpcb;
1149 	return (0);
1150 }
1151 
1152 int
1153 vop_stdunp_connect(struct vop_unp_connect_args *ap)
1154 {
1155 
1156 	*ap->a_unpcb = ap->a_vp->v_unpcb;
1157 	return (0);
1158 }
1159 
1160 int
1161 vop_stdunp_detach(struct vop_unp_detach_args *ap)
1162 {
1163 
1164 	ap->a_vp->v_unpcb = NULL;
1165 	return (0);
1166 }
1167 
1168 static int
1169 vop_stdis_text(struct vop_is_text_args *ap)
1170 {
1171 
1172 	return (ap->a_vp->v_writecount < 0);
1173 }
1174 
1175 int
1176 vop_stdset_text(struct vop_set_text_args *ap)
1177 {
1178 	struct vnode *vp;
1179 	struct mount *mp;
1180 	int error;
1181 
1182 	vp = ap->a_vp;
1183 	VI_LOCK(vp);
1184 	if (vp->v_writecount > 0) {
1185 		error = ETXTBSY;
1186 	} else {
1187 		/*
1188 		 * If requested by fs, keep a use reference to the
1189 		 * vnode until the last text reference is released.
1190 		 */
1191 		mp = vp->v_mount;
1192 		if (mp != NULL && (mp->mnt_kern_flag & MNTK_TEXT_REFS) != 0 &&
1193 		    vp->v_writecount == 0) {
1194 			VNPASS((vp->v_iflag & VI_TEXT_REF) == 0, vp);
1195 			vp->v_iflag |= VI_TEXT_REF;
1196 			vrefl(vp);
1197 		}
1198 
1199 		vp->v_writecount--;
1200 		error = 0;
1201 	}
1202 	VI_UNLOCK(vp);
1203 	return (error);
1204 }
1205 
1206 static int
1207 vop_stdunset_text(struct vop_unset_text_args *ap)
1208 {
1209 	struct vnode *vp;
1210 	int error;
1211 	bool last;
1212 
1213 	vp = ap->a_vp;
1214 	last = false;
1215 	VI_LOCK(vp);
1216 	if (vp->v_writecount < 0) {
1217 		if ((vp->v_iflag & VI_TEXT_REF) != 0 &&
1218 		    vp->v_writecount == -1) {
1219 			last = true;
1220 			vp->v_iflag &= ~VI_TEXT_REF;
1221 		}
1222 		vp->v_writecount++;
1223 		error = 0;
1224 	} else {
1225 		error = EINVAL;
1226 	}
1227 	VI_UNLOCK(vp);
1228 	if (last)
1229 		vunref(vp);
1230 	return (error);
1231 }
1232 
1233 static int
1234 vop_stdadd_writecount(struct vop_add_writecount_args *ap)
1235 {
1236 	struct vnode *vp;
1237 	struct mount *mp;
1238 	int error;
1239 
1240 	vp = ap->a_vp;
1241 	VI_LOCK_FLAGS(vp, MTX_DUPOK);
1242 	if (vp->v_writecount < 0) {
1243 		error = ETXTBSY;
1244 	} else {
1245 		VNASSERT(vp->v_writecount + ap->a_inc >= 0, vp,
1246 		    ("neg writecount increment %d", ap->a_inc));
1247 		if (vp->v_writecount == 0) {
1248 			mp = vp->v_mount;
1249 			if (mp != NULL && (mp->mnt_kern_flag & MNTK_NOMSYNC) == 0)
1250 				vlazy(vp);
1251 		}
1252 		vp->v_writecount += ap->a_inc;
1253 		error = 0;
1254 	}
1255 	VI_UNLOCK(vp);
1256 	return (error);
1257 }
1258 
1259 int
1260 vop_stdneed_inactive(struct vop_need_inactive_args *ap)
1261 {
1262 
1263 	return (1);
1264 }
1265 
1266 int
1267 vop_stdioctl(struct vop_ioctl_args *ap)
1268 {
1269 	struct vnode *vp;
1270 	struct vattr va;
1271 	off_t *offp;
1272 	int error;
1273 
1274 	switch (ap->a_command) {
1275 	case FIOSEEKDATA:
1276 	case FIOSEEKHOLE:
1277 		vp = ap->a_vp;
1278 		error = vn_lock(vp, LK_SHARED);
1279 		if (error != 0)
1280 			return (EBADF);
1281 		if (vp->v_type == VREG)
1282 			error = VOP_GETATTR(vp, &va, ap->a_cred);
1283 		else
1284 			error = ENOTTY;
1285 		if (error == 0) {
1286 			offp = ap->a_data;
1287 			if (*offp < 0 || *offp >= va.va_size)
1288 				error = ENXIO;
1289 			else if (ap->a_command == FIOSEEKHOLE)
1290 				*offp = va.va_size;
1291 		}
1292 		VOP_UNLOCK(vp);
1293 		break;
1294 	default:
1295 		error = ENOTTY;
1296 		break;
1297 	}
1298 	return (error);
1299 }
1300 
1301 /*
1302  * vfs default ops
1303  * used to fill the vfs function table to get reasonable default return values.
1304  */
1305 int
1306 vfs_stdroot (mp, flags, vpp)
1307 	struct mount *mp;
1308 	int flags;
1309 	struct vnode **vpp;
1310 {
1311 
1312 	return (EOPNOTSUPP);
1313 }
1314 
1315 int
1316 vfs_stdstatfs (mp, sbp)
1317 	struct mount *mp;
1318 	struct statfs *sbp;
1319 {
1320 
1321 	return (EOPNOTSUPP);
1322 }
1323 
1324 int
1325 vfs_stdquotactl (mp, cmds, uid, arg)
1326 	struct mount *mp;
1327 	int cmds;
1328 	uid_t uid;
1329 	void *arg;
1330 {
1331 
1332 	return (EOPNOTSUPP);
1333 }
1334 
1335 int
1336 vfs_stdsync(mp, waitfor)
1337 	struct mount *mp;
1338 	int waitfor;
1339 {
1340 	struct vnode *vp, *mvp;
1341 	struct thread *td;
1342 	int error, lockreq, allerror = 0;
1343 
1344 	td = curthread;
1345 	lockreq = LK_EXCLUSIVE | LK_INTERLOCK;
1346 	if (waitfor != MNT_WAIT)
1347 		lockreq |= LK_NOWAIT;
1348 	/*
1349 	 * Force stale buffer cache information to be flushed.
1350 	 */
1351 loop:
1352 	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1353 		if (vp->v_bufobj.bo_dirty.bv_cnt == 0) {
1354 			VI_UNLOCK(vp);
1355 			continue;
1356 		}
1357 		if ((error = vget(vp, lockreq)) != 0) {
1358 			if (error == ENOENT) {
1359 				MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1360 				goto loop;
1361 			}
1362 			continue;
1363 		}
1364 		error = VOP_FSYNC(vp, waitfor, td);
1365 		if (error)
1366 			allerror = error;
1367 		vput(vp);
1368 	}
1369 	return (allerror);
1370 }
1371 
1372 int
1373 vfs_stdnosync (mp, waitfor)
1374 	struct mount *mp;
1375 	int waitfor;
1376 {
1377 
1378 	return (0);
1379 }
1380 
1381 static int
1382 vop_stdcopy_file_range(struct vop_copy_file_range_args *ap)
1383 {
1384 	int error;
1385 
1386 	error = vn_generic_copy_file_range(ap->a_invp, ap->a_inoffp,
1387 	    ap->a_outvp, ap->a_outoffp, ap->a_lenp, ap->a_flags, ap->a_incred,
1388 	    ap->a_outcred, ap->a_fsizetd);
1389 	return (error);
1390 }
1391 
1392 int
1393 vfs_stdvget (mp, ino, flags, vpp)
1394 	struct mount *mp;
1395 	ino_t ino;
1396 	int flags;
1397 	struct vnode **vpp;
1398 {
1399 
1400 	return (EOPNOTSUPP);
1401 }
1402 
1403 int
1404 vfs_stdfhtovp (mp, fhp, flags, vpp)
1405 	struct mount *mp;
1406 	struct fid *fhp;
1407 	int flags;
1408 	struct vnode **vpp;
1409 {
1410 
1411 	return (EOPNOTSUPP);
1412 }
1413 
1414 int
1415 vfs_stdinit (vfsp)
1416 	struct vfsconf *vfsp;
1417 {
1418 
1419 	return (0);
1420 }
1421 
1422 int
1423 vfs_stduninit (vfsp)
1424 	struct vfsconf *vfsp;
1425 {
1426 
1427 	return(0);
1428 }
1429 
1430 int
1431 vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname)
1432 	struct mount *mp;
1433 	int cmd;
1434 	struct vnode *filename_vp;
1435 	int attrnamespace;
1436 	const char *attrname;
1437 {
1438 
1439 	if (filename_vp != NULL)
1440 		VOP_UNLOCK(filename_vp);
1441 	return (EOPNOTSUPP);
1442 }
1443 
1444 int
1445 vfs_stdsysctl(mp, op, req)
1446 	struct mount *mp;
1447 	fsctlop_t op;
1448 	struct sysctl_req *req;
1449 {
1450 
1451 	return (EOPNOTSUPP);
1452 }
1453 
1454 static vop_bypass_t *
1455 bp_by_off(struct vop_vector *vop, struct vop_generic_args *a)
1456 {
1457 
1458 	return (*(vop_bypass_t **)((char *)vop + a->a_desc->vdesc_vop_offset));
1459 }
1460 
1461 int
1462 vop_sigdefer(struct vop_vector *vop, struct vop_generic_args *a)
1463 {
1464 	vop_bypass_t *bp;
1465 	int prev_stops, rc;
1466 
1467 	bp = bp_by_off(vop, a);
1468 	MPASS(bp != NULL);
1469 
1470 	prev_stops = sigdeferstop(SIGDEFERSTOP_SILENT);
1471 	rc = bp(a);
1472 	sigallowstop(prev_stops);
1473 	return (rc);
1474 }
1475 
1476 static int
1477 vop_stdstat(struct vop_stat_args *a)
1478 {
1479 	struct vattr vattr;
1480 	struct vattr *vap;
1481 	struct vnode *vp;
1482 	struct stat *sb;
1483 	int error;
1484 	u_short mode;
1485 
1486 	vp = a->a_vp;
1487 	sb = a->a_sb;
1488 
1489 	error = vop_stat_helper_pre(a);
1490 	if (error != 0)
1491 		return (error);
1492 
1493 	vap = &vattr;
1494 
1495 	/*
1496 	 * Initialize defaults for new and unusual fields, so that file
1497 	 * systems which don't support these fields don't need to know
1498 	 * about them.
1499 	 */
1500 	vap->va_birthtime.tv_sec = -1;
1501 	vap->va_birthtime.tv_nsec = 0;
1502 	vap->va_fsid = VNOVAL;
1503 	vap->va_rdev = NODEV;
1504 
1505 	error = VOP_GETATTR(vp, vap, a->a_active_cred);
1506 	if (error)
1507 		goto out;
1508 
1509 	/*
1510 	 * Zero the spare stat fields
1511 	 */
1512 	bzero(sb, sizeof *sb);
1513 
1514 	/*
1515 	 * Copy from vattr table
1516 	 */
1517 	if (vap->va_fsid != VNOVAL)
1518 		sb->st_dev = vap->va_fsid;
1519 	else
1520 		sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0];
1521 	sb->st_ino = vap->va_fileid;
1522 	mode = vap->va_mode;
1523 	switch (vap->va_type) {
1524 	case VREG:
1525 		mode |= S_IFREG;
1526 		break;
1527 	case VDIR:
1528 		mode |= S_IFDIR;
1529 		break;
1530 	case VBLK:
1531 		mode |= S_IFBLK;
1532 		break;
1533 	case VCHR:
1534 		mode |= S_IFCHR;
1535 		break;
1536 	case VLNK:
1537 		mode |= S_IFLNK;
1538 		break;
1539 	case VSOCK:
1540 		mode |= S_IFSOCK;
1541 		break;
1542 	case VFIFO:
1543 		mode |= S_IFIFO;
1544 		break;
1545 	default:
1546 		error = EBADF;
1547 		goto out;
1548 	}
1549 	sb->st_mode = mode;
1550 	sb->st_nlink = vap->va_nlink;
1551 	sb->st_uid = vap->va_uid;
1552 	sb->st_gid = vap->va_gid;
1553 	sb->st_rdev = vap->va_rdev;
1554 	if (vap->va_size > OFF_MAX) {
1555 		error = EOVERFLOW;
1556 		goto out;
1557 	}
1558 	sb->st_size = vap->va_size;
1559 	sb->st_atim.tv_sec = vap->va_atime.tv_sec;
1560 	sb->st_atim.tv_nsec = vap->va_atime.tv_nsec;
1561 	sb->st_mtim.tv_sec = vap->va_mtime.tv_sec;
1562 	sb->st_mtim.tv_nsec = vap->va_mtime.tv_nsec;
1563 	sb->st_ctim.tv_sec = vap->va_ctime.tv_sec;
1564 	sb->st_ctim.tv_nsec = vap->va_ctime.tv_nsec;
1565 	sb->st_birthtim.tv_sec = vap->va_birthtime.tv_sec;
1566 	sb->st_birthtim.tv_nsec = vap->va_birthtime.tv_nsec;
1567 
1568 	/*
1569 	 * According to www.opengroup.org, the meaning of st_blksize is
1570 	 *   "a filesystem-specific preferred I/O block size for this
1571 	 *    object.  In some filesystem types, this may vary from file
1572 	 *    to file"
1573 	 * Use minimum/default of PAGE_SIZE (e.g. for VCHR).
1574 	 */
1575 
1576 	sb->st_blksize = max(PAGE_SIZE, vap->va_blocksize);
1577 	sb->st_flags = vap->va_flags;
1578 	sb->st_blocks = vap->va_bytes / S_BLKSIZE;
1579 	sb->st_gen = vap->va_gen;
1580 out:
1581 	return (vop_stat_helper_post(a, error));
1582 }
1583 
1584 static int
1585 vop_stdread_pgcache(struct vop_read_pgcache_args *ap __unused)
1586 {
1587 	return (EJUSTRETURN);
1588 }
1589 
1590 static int
1591 vop_stdvput_pair(struct vop_vput_pair_args *ap)
1592 {
1593 	struct vnode *dvp, *vp, **vpp;
1594 
1595 	dvp = ap->a_dvp;
1596 	vpp = ap->a_vpp;
1597 	vput(dvp);
1598 	if (vpp != NULL && ap->a_unlock_vp && (vp = *vpp) != NULL)
1599 		vput(vp);
1600 	return (0);
1601 }
1602