xref: /freebsd/sys/kern/vfs_default.c (revision 4f52dfbb8d6c4d446500c5b097e3806ec219fbd4)
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/kernel.h>
47 #include <sys/limits.h>
48 #include <sys/lock.h>
49 #include <sys/lockf.h>
50 #include <sys/malloc.h>
51 #include <sys/mount.h>
52 #include <sys/namei.h>
53 #include <sys/rwlock.h>
54 #include <sys/fcntl.h>
55 #include <sys/unistd.h>
56 #include <sys/vnode.h>
57 #include <sys/dirent.h>
58 #include <sys/poll.h>
59 
60 #include <security/mac/mac_framework.h>
61 
62 #include <vm/vm.h>
63 #include <vm/vm_object.h>
64 #include <vm/vm_extern.h>
65 #include <vm/pmap.h>
66 #include <vm/vm_map.h>
67 #include <vm/vm_page.h>
68 #include <vm/vm_pager.h>
69 #include <vm/vnode_pager.h>
70 
71 static int	vop_nolookup(struct vop_lookup_args *);
72 static int	vop_norename(struct vop_rename_args *);
73 static int	vop_nostrategy(struct vop_strategy_args *);
74 static int	get_next_dirent(struct vnode *vp, struct dirent **dpp,
75 				char *dirbuf, int dirbuflen, off_t *off,
76 				char **cpos, int *len, int *eofflag,
77 				struct thread *td);
78 static int	dirent_exists(struct vnode *vp, const char *dirname,
79 			      struct thread *td);
80 
81 #define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4)
82 
83 static int vop_stdis_text(struct vop_is_text_args *ap);
84 static int vop_stdset_text(struct vop_set_text_args *ap);
85 static int vop_stdunset_text(struct vop_unset_text_args *ap);
86 static int vop_stdget_writecount(struct vop_get_writecount_args *ap);
87 static int vop_stdadd_writecount(struct vop_add_writecount_args *ap);
88 static int vop_stdfdatasync(struct vop_fdatasync_args *ap);
89 static int vop_stdgetpages_async(struct vop_getpages_async_args *ap);
90 
91 /*
92  * This vnode table stores what we want to do if the filesystem doesn't
93  * implement a particular VOP.
94  *
95  * If there is no specific entry here, we will return EOPNOTSUPP.
96  *
97  * Note that every filesystem has to implement either vop_access
98  * or vop_accessx; failing to do so will result in immediate crash
99  * due to stack overflow, as vop_stdaccess() calls vop_stdaccessx(),
100  * which calls vop_stdaccess() etc.
101  */
102 
103 struct vop_vector default_vnodeops = {
104 	.vop_default =		NULL,
105 	.vop_bypass =		VOP_EOPNOTSUPP,
106 
107 	.vop_access =		vop_stdaccess,
108 	.vop_accessx =		vop_stdaccessx,
109 	.vop_advise =		vop_stdadvise,
110 	.vop_advlock =		vop_stdadvlock,
111 	.vop_advlockasync =	vop_stdadvlockasync,
112 	.vop_advlockpurge =	vop_stdadvlockpurge,
113 	.vop_allocate =		vop_stdallocate,
114 	.vop_bmap =		vop_stdbmap,
115 	.vop_close =		VOP_NULL,
116 	.vop_fsync =		VOP_NULL,
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_ioctl =		VOP_ENOTTY,
123 	.vop_kqfilter =		vop_stdkqfilter,
124 	.vop_islocked =		vop_stdislocked,
125 	.vop_lock1 =		vop_stdlock,
126 	.vop_lookup =		vop_nolookup,
127 	.vop_open =		VOP_NULL,
128 	.vop_pathconf =		VOP_EINVAL,
129 	.vop_poll =		vop_nopoll,
130 	.vop_putpages =		vop_stdputpages,
131 	.vop_readlink =		VOP_EINVAL,
132 	.vop_rename =		vop_norename,
133 	.vop_revoke =		VOP_PANIC,
134 	.vop_strategy =		vop_nostrategy,
135 	.vop_unlock =		vop_stdunlock,
136 	.vop_vptocnp =		vop_stdvptocnp,
137 	.vop_vptofh =		vop_stdvptofh,
138 	.vop_unp_bind =		vop_stdunp_bind,
139 	.vop_unp_connect =	vop_stdunp_connect,
140 	.vop_unp_detach =	vop_stdunp_detach,
141 	.vop_is_text =		vop_stdis_text,
142 	.vop_set_text =		vop_stdset_text,
143 	.vop_unset_text =	vop_stdunset_text,
144 	.vop_get_writecount =	vop_stdget_writecount,
145 	.vop_add_writecount =	vop_stdadd_writecount,
146 };
147 
148 /*
149  * Series of placeholder functions for various error returns for
150  * VOPs.
151  */
152 
153 int
154 vop_eopnotsupp(struct vop_generic_args *ap)
155 {
156 	/*
157 	printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name);
158 	*/
159 
160 	return (EOPNOTSUPP);
161 }
162 
163 int
164 vop_ebadf(struct vop_generic_args *ap)
165 {
166 
167 	return (EBADF);
168 }
169 
170 int
171 vop_enotty(struct vop_generic_args *ap)
172 {
173 
174 	return (ENOTTY);
175 }
176 
177 int
178 vop_einval(struct vop_generic_args *ap)
179 {
180 
181 	return (EINVAL);
182 }
183 
184 int
185 vop_enoent(struct vop_generic_args *ap)
186 {
187 
188 	return (ENOENT);
189 }
190 
191 int
192 vop_null(struct vop_generic_args *ap)
193 {
194 
195 	return (0);
196 }
197 
198 /*
199  * Helper function to panic on some bad VOPs in some filesystems.
200  */
201 int
202 vop_panic(struct vop_generic_args *ap)
203 {
204 
205 	panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
206 }
207 
208 /*
209  * vop_std<something> and vop_no<something> are default functions for use by
210  * filesystems that need the "default reasonable" implementation for a
211  * particular operation.
212  *
213  * The documentation for the operations they implement exists (if it exists)
214  * in the VOP_<SOMETHING>(9) manpage (all uppercase).
215  */
216 
217 /*
218  * Default vop for filesystems that do not support name lookup
219  */
220 static int
221 vop_nolookup(ap)
222 	struct vop_lookup_args /* {
223 		struct vnode *a_dvp;
224 		struct vnode **a_vpp;
225 		struct componentname *a_cnp;
226 	} */ *ap;
227 {
228 
229 	*ap->a_vpp = NULL;
230 	return (ENOTDIR);
231 }
232 
233 /*
234  * vop_norename:
235  *
236  * Handle unlock and reference counting for arguments of vop_rename
237  * for filesystems that do not implement rename operation.
238  */
239 static int
240 vop_norename(struct vop_rename_args *ap)
241 {
242 
243 	vop_rename_fail(ap);
244 	return (EOPNOTSUPP);
245 }
246 
247 /*
248  *	vop_nostrategy:
249  *
250  *	Strategy routine for VFS devices that have none.
251  *
252  *	BIO_ERROR and B_INVAL must be cleared prior to calling any strategy
253  *	routine.  Typically this is done for a BIO_READ strategy call.
254  *	Typically B_INVAL is assumed to already be clear prior to a write
255  *	and should not be cleared manually unless you just made the buffer
256  *	invalid.  BIO_ERROR should be cleared either way.
257  */
258 
259 static int
260 vop_nostrategy (struct vop_strategy_args *ap)
261 {
262 	printf("No strategy for buffer at %p\n", ap->a_bp);
263 	vn_printf(ap->a_vp, "vnode ");
264 	ap->a_bp->b_ioflags |= BIO_ERROR;
265 	ap->a_bp->b_error = EOPNOTSUPP;
266 	bufdone(ap->a_bp);
267 	return (EOPNOTSUPP);
268 }
269 
270 static int
271 get_next_dirent(struct vnode *vp, struct dirent **dpp, char *dirbuf,
272 		int dirbuflen, off_t *off, char **cpos, int *len,
273 		int *eofflag, struct thread *td)
274 {
275 	int error, reclen;
276 	struct uio uio;
277 	struct iovec iov;
278 	struct dirent *dp;
279 
280 	KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
281 	KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
282 
283 	if (*len == 0) {
284 		iov.iov_base = dirbuf;
285 		iov.iov_len = dirbuflen;
286 
287 		uio.uio_iov = &iov;
288 		uio.uio_iovcnt = 1;
289 		uio.uio_offset = *off;
290 		uio.uio_resid = dirbuflen;
291 		uio.uio_segflg = UIO_SYSSPACE;
292 		uio.uio_rw = UIO_READ;
293 		uio.uio_td = td;
294 
295 		*eofflag = 0;
296 
297 #ifdef MAC
298 		error = mac_vnode_check_readdir(td->td_ucred, vp);
299 		if (error == 0)
300 #endif
301 			error = VOP_READDIR(vp, &uio, td->td_ucred, eofflag,
302 		    		NULL, NULL);
303 		if (error)
304 			return (error);
305 
306 		*off = uio.uio_offset;
307 
308 		*cpos = dirbuf;
309 		*len = (dirbuflen - uio.uio_resid);
310 
311 		if (*len == 0)
312 			return (ENOENT);
313 	}
314 
315 	dp = (struct dirent *)(*cpos);
316 	reclen = dp->d_reclen;
317 	*dpp = dp;
318 
319 	/* check for malformed directory.. */
320 	if (reclen < DIRENT_MINSIZE)
321 		return (EINVAL);
322 
323 	*cpos += reclen;
324 	*len -= reclen;
325 
326 	return (0);
327 }
328 
329 /*
330  * Check if a named file exists in a given directory vnode.
331  */
332 static int
333 dirent_exists(struct vnode *vp, const char *dirname, struct thread *td)
334 {
335 	char *dirbuf, *cpos;
336 	int error, eofflag, dirbuflen, len, found;
337 	off_t off;
338 	struct dirent *dp;
339 	struct vattr va;
340 
341 	KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
342 	KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
343 
344 	found = 0;
345 
346 	error = VOP_GETATTR(vp, &va, td->td_ucred);
347 	if (error)
348 		return (found);
349 
350 	dirbuflen = DEV_BSIZE;
351 	if (dirbuflen < va.va_blocksize)
352 		dirbuflen = va.va_blocksize;
353 	dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
354 
355 	off = 0;
356 	len = 0;
357 	do {
358 		error = get_next_dirent(vp, &dp, dirbuf, dirbuflen, &off,
359 					&cpos, &len, &eofflag, td);
360 		if (error)
361 			goto out;
362 
363 		if (dp->d_type != DT_WHT && dp->d_fileno != 0 &&
364 		    strcmp(dp->d_name, dirname) == 0) {
365 			found = 1;
366 			goto out;
367 		}
368 	} while (len > 0 || !eofflag);
369 
370 out:
371 	free(dirbuf, M_TEMP);
372 	return (found);
373 }
374 
375 int
376 vop_stdaccess(struct vop_access_args *ap)
377 {
378 
379 	KASSERT((ap->a_accmode & ~(VEXEC | VWRITE | VREAD | VADMIN |
380 	    VAPPEND)) == 0, ("invalid bit in accmode"));
381 
382 	return (VOP_ACCESSX(ap->a_vp, ap->a_accmode, ap->a_cred, ap->a_td));
383 }
384 
385 int
386 vop_stdaccessx(struct vop_accessx_args *ap)
387 {
388 	int error;
389 	accmode_t accmode = ap->a_accmode;
390 
391 	error = vfs_unixify_accmode(&accmode);
392 	if (error != 0)
393 		return (error);
394 
395 	if (accmode == 0)
396 		return (0);
397 
398 	return (VOP_ACCESS(ap->a_vp, accmode, ap->a_cred, ap->a_td));
399 }
400 
401 /*
402  * Advisory record locking support
403  */
404 int
405 vop_stdadvlock(struct vop_advlock_args *ap)
406 {
407 	struct vnode *vp;
408 	struct vattr vattr;
409 	int error;
410 
411 	vp = ap->a_vp;
412 	if (ap->a_fl->l_whence == SEEK_END) {
413 		/*
414 		 * The NFSv4 server must avoid doing a vn_lock() here, since it
415 		 * can deadlock the nfsd threads, due to a LOR.  Fortunately
416 		 * the NFSv4 server always uses SEEK_SET and this code is
417 		 * only required for the SEEK_END case.
418 		 */
419 		vn_lock(vp, LK_SHARED | LK_RETRY);
420 		error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
421 		VOP_UNLOCK(vp, 0);
422 		if (error)
423 			return (error);
424 	} else
425 		vattr.va_size = 0;
426 
427 	return (lf_advlock(ap, &(vp->v_lockf), vattr.va_size));
428 }
429 
430 int
431 vop_stdadvlockasync(struct vop_advlockasync_args *ap)
432 {
433 	struct vnode *vp;
434 	struct vattr vattr;
435 	int error;
436 
437 	vp = ap->a_vp;
438 	if (ap->a_fl->l_whence == SEEK_END) {
439 		/* The size argument is only needed for SEEK_END. */
440 		vn_lock(vp, LK_SHARED | LK_RETRY);
441 		error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
442 		VOP_UNLOCK(vp, 0);
443 		if (error)
444 			return (error);
445 	} else
446 		vattr.va_size = 0;
447 
448 	return (lf_advlockasync(ap, &(vp->v_lockf), vattr.va_size));
449 }
450 
451 int
452 vop_stdadvlockpurge(struct vop_advlockpurge_args *ap)
453 {
454 	struct vnode *vp;
455 
456 	vp = ap->a_vp;
457 	lf_purgelocks(vp, &vp->v_lockf);
458 	return (0);
459 }
460 
461 /*
462  * vop_stdpathconf:
463  *
464  * Standard implementation of POSIX pathconf, to get information about limits
465  * for a filesystem.
466  * Override per filesystem for the case where the filesystem has smaller
467  * limits.
468  */
469 int
470 vop_stdpathconf(ap)
471 	struct vop_pathconf_args /* {
472 	struct vnode *a_vp;
473 	int a_name;
474 	int *a_retval;
475 	} */ *ap;
476 {
477 
478 	switch (ap->a_name) {
479 		case _PC_ASYNC_IO:
480 			*ap->a_retval = _POSIX_ASYNCHRONOUS_IO;
481 			return (0);
482 		case _PC_PATH_MAX:
483 			*ap->a_retval = PATH_MAX;
484 			return (0);
485 		default:
486 			return (EINVAL);
487 	}
488 	/* NOTREACHED */
489 }
490 
491 /*
492  * Standard lock, unlock and islocked functions.
493  */
494 int
495 vop_stdlock(ap)
496 	struct vop_lock1_args /* {
497 		struct vnode *a_vp;
498 		int a_flags;
499 		char *file;
500 		int line;
501 	} */ *ap;
502 {
503 	struct vnode *vp = ap->a_vp;
504 	struct mtx *ilk;
505 
506 	ilk = VI_MTX(vp);
507 	return (lockmgr_lock_fast_path(vp->v_vnlock, ap->a_flags,
508 	    (ilk != NULL) ? &ilk->lock_object : NULL, ap->a_file, ap->a_line));
509 }
510 
511 /* See above. */
512 int
513 vop_stdunlock(ap)
514 	struct vop_unlock_args /* {
515 		struct vnode *a_vp;
516 		int a_flags;
517 	} */ *ap;
518 {
519 	struct vnode *vp = ap->a_vp;
520 	struct mtx *ilk;
521 
522 	ilk = VI_MTX(vp);
523 	return (lockmgr_unlock_fast_path(vp->v_vnlock, ap->a_flags,
524 	    (ilk != NULL) ? &ilk->lock_object : NULL));
525 }
526 
527 /* See above. */
528 int
529 vop_stdislocked(ap)
530 	struct vop_islocked_args /* {
531 		struct vnode *a_vp;
532 	} */ *ap;
533 {
534 
535 	return (lockstatus(ap->a_vp->v_vnlock));
536 }
537 
538 /*
539  * Return true for select/poll.
540  */
541 int
542 vop_nopoll(ap)
543 	struct vop_poll_args /* {
544 		struct vnode *a_vp;
545 		int  a_events;
546 		struct ucred *a_cred;
547 		struct thread *a_td;
548 	} */ *ap;
549 {
550 
551 	return (poll_no_poll(ap->a_events));
552 }
553 
554 /*
555  * Implement poll for local filesystems that support it.
556  */
557 int
558 vop_stdpoll(ap)
559 	struct vop_poll_args /* {
560 		struct vnode *a_vp;
561 		int  a_events;
562 		struct ucred *a_cred;
563 		struct thread *a_td;
564 	} */ *ap;
565 {
566 	if (ap->a_events & ~POLLSTANDARD)
567 		return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
568 	return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
569 }
570 
571 /*
572  * Return our mount point, as we will take charge of the writes.
573  */
574 int
575 vop_stdgetwritemount(ap)
576 	struct vop_getwritemount_args /* {
577 		struct vnode *a_vp;
578 		struct mount **a_mpp;
579 	} */ *ap;
580 {
581 	struct mount *mp;
582 
583 	/*
584 	 * XXX Since this is called unlocked we may be recycled while
585 	 * attempting to ref the mount.  If this is the case or mountpoint
586 	 * will be set to NULL.  We only have to prevent this call from
587 	 * returning with a ref to an incorrect mountpoint.  It is not
588 	 * harmful to return with a ref to our previous mountpoint.
589 	 */
590 	mp = ap->a_vp->v_mount;
591 	if (mp != NULL) {
592 		vfs_ref(mp);
593 		if (mp != ap->a_vp->v_mount) {
594 			vfs_rel(mp);
595 			mp = NULL;
596 		}
597 	}
598 	*(ap->a_mpp) = mp;
599 	return (0);
600 }
601 
602 /* XXX Needs good comment and VOP_BMAP(9) manpage */
603 int
604 vop_stdbmap(ap)
605 	struct vop_bmap_args /* {
606 		struct vnode *a_vp;
607 		daddr_t  a_bn;
608 		struct bufobj **a_bop;
609 		daddr_t *a_bnp;
610 		int *a_runp;
611 		int *a_runb;
612 	} */ *ap;
613 {
614 
615 	if (ap->a_bop != NULL)
616 		*ap->a_bop = &ap->a_vp->v_bufobj;
617 	if (ap->a_bnp != NULL)
618 		*ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize);
619 	if (ap->a_runp != NULL)
620 		*ap->a_runp = 0;
621 	if (ap->a_runb != NULL)
622 		*ap->a_runb = 0;
623 	return (0);
624 }
625 
626 int
627 vop_stdfsync(ap)
628 	struct vop_fsync_args /* {
629 		struct vnode *a_vp;
630 		int a_waitfor;
631 		struct thread *a_td;
632 	} */ *ap;
633 {
634 	struct vnode *vp;
635 	struct buf *bp, *nbp;
636 	struct bufobj *bo;
637 	struct mount *mp;
638 	int error, maxretry;
639 
640 	error = 0;
641 	maxretry = 10000;     /* large, arbitrarily chosen */
642 	vp = ap->a_vp;
643 	mp = NULL;
644 	if (vp->v_type == VCHR) {
645 		VI_LOCK(vp);
646 		mp = vp->v_rdev->si_mountpt;
647 		VI_UNLOCK(vp);
648 	}
649 	bo = &vp->v_bufobj;
650 	BO_LOCK(bo);
651 loop1:
652 	/*
653 	 * MARK/SCAN initialization to avoid infinite loops.
654 	 */
655         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs) {
656                 bp->b_vflags &= ~BV_SCANNED;
657 		bp->b_error = 0;
658 	}
659 
660 	/*
661 	 * Flush all dirty buffers associated with a vnode.
662 	 */
663 loop2:
664 	TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
665 		if ((bp->b_vflags & BV_SCANNED) != 0)
666 			continue;
667 		bp->b_vflags |= BV_SCANNED;
668 		if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
669 			if (ap->a_waitfor != MNT_WAIT)
670 				continue;
671 			if (BUF_LOCK(bp,
672 			    LK_EXCLUSIVE | LK_INTERLOCK | LK_SLEEPFAIL,
673 			    BO_LOCKPTR(bo)) != 0) {
674 				BO_LOCK(bo);
675 				goto loop1;
676 			}
677 			BO_LOCK(bo);
678 		}
679 		BO_UNLOCK(bo);
680 		KASSERT(bp->b_bufobj == bo,
681 		    ("bp %p wrong b_bufobj %p should be %p",
682 		    bp, bp->b_bufobj, bo));
683 		if ((bp->b_flags & B_DELWRI) == 0)
684 			panic("fsync: not dirty");
685 		if ((vp->v_object != NULL) && (bp->b_flags & B_CLUSTEROK)) {
686 			vfs_bio_awrite(bp);
687 		} else {
688 			bremfree(bp);
689 			bawrite(bp);
690 		}
691 		if (maxretry < 1000)
692 			pause("dirty", hz < 1000 ? 1 : hz / 1000);
693 		BO_LOCK(bo);
694 		goto loop2;
695 	}
696 
697 	/*
698 	 * If synchronous the caller expects us to completely resolve all
699 	 * dirty buffers in the system.  Wait for in-progress I/O to
700 	 * complete (which could include background bitmap writes), then
701 	 * retry if dirty blocks still exist.
702 	 */
703 	if (ap->a_waitfor == MNT_WAIT) {
704 		bufobj_wwait(bo, 0, 0);
705 		if (bo->bo_dirty.bv_cnt > 0) {
706 			/*
707 			 * If we are unable to write any of these buffers
708 			 * then we fail now rather than trying endlessly
709 			 * to write them out.
710 			 */
711 			TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
712 				if ((error = bp->b_error) != 0)
713 					break;
714 			if ((mp != NULL && mp->mnt_secondary_writes > 0) ||
715 			    (error == 0 && --maxretry >= 0))
716 				goto loop1;
717 			if (error == 0)
718 				error = EAGAIN;
719 		}
720 	}
721 	BO_UNLOCK(bo);
722 	if (error != 0)
723 		vn_printf(vp, "fsync: giving up on dirty (error = %d) ", error);
724 
725 	return (error);
726 }
727 
728 static int
729 vop_stdfdatasync(struct vop_fdatasync_args *ap)
730 {
731 
732 	return (VOP_FSYNC(ap->a_vp, MNT_WAIT, ap->a_td));
733 }
734 
735 int
736 vop_stdfdatasync_buf(struct vop_fdatasync_args *ap)
737 {
738 	struct vop_fsync_args apf;
739 
740 	apf.a_vp = ap->a_vp;
741 	apf.a_waitfor = MNT_WAIT;
742 	apf.a_td = ap->a_td;
743 	return (vop_stdfsync(&apf));
744 }
745 
746 /* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */
747 int
748 vop_stdgetpages(ap)
749 	struct vop_getpages_args /* {
750 		struct vnode *a_vp;
751 		vm_page_t *a_m;
752 		int a_count;
753 		int *a_rbehind;
754 		int *a_rahead;
755 	} */ *ap;
756 {
757 
758 	return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
759 	    ap->a_count, ap->a_rbehind, ap->a_rahead, NULL, NULL);
760 }
761 
762 static int
763 vop_stdgetpages_async(struct vop_getpages_async_args *ap)
764 {
765 	int error;
766 
767 	error = VOP_GETPAGES(ap->a_vp, ap->a_m, ap->a_count, ap->a_rbehind,
768 	    ap->a_rahead);
769 	ap->a_iodone(ap->a_arg, ap->a_m, ap->a_count, error);
770 	return (error);
771 }
772 
773 int
774 vop_stdkqfilter(struct vop_kqfilter_args *ap)
775 {
776 	return vfs_kqfilter(ap);
777 }
778 
779 /* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */
780 int
781 vop_stdputpages(ap)
782 	struct vop_putpages_args /* {
783 		struct vnode *a_vp;
784 		vm_page_t *a_m;
785 		int a_count;
786 		int a_sync;
787 		int *a_rtvals;
788 	} */ *ap;
789 {
790 
791 	return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
792 	     ap->a_sync, ap->a_rtvals);
793 }
794 
795 int
796 vop_stdvptofh(struct vop_vptofh_args *ap)
797 {
798 	return (EOPNOTSUPP);
799 }
800 
801 int
802 vop_stdvptocnp(struct vop_vptocnp_args *ap)
803 {
804 	struct vnode *vp = ap->a_vp;
805 	struct vnode **dvp = ap->a_vpp;
806 	struct ucred *cred = ap->a_cred;
807 	char *buf = ap->a_buf;
808 	int *buflen = ap->a_buflen;
809 	char *dirbuf, *cpos;
810 	int i, error, eofflag, dirbuflen, flags, locked, len, covered;
811 	off_t off;
812 	ino_t fileno;
813 	struct vattr va;
814 	struct nameidata nd;
815 	struct thread *td;
816 	struct dirent *dp;
817 	struct vnode *mvp;
818 
819 	i = *buflen;
820 	error = 0;
821 	covered = 0;
822 	td = curthread;
823 
824 	if (vp->v_type != VDIR)
825 		return (ENOENT);
826 
827 	error = VOP_GETATTR(vp, &va, cred);
828 	if (error)
829 		return (error);
830 
831 	VREF(vp);
832 	locked = VOP_ISLOCKED(vp);
833 	VOP_UNLOCK(vp, 0);
834 	NDINIT_ATVP(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF, UIO_SYSSPACE,
835 	    "..", vp, td);
836 	flags = FREAD;
837 	error = vn_open_cred(&nd, &flags, 0, VN_OPEN_NOAUDIT, cred, NULL);
838 	if (error) {
839 		vn_lock(vp, locked | LK_RETRY);
840 		return (error);
841 	}
842 	NDFREE(&nd, NDF_ONLY_PNBUF);
843 
844 	mvp = *dvp = nd.ni_vp;
845 
846 	if (vp->v_mount != (*dvp)->v_mount &&
847 	    ((*dvp)->v_vflag & VV_ROOT) &&
848 	    ((*dvp)->v_mount->mnt_flag & MNT_UNION)) {
849 		*dvp = (*dvp)->v_mount->mnt_vnodecovered;
850 		VREF(mvp);
851 		VOP_UNLOCK(mvp, 0);
852 		vn_close(mvp, FREAD, cred, td);
853 		VREF(*dvp);
854 		vn_lock(*dvp, LK_SHARED | LK_RETRY);
855 		covered = 1;
856 	}
857 
858 	fileno = va.va_fileid;
859 
860 	dirbuflen = DEV_BSIZE;
861 	if (dirbuflen < va.va_blocksize)
862 		dirbuflen = va.va_blocksize;
863 	dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
864 
865 	if ((*dvp)->v_type != VDIR) {
866 		error = ENOENT;
867 		goto out;
868 	}
869 
870 	off = 0;
871 	len = 0;
872 	do {
873 		/* call VOP_READDIR of parent */
874 		error = get_next_dirent(*dvp, &dp, dirbuf, dirbuflen, &off,
875 					&cpos, &len, &eofflag, td);
876 		if (error)
877 			goto out;
878 
879 		if ((dp->d_type != DT_WHT) &&
880 		    (dp->d_fileno == fileno)) {
881 			if (covered) {
882 				VOP_UNLOCK(*dvp, 0);
883 				vn_lock(mvp, LK_SHARED | LK_RETRY);
884 				if (dirent_exists(mvp, dp->d_name, td)) {
885 					error = ENOENT;
886 					VOP_UNLOCK(mvp, 0);
887 					vn_lock(*dvp, LK_SHARED | LK_RETRY);
888 					goto out;
889 				}
890 				VOP_UNLOCK(mvp, 0);
891 				vn_lock(*dvp, LK_SHARED | LK_RETRY);
892 			}
893 			i -= dp->d_namlen;
894 
895 			if (i < 0) {
896 				error = ENOMEM;
897 				goto out;
898 			}
899 			if (dp->d_namlen == 1 && dp->d_name[0] == '.') {
900 				error = ENOENT;
901 			} else {
902 				bcopy(dp->d_name, buf + i, dp->d_namlen);
903 				error = 0;
904 			}
905 			goto out;
906 		}
907 	} while (len > 0 || !eofflag);
908 	error = ENOENT;
909 
910 out:
911 	free(dirbuf, M_TEMP);
912 	if (!error) {
913 		*buflen = i;
914 		vref(*dvp);
915 	}
916 	if (covered) {
917 		vput(*dvp);
918 		vrele(mvp);
919 	} else {
920 		VOP_UNLOCK(mvp, 0);
921 		vn_close(mvp, FREAD, cred, td);
922 	}
923 	vn_lock(vp, locked | LK_RETRY);
924 	return (error);
925 }
926 
927 int
928 vop_stdallocate(struct vop_allocate_args *ap)
929 {
930 #ifdef __notyet__
931 	struct statfs *sfs;
932 	off_t maxfilesize = 0;
933 #endif
934 	struct iovec aiov;
935 	struct vattr vattr, *vap;
936 	struct uio auio;
937 	off_t fsize, len, cur, offset;
938 	uint8_t *buf;
939 	struct thread *td;
940 	struct vnode *vp;
941 	size_t iosize;
942 	int error;
943 
944 	buf = NULL;
945 	error = 0;
946 	td = curthread;
947 	vap = &vattr;
948 	vp = ap->a_vp;
949 	len = *ap->a_len;
950 	offset = *ap->a_offset;
951 
952 	error = VOP_GETATTR(vp, vap, td->td_ucred);
953 	if (error != 0)
954 		goto out;
955 	fsize = vap->va_size;
956 	iosize = vap->va_blocksize;
957 	if (iosize == 0)
958 		iosize = BLKDEV_IOSIZE;
959 	if (iosize > MAXPHYS)
960 		iosize = MAXPHYS;
961 	buf = malloc(iosize, M_TEMP, M_WAITOK);
962 
963 #ifdef __notyet__
964 	/*
965 	 * Check if the filesystem sets f_maxfilesize; if not use
966 	 * VOP_SETATTR to perform the check.
967 	 */
968 	sfs = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
969 	error = VFS_STATFS(vp->v_mount, sfs, td);
970 	if (error == 0)
971 		maxfilesize = sfs->f_maxfilesize;
972 	free(sfs, M_STATFS);
973 	if (error != 0)
974 		goto out;
975 	if (maxfilesize) {
976 		if (offset > maxfilesize || len > maxfilesize ||
977 		    offset + len > maxfilesize) {
978 			error = EFBIG;
979 			goto out;
980 		}
981 	} else
982 #endif
983 	if (offset + len > vap->va_size) {
984 		/*
985 		 * Test offset + len against the filesystem's maxfilesize.
986 		 */
987 		VATTR_NULL(vap);
988 		vap->va_size = offset + len;
989 		error = VOP_SETATTR(vp, vap, td->td_ucred);
990 		if (error != 0)
991 			goto out;
992 		VATTR_NULL(vap);
993 		vap->va_size = fsize;
994 		error = VOP_SETATTR(vp, vap, td->td_ucred);
995 		if (error != 0)
996 			goto out;
997 	}
998 
999 	for (;;) {
1000 		/*
1001 		 * Read and write back anything below the nominal file
1002 		 * size.  There's currently no way outside the filesystem
1003 		 * to know whether this area is sparse or not.
1004 		 */
1005 		cur = iosize;
1006 		if ((offset % iosize) != 0)
1007 			cur -= (offset % iosize);
1008 		if (cur > len)
1009 			cur = len;
1010 		if (offset < fsize) {
1011 			aiov.iov_base = buf;
1012 			aiov.iov_len = cur;
1013 			auio.uio_iov = &aiov;
1014 			auio.uio_iovcnt = 1;
1015 			auio.uio_offset = offset;
1016 			auio.uio_resid = cur;
1017 			auio.uio_segflg = UIO_SYSSPACE;
1018 			auio.uio_rw = UIO_READ;
1019 			auio.uio_td = td;
1020 			error = VOP_READ(vp, &auio, 0, td->td_ucred);
1021 			if (error != 0)
1022 				break;
1023 			if (auio.uio_resid > 0) {
1024 				bzero(buf + cur - auio.uio_resid,
1025 				    auio.uio_resid);
1026 			}
1027 		} else {
1028 			bzero(buf, cur);
1029 		}
1030 
1031 		aiov.iov_base = buf;
1032 		aiov.iov_len = cur;
1033 		auio.uio_iov = &aiov;
1034 		auio.uio_iovcnt = 1;
1035 		auio.uio_offset = offset;
1036 		auio.uio_resid = cur;
1037 		auio.uio_segflg = UIO_SYSSPACE;
1038 		auio.uio_rw = UIO_WRITE;
1039 		auio.uio_td = td;
1040 
1041 		error = VOP_WRITE(vp, &auio, 0, td->td_ucred);
1042 		if (error != 0)
1043 			break;
1044 
1045 		len -= cur;
1046 		offset += cur;
1047 		if (len == 0)
1048 			break;
1049 		if (should_yield())
1050 			break;
1051 	}
1052 
1053  out:
1054 	*ap->a_len = len;
1055 	*ap->a_offset = offset;
1056 	free(buf, M_TEMP);
1057 	return (error);
1058 }
1059 
1060 int
1061 vop_stdadvise(struct vop_advise_args *ap)
1062 {
1063 	struct vnode *vp;
1064 	struct bufobj *bo;
1065 	daddr_t startn, endn;
1066 	off_t start, end;
1067 	int bsize, error;
1068 
1069 	vp = ap->a_vp;
1070 	switch (ap->a_advice) {
1071 	case POSIX_FADV_WILLNEED:
1072 		/*
1073 		 * Do nothing for now.  Filesystems should provide a
1074 		 * custom method which starts an asynchronous read of
1075 		 * the requested region.
1076 		 */
1077 		error = 0;
1078 		break;
1079 	case POSIX_FADV_DONTNEED:
1080 		error = 0;
1081 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1082 		if (vp->v_iflag & VI_DOOMED) {
1083 			VOP_UNLOCK(vp, 0);
1084 			break;
1085 		}
1086 
1087 		/*
1088 		 * Deactivate pages in the specified range from the backing VM
1089 		 * object.  Pages that are resident in the buffer cache will
1090 		 * remain wired until their corresponding buffers are released
1091 		 * below.
1092 		 */
1093 		if (vp->v_object != NULL) {
1094 			start = trunc_page(ap->a_start);
1095 			end = round_page(ap->a_end);
1096 			VM_OBJECT_RLOCK(vp->v_object);
1097 			vm_object_page_noreuse(vp->v_object, OFF_TO_IDX(start),
1098 			    OFF_TO_IDX(end));
1099 			VM_OBJECT_RUNLOCK(vp->v_object);
1100 		}
1101 
1102 		bo = &vp->v_bufobj;
1103 		BO_RLOCK(bo);
1104 		bsize = vp->v_bufobj.bo_bsize;
1105 		startn = ap->a_start / bsize;
1106 		endn = ap->a_end / bsize;
1107 		error = bnoreuselist(&bo->bo_clean, bo, startn, endn);
1108 		if (error == 0)
1109 			error = bnoreuselist(&bo->bo_dirty, bo, startn, endn);
1110 		BO_RUNLOCK(bo);
1111 		VOP_UNLOCK(vp, 0);
1112 		break;
1113 	default:
1114 		error = EINVAL;
1115 		break;
1116 	}
1117 	return (error);
1118 }
1119 
1120 int
1121 vop_stdunp_bind(struct vop_unp_bind_args *ap)
1122 {
1123 
1124 	ap->a_vp->v_unpcb = ap->a_unpcb;
1125 	return (0);
1126 }
1127 
1128 int
1129 vop_stdunp_connect(struct vop_unp_connect_args *ap)
1130 {
1131 
1132 	*ap->a_unpcb = ap->a_vp->v_unpcb;
1133 	return (0);
1134 }
1135 
1136 int
1137 vop_stdunp_detach(struct vop_unp_detach_args *ap)
1138 {
1139 
1140 	ap->a_vp->v_unpcb = NULL;
1141 	return (0);
1142 }
1143 
1144 static int
1145 vop_stdis_text(struct vop_is_text_args *ap)
1146 {
1147 
1148 	return ((ap->a_vp->v_vflag & VV_TEXT) != 0);
1149 }
1150 
1151 static int
1152 vop_stdset_text(struct vop_set_text_args *ap)
1153 {
1154 
1155 	ap->a_vp->v_vflag |= VV_TEXT;
1156 	return (0);
1157 }
1158 
1159 static int
1160 vop_stdunset_text(struct vop_unset_text_args *ap)
1161 {
1162 
1163 	ap->a_vp->v_vflag &= ~VV_TEXT;
1164 	return (0);
1165 }
1166 
1167 static int
1168 vop_stdget_writecount(struct vop_get_writecount_args *ap)
1169 {
1170 
1171 	*ap->a_writecount = ap->a_vp->v_writecount;
1172 	return (0);
1173 }
1174 
1175 static int
1176 vop_stdadd_writecount(struct vop_add_writecount_args *ap)
1177 {
1178 
1179 	ap->a_vp->v_writecount += ap->a_inc;
1180 	return (0);
1181 }
1182 
1183 /*
1184  * vfs default ops
1185  * used to fill the vfs function table to get reasonable default return values.
1186  */
1187 int
1188 vfs_stdroot (mp, flags, vpp)
1189 	struct mount *mp;
1190 	int flags;
1191 	struct vnode **vpp;
1192 {
1193 
1194 	return (EOPNOTSUPP);
1195 }
1196 
1197 int
1198 vfs_stdstatfs (mp, sbp)
1199 	struct mount *mp;
1200 	struct statfs *sbp;
1201 {
1202 
1203 	return (EOPNOTSUPP);
1204 }
1205 
1206 int
1207 vfs_stdquotactl (mp, cmds, uid, arg)
1208 	struct mount *mp;
1209 	int cmds;
1210 	uid_t uid;
1211 	void *arg;
1212 {
1213 
1214 	return (EOPNOTSUPP);
1215 }
1216 
1217 int
1218 vfs_stdsync(mp, waitfor)
1219 	struct mount *mp;
1220 	int waitfor;
1221 {
1222 	struct vnode *vp, *mvp;
1223 	struct thread *td;
1224 	int error, lockreq, allerror = 0;
1225 
1226 	td = curthread;
1227 	lockreq = LK_EXCLUSIVE | LK_INTERLOCK;
1228 	if (waitfor != MNT_WAIT)
1229 		lockreq |= LK_NOWAIT;
1230 	/*
1231 	 * Force stale buffer cache information to be flushed.
1232 	 */
1233 loop:
1234 	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1235 		if (vp->v_bufobj.bo_dirty.bv_cnt == 0) {
1236 			VI_UNLOCK(vp);
1237 			continue;
1238 		}
1239 		if ((error = vget(vp, lockreq, td)) != 0) {
1240 			if (error == ENOENT) {
1241 				MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1242 				goto loop;
1243 			}
1244 			continue;
1245 		}
1246 		error = VOP_FSYNC(vp, waitfor, td);
1247 		if (error)
1248 			allerror = error;
1249 		vput(vp);
1250 	}
1251 	return (allerror);
1252 }
1253 
1254 int
1255 vfs_stdnosync (mp, waitfor)
1256 	struct mount *mp;
1257 	int waitfor;
1258 {
1259 
1260 	return (0);
1261 }
1262 
1263 int
1264 vfs_stdvget (mp, ino, flags, vpp)
1265 	struct mount *mp;
1266 	ino_t ino;
1267 	int flags;
1268 	struct vnode **vpp;
1269 {
1270 
1271 	return (EOPNOTSUPP);
1272 }
1273 
1274 int
1275 vfs_stdfhtovp (mp, fhp, flags, vpp)
1276 	struct mount *mp;
1277 	struct fid *fhp;
1278 	int flags;
1279 	struct vnode **vpp;
1280 {
1281 
1282 	return (EOPNOTSUPP);
1283 }
1284 
1285 int
1286 vfs_stdinit (vfsp)
1287 	struct vfsconf *vfsp;
1288 {
1289 
1290 	return (0);
1291 }
1292 
1293 int
1294 vfs_stduninit (vfsp)
1295 	struct vfsconf *vfsp;
1296 {
1297 
1298 	return(0);
1299 }
1300 
1301 int
1302 vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname)
1303 	struct mount *mp;
1304 	int cmd;
1305 	struct vnode *filename_vp;
1306 	int attrnamespace;
1307 	const char *attrname;
1308 {
1309 
1310 	if (filename_vp != NULL)
1311 		VOP_UNLOCK(filename_vp, 0);
1312 	return (EOPNOTSUPP);
1313 }
1314 
1315 int
1316 vfs_stdsysctl(mp, op, req)
1317 	struct mount *mp;
1318 	fsctlop_t op;
1319 	struct sysctl_req *req;
1320 {
1321 
1322 	return (EOPNOTSUPP);
1323 }
1324 
1325 /* end of vfs default ops */
1326