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