xref: /freebsd/sys/kern/vfs_subr.c (revision 02f27f1cfa619cdf9509c65366f55f7c8803de5c)
1 /*-
2  * Copyright (c) 1989, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 4. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  *	@(#)vfs_subr.c	8.31 (Berkeley) 5/26/95
35  */
36 
37 /*
38  * External virtual filesystem routines
39  */
40 
41 #include <sys/cdefs.h>
42 __FBSDID("$FreeBSD$");
43 
44 #include "opt_ddb.h"
45 #include "opt_mac.h"
46 
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/bio.h>
50 #include <sys/buf.h>
51 #include <sys/conf.h>
52 #include <sys/dirent.h>
53 #include <sys/event.h>
54 #include <sys/eventhandler.h>
55 #include <sys/extattr.h>
56 #include <sys/file.h>
57 #include <sys/fcntl.h>
58 #include <sys/jail.h>
59 #include <sys/kdb.h>
60 #include <sys/kernel.h>
61 #include <sys/kthread.h>
62 #include <sys/malloc.h>
63 #include <sys/mount.h>
64 #include <sys/namei.h>
65 #include <sys/priv.h>
66 #include <sys/reboot.h>
67 #include <sys/sleepqueue.h>
68 #include <sys/stat.h>
69 #include <sys/sysctl.h>
70 #include <sys/syslog.h>
71 #include <sys/vmmeter.h>
72 #include <sys/vnode.h>
73 
74 #include <machine/stdarg.h>
75 
76 #include <security/mac/mac_framework.h>
77 
78 #include <vm/vm.h>
79 #include <vm/vm_object.h>
80 #include <vm/vm_extern.h>
81 #include <vm/pmap.h>
82 #include <vm/vm_map.h>
83 #include <vm/vm_page.h>
84 #include <vm/vm_kern.h>
85 #include <vm/uma.h>
86 
87 #ifdef DDB
88 #include <ddb/ddb.h>
89 #endif
90 
91 static MALLOC_DEFINE(M_NETADDR, "subr_export_host", "Export host address structure");
92 
93 static void	delmntque(struct vnode *vp);
94 static int	flushbuflist(struct bufv *bufv, int flags, struct bufobj *bo,
95 		    int slpflag, int slptimeo);
96 static void	syncer_shutdown(void *arg, int howto);
97 static int	vtryrecycle(struct vnode *vp);
98 static void	vbusy(struct vnode *vp);
99 static void	vinactive(struct vnode *, struct thread *);
100 static void	v_incr_usecount(struct vnode *);
101 static void	v_decr_usecount(struct vnode *);
102 static void	v_decr_useonly(struct vnode *);
103 static void	v_upgrade_usecount(struct vnode *);
104 static void	vfree(struct vnode *);
105 static void	vnlru_free(int);
106 static void	vdestroy(struct vnode *);
107 static void	vgonel(struct vnode *);
108 static void	vfs_knllock(void *arg);
109 static void	vfs_knlunlock(void *arg);
110 static int	vfs_knllocked(void *arg);
111 
112 
113 /*
114  * Enable Giant pushdown based on whether or not the vm is mpsafe in this
115  * build.  Without mpsafevm the buffer cache can not run Giant free.
116  */
117 int mpsafe_vfs = 1;
118 TUNABLE_INT("debug.mpsafevfs", &mpsafe_vfs);
119 SYSCTL_INT(_debug, OID_AUTO, mpsafevfs, CTLFLAG_RD, &mpsafe_vfs, 0,
120     "MPSAFE VFS");
121 
122 /*
123  * Number of vnodes in existence.  Increased whenever getnewvnode()
124  * allocates a new vnode, decreased on vdestroy() called on VI_DOOMed
125  * vnode.
126  */
127 static unsigned long	numvnodes;
128 
129 SYSCTL_LONG(_vfs, OID_AUTO, numvnodes, CTLFLAG_RD, &numvnodes, 0, "");
130 
131 /*
132  * Conversion tables for conversion from vnode types to inode formats
133  * and back.
134  */
135 enum vtype iftovt_tab[16] = {
136 	VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
137 	VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
138 };
139 int vttoif_tab[10] = {
140 	0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
141 	S_IFSOCK, S_IFIFO, S_IFMT, S_IFMT
142 };
143 
144 /*
145  * List of vnodes that are ready for recycling.
146  */
147 static TAILQ_HEAD(freelst, vnode) vnode_free_list;
148 
149 /*
150  * Free vnode target.  Free vnodes may simply be files which have been stat'd
151  * but not read.  This is somewhat common, and a small cache of such files
152  * should be kept to avoid recreation costs.
153  */
154 static u_long wantfreevnodes;
155 SYSCTL_LONG(_vfs, OID_AUTO, wantfreevnodes, CTLFLAG_RW, &wantfreevnodes, 0, "");
156 /* Number of vnodes in the free list. */
157 static u_long freevnodes;
158 SYSCTL_LONG(_vfs, OID_AUTO, freevnodes, CTLFLAG_RD, &freevnodes, 0, "");
159 
160 /*
161  * Various variables used for debugging the new implementation of
162  * reassignbuf().
163  * XXX these are probably of (very) limited utility now.
164  */
165 static int reassignbufcalls;
166 SYSCTL_INT(_vfs, OID_AUTO, reassignbufcalls, CTLFLAG_RW, &reassignbufcalls, 0, "");
167 
168 /*
169  * Cache for the mount type id assigned to NFS.  This is used for
170  * special checks in nfs/nfs_nqlease.c and vm/vnode_pager.c.
171  */
172 int	nfs_mount_type = -1;
173 
174 /* To keep more than one thread at a time from running vfs_getnewfsid */
175 static struct mtx mntid_mtx;
176 
177 /*
178  * Lock for any access to the following:
179  *	vnode_free_list
180  *	numvnodes
181  *	freevnodes
182  */
183 static struct mtx vnode_free_list_mtx;
184 
185 /* Publicly exported FS */
186 struct nfs_public nfs_pub;
187 
188 /* Zone for allocation of new vnodes - used exclusively by getnewvnode() */
189 static uma_zone_t vnode_zone;
190 static uma_zone_t vnodepoll_zone;
191 
192 /* Set to 1 to print out reclaim of active vnodes */
193 int	prtactive;
194 
195 /*
196  * The workitem queue.
197  *
198  * It is useful to delay writes of file data and filesystem metadata
199  * for tens of seconds so that quickly created and deleted files need
200  * not waste disk bandwidth being created and removed. To realize this,
201  * we append vnodes to a "workitem" queue. When running with a soft
202  * updates implementation, most pending metadata dependencies should
203  * not wait for more than a few seconds. Thus, mounted on block devices
204  * are delayed only about a half the time that file data is delayed.
205  * Similarly, directory updates are more critical, so are only delayed
206  * about a third the time that file data is delayed. Thus, there are
207  * SYNCER_MAXDELAY queues that are processed round-robin at a rate of
208  * one each second (driven off the filesystem syncer process). The
209  * syncer_delayno variable indicates the next queue that is to be processed.
210  * Items that need to be processed soon are placed in this queue:
211  *
212  *	syncer_workitem_pending[syncer_delayno]
213  *
214  * A delay of fifteen seconds is done by placing the request fifteen
215  * entries later in the queue:
216  *
217  *	syncer_workitem_pending[(syncer_delayno + 15) & syncer_mask]
218  *
219  */
220 static int syncer_delayno;
221 static long syncer_mask;
222 LIST_HEAD(synclist, bufobj);
223 static struct synclist *syncer_workitem_pending;
224 /*
225  * The sync_mtx protects:
226  *	bo->bo_synclist
227  *	sync_vnode_count
228  *	syncer_delayno
229  *	syncer_state
230  *	syncer_workitem_pending
231  *	syncer_worklist_len
232  *	rushjob
233  */
234 static struct mtx sync_mtx;
235 
236 #define SYNCER_MAXDELAY		32
237 static int syncer_maxdelay = SYNCER_MAXDELAY;	/* maximum delay time */
238 static int syncdelay = 30;		/* max time to delay syncing data */
239 static int filedelay = 30;		/* time to delay syncing files */
240 SYSCTL_INT(_kern, OID_AUTO, filedelay, CTLFLAG_RW, &filedelay, 0, "");
241 static int dirdelay = 29;		/* time to delay syncing directories */
242 SYSCTL_INT(_kern, OID_AUTO, dirdelay, CTLFLAG_RW, &dirdelay, 0, "");
243 static int metadelay = 28;		/* time to delay syncing metadata */
244 SYSCTL_INT(_kern, OID_AUTO, metadelay, CTLFLAG_RW, &metadelay, 0, "");
245 static int rushjob;		/* number of slots to run ASAP */
246 static int stat_rush_requests;	/* number of times I/O speeded up */
247 SYSCTL_INT(_debug, OID_AUTO, rush_requests, CTLFLAG_RW, &stat_rush_requests, 0, "");
248 
249 /*
250  * When shutting down the syncer, run it at four times normal speed.
251  */
252 #define SYNCER_SHUTDOWN_SPEEDUP		4
253 static int sync_vnode_count;
254 static int syncer_worklist_len;
255 static enum { SYNCER_RUNNING, SYNCER_SHUTTING_DOWN, SYNCER_FINAL_DELAY }
256     syncer_state;
257 
258 /*
259  * Number of vnodes we want to exist at any one time.  This is mostly used
260  * to size hash tables in vnode-related code.  It is normally not used in
261  * getnewvnode(), as wantfreevnodes is normally nonzero.)
262  *
263  * XXX desiredvnodes is historical cruft and should not exist.
264  */
265 int desiredvnodes;
266 SYSCTL_INT(_kern, KERN_MAXVNODES, maxvnodes, CTLFLAG_RW,
267     &desiredvnodes, 0, "Maximum number of vnodes");
268 SYSCTL_INT(_kern, OID_AUTO, minvnodes, CTLFLAG_RW,
269     &wantfreevnodes, 0, "Minimum number of vnodes (legacy)");
270 static int vnlru_nowhere;
271 SYSCTL_INT(_debug, OID_AUTO, vnlru_nowhere, CTLFLAG_RW,
272     &vnlru_nowhere, 0, "Number of times the vnlru process ran without success");
273 
274 /*
275  * Macros to control when a vnode is freed and recycled.  All require
276  * the vnode interlock.
277  */
278 #define VCANRECYCLE(vp) (((vp)->v_iflag & VI_FREE) && !(vp)->v_holdcnt)
279 #define VSHOULDFREE(vp) (!((vp)->v_iflag & VI_FREE) && !(vp)->v_holdcnt)
280 #define VSHOULDBUSY(vp) (((vp)->v_iflag & VI_FREE) && (vp)->v_holdcnt)
281 
282 
283 /*
284  * Initialize the vnode management data structures.
285  */
286 #ifndef	MAXVNODES_MAX
287 #define	MAXVNODES_MAX	100000
288 #endif
289 static void
290 vntblinit(void *dummy __unused)
291 {
292 
293 	/*
294 	 * Desiredvnodes is a function of the physical memory size and
295 	 * the kernel's heap size.  Specifically, desiredvnodes scales
296 	 * in proportion to the physical memory size until two fifths
297 	 * of the kernel's heap size is consumed by vnodes and vm
298 	 * objects.
299 	 */
300 	desiredvnodes = min(maxproc + cnt.v_page_count / 4, 2 * vm_kmem_size /
301 	    (5 * (sizeof(struct vm_object) + sizeof(struct vnode))));
302 	if (desiredvnodes > MAXVNODES_MAX) {
303 		if (bootverbose)
304 			printf("Reducing kern.maxvnodes %d -> %d\n",
305 			    desiredvnodes, MAXVNODES_MAX);
306 		desiredvnodes = MAXVNODES_MAX;
307 	}
308 	wantfreevnodes = desiredvnodes / 4;
309 	mtx_init(&mntid_mtx, "mntid", NULL, MTX_DEF);
310 	TAILQ_INIT(&vnode_free_list);
311 	mtx_init(&vnode_free_list_mtx, "vnode_free_list", NULL, MTX_DEF);
312 	vnode_zone = uma_zcreate("VNODE", sizeof (struct vnode), NULL, NULL,
313 	    NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
314 	vnodepoll_zone = uma_zcreate("VNODEPOLL", sizeof (struct vpollinfo),
315 	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
316 	/*
317 	 * Initialize the filesystem syncer.
318 	 */
319 	syncer_workitem_pending = hashinit(syncer_maxdelay, M_VNODE,
320 		&syncer_mask);
321 	syncer_maxdelay = syncer_mask + 1;
322 	mtx_init(&sync_mtx, "Syncer mtx", NULL, MTX_DEF);
323 }
324 SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_FIRST, vntblinit, NULL)
325 
326 
327 /*
328  * Mark a mount point as busy. Used to synchronize access and to delay
329  * unmounting. Interlock is not released on failure.
330  */
331 int
332 vfs_busy(struct mount *mp, int flags, struct mtx *interlkp,
333     struct thread *td)
334 {
335 	int lkflags;
336 
337 	MNT_ILOCK(mp);
338 	MNT_REF(mp);
339 	if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
340 		if (flags & LK_NOWAIT) {
341 			MNT_REL(mp);
342 			MNT_IUNLOCK(mp);
343 			return (ENOENT);
344 		}
345 		if (interlkp)
346 			mtx_unlock(interlkp);
347 		mp->mnt_kern_flag |= MNTK_MWAIT;
348 		/*
349 		 * Since all busy locks are shared except the exclusive
350 		 * lock granted when unmounting, the only place that a
351 		 * wakeup needs to be done is at the release of the
352 		 * exclusive lock at the end of dounmount.
353 		 */
354 		msleep(mp, MNT_MTX(mp), PVFS, "vfs_busy", 0);
355 		MNT_REL(mp);
356 		MNT_IUNLOCK(mp);
357 		if (interlkp)
358 			mtx_lock(interlkp);
359 		return (ENOENT);
360 	}
361 	if (interlkp)
362 		mtx_unlock(interlkp);
363 	lkflags = LK_SHARED | LK_INTERLOCK;
364 	if (lockmgr(&mp->mnt_lock, lkflags, MNT_MTX(mp)))
365 		panic("vfs_busy: unexpected lock failure");
366 	return (0);
367 }
368 
369 /*
370  * Free a busy filesystem.
371  */
372 void
373 vfs_unbusy(struct mount *mp, struct thread *td)
374 {
375 
376 	lockmgr(&mp->mnt_lock, LK_RELEASE, NULL);
377 	vfs_rel(mp);
378 }
379 
380 /*
381  * Lookup a mount point by filesystem identifier.
382  */
383 struct mount *
384 vfs_getvfs(fsid_t *fsid)
385 {
386 	struct mount *mp;
387 
388 	mtx_lock(&mountlist_mtx);
389 	TAILQ_FOREACH(mp, &mountlist, mnt_list) {
390 		if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
391 		    mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
392 			vfs_ref(mp);
393 			mtx_unlock(&mountlist_mtx);
394 			return (mp);
395 		}
396 	}
397 	mtx_unlock(&mountlist_mtx);
398 	return ((struct mount *) 0);
399 }
400 
401 /*
402  * Check if a user can access privileged mount options.
403  */
404 int
405 vfs_suser(struct mount *mp, struct thread *td)
406 {
407 	int error;
408 
409 	/*
410 	 * If the thread is jailed, but this is not a jail-friendly file
411 	 * system, deny immediately.
412 	 */
413 	if (jailed(td->td_ucred) && !(mp->mnt_vfc->vfc_flags & VFCF_JAIL))
414 		return (EPERM);
415 
416 	/*
417 	 * If the file system was mounted outside a jail and a jailed thread
418 	 * tries to access it, deny immediately.
419 	 */
420 	if (!jailed(mp->mnt_cred) && jailed(td->td_ucred))
421 		return (EPERM);
422 
423 	/*
424 	 * If the file system was mounted inside different jail that the jail of
425 	 * the calling thread, deny immediately.
426 	 */
427 	if (jailed(mp->mnt_cred) && jailed(td->td_ucred) &&
428 	    mp->mnt_cred->cr_prison != td->td_ucred->cr_prison) {
429 		return (EPERM);
430 	}
431 
432 	if ((mp->mnt_flag & MNT_USER) == 0 ||
433 	    mp->mnt_cred->cr_uid != td->td_ucred->cr_uid) {
434 		if ((error = priv_check(td, PRIV_VFS_MOUNT_OWNER)) != 0)
435 			return (error);
436 	}
437 	return (0);
438 }
439 
440 /*
441  * Get a new unique fsid.  Try to make its val[0] unique, since this value
442  * will be used to create fake device numbers for stat().  Also try (but
443  * not so hard) make its val[0] unique mod 2^16, since some emulators only
444  * support 16-bit device numbers.  We end up with unique val[0]'s for the
445  * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
446  *
447  * Keep in mind that several mounts may be running in parallel.  Starting
448  * the search one past where the previous search terminated is both a
449  * micro-optimization and a defense against returning the same fsid to
450  * different mounts.
451  */
452 void
453 vfs_getnewfsid(struct mount *mp)
454 {
455 	static u_int16_t mntid_base;
456 	struct mount *nmp;
457 	fsid_t tfsid;
458 	int mtype;
459 
460 	mtx_lock(&mntid_mtx);
461 	mtype = mp->mnt_vfc->vfc_typenum;
462 	tfsid.val[1] = mtype;
463 	mtype = (mtype & 0xFF) << 24;
464 	for (;;) {
465 		tfsid.val[0] = makedev(255,
466 		    mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF));
467 		mntid_base++;
468 		if ((nmp = vfs_getvfs(&tfsid)) == NULL)
469 			break;
470 		vfs_rel(nmp);
471 	}
472 	mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
473 	mp->mnt_stat.f_fsid.val[1] = tfsid.val[1];
474 	mtx_unlock(&mntid_mtx);
475 }
476 
477 /*
478  * Knob to control the precision of file timestamps:
479  *
480  *   0 = seconds only; nanoseconds zeroed.
481  *   1 = seconds and nanoseconds, accurate within 1/HZ.
482  *   2 = seconds and nanoseconds, truncated to microseconds.
483  * >=3 = seconds and nanoseconds, maximum precision.
484  */
485 enum { TSP_SEC, TSP_HZ, TSP_USEC, TSP_NSEC };
486 
487 static int timestamp_precision = TSP_SEC;
488 SYSCTL_INT(_vfs, OID_AUTO, timestamp_precision, CTLFLAG_RW,
489     &timestamp_precision, 0, "");
490 
491 /*
492  * Get a current timestamp.
493  */
494 void
495 vfs_timestamp(struct timespec *tsp)
496 {
497 	struct timeval tv;
498 
499 	switch (timestamp_precision) {
500 	case TSP_SEC:
501 		tsp->tv_sec = time_second;
502 		tsp->tv_nsec = 0;
503 		break;
504 	case TSP_HZ:
505 		getnanotime(tsp);
506 		break;
507 	case TSP_USEC:
508 		microtime(&tv);
509 		TIMEVAL_TO_TIMESPEC(&tv, tsp);
510 		break;
511 	case TSP_NSEC:
512 	default:
513 		nanotime(tsp);
514 		break;
515 	}
516 }
517 
518 /*
519  * Set vnode attributes to VNOVAL
520  */
521 void
522 vattr_null(struct vattr *vap)
523 {
524 
525 	vap->va_type = VNON;
526 	vap->va_size = VNOVAL;
527 	vap->va_bytes = VNOVAL;
528 	vap->va_mode = VNOVAL;
529 	vap->va_nlink = VNOVAL;
530 	vap->va_uid = VNOVAL;
531 	vap->va_gid = VNOVAL;
532 	vap->va_fsid = VNOVAL;
533 	vap->va_fileid = VNOVAL;
534 	vap->va_blocksize = VNOVAL;
535 	vap->va_rdev = VNOVAL;
536 	vap->va_atime.tv_sec = VNOVAL;
537 	vap->va_atime.tv_nsec = VNOVAL;
538 	vap->va_mtime.tv_sec = VNOVAL;
539 	vap->va_mtime.tv_nsec = VNOVAL;
540 	vap->va_ctime.tv_sec = VNOVAL;
541 	vap->va_ctime.tv_nsec = VNOVAL;
542 	vap->va_birthtime.tv_sec = VNOVAL;
543 	vap->va_birthtime.tv_nsec = VNOVAL;
544 	vap->va_flags = VNOVAL;
545 	vap->va_gen = VNOVAL;
546 	vap->va_vaflags = 0;
547 }
548 
549 /*
550  * This routine is called when we have too many vnodes.  It attempts
551  * to free <count> vnodes and will potentially free vnodes that still
552  * have VM backing store (VM backing store is typically the cause
553  * of a vnode blowout so we want to do this).  Therefore, this operation
554  * is not considered cheap.
555  *
556  * A number of conditions may prevent a vnode from being reclaimed.
557  * the buffer cache may have references on the vnode, a directory
558  * vnode may still have references due to the namei cache representing
559  * underlying files, or the vnode may be in active use.   It is not
560  * desireable to reuse such vnodes.  These conditions may cause the
561  * number of vnodes to reach some minimum value regardless of what
562  * you set kern.maxvnodes to.  Do not set kern.maxvnodes too low.
563  */
564 static int
565 vlrureclaim(struct mount *mp)
566 {
567 	struct thread *td;
568 	struct vnode *vp;
569 	int done;
570 	int trigger;
571 	int usevnodes;
572 	int count;
573 
574 	/*
575 	 * Calculate the trigger point, don't allow user
576 	 * screwups to blow us up.   This prevents us from
577 	 * recycling vnodes with lots of resident pages.  We
578 	 * aren't trying to free memory, we are trying to
579 	 * free vnodes.
580 	 */
581 	usevnodes = desiredvnodes;
582 	if (usevnodes <= 0)
583 		usevnodes = 1;
584 	trigger = cnt.v_page_count * 2 / usevnodes;
585 	done = 0;
586 	td = curthread;
587 	vn_start_write(NULL, &mp, V_WAIT);
588 	MNT_ILOCK(mp);
589 	count = mp->mnt_nvnodelistsize / 10 + 1;
590 	while (count != 0) {
591 		vp = TAILQ_FIRST(&mp->mnt_nvnodelist);
592 		while (vp != NULL && vp->v_type == VMARKER)
593 			vp = TAILQ_NEXT(vp, v_nmntvnodes);
594 		if (vp == NULL)
595 			break;
596 		TAILQ_REMOVE(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
597 		TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
598 		--count;
599 		if (!VI_TRYLOCK(vp))
600 			goto next_iter;
601 		/*
602 		 * If it's been deconstructed already, it's still
603 		 * referenced, or it exceeds the trigger, skip it.
604 		 */
605 		if (vp->v_usecount || !LIST_EMPTY(&(vp)->v_cache_src) ||
606 		    (vp->v_iflag & VI_DOOMED) != 0 || (vp->v_object != NULL &&
607 		    vp->v_object->resident_page_count > trigger)) {
608 			VI_UNLOCK(vp);
609 			goto next_iter;
610 		}
611 		MNT_IUNLOCK(mp);
612 		vholdl(vp);
613 		if (VOP_LOCK(vp, LK_INTERLOCK|LK_EXCLUSIVE|LK_NOWAIT)) {
614 			vdrop(vp);
615 			goto next_iter_mntunlocked;
616 		}
617 		VI_LOCK(vp);
618 		/*
619 		 * v_usecount may have been bumped after VOP_LOCK() dropped
620 		 * the vnode interlock and before it was locked again.
621 		 *
622 		 * It is not necessary to recheck VI_DOOMED because it can
623 		 * only be set by another thread that holds both the vnode
624 		 * lock and vnode interlock.  If another thread has the
625 		 * vnode lock before we get to VOP_LOCK() and obtains the
626 		 * vnode interlock after VOP_LOCK() drops the vnode
627 		 * interlock, the other thread will be unable to drop the
628 		 * vnode lock before our VOP_LOCK() call fails.
629 		 */
630 		if (vp->v_usecount || !LIST_EMPTY(&(vp)->v_cache_src) ||
631 		    (vp->v_object != NULL &&
632 		    vp->v_object->resident_page_count > trigger)) {
633 			VOP_UNLOCK(vp, LK_INTERLOCK);
634 			goto next_iter_mntunlocked;
635 		}
636 		KASSERT((vp->v_iflag & VI_DOOMED) == 0,
637 		    ("VI_DOOMED unexpectedly detected in vlrureclaim()"));
638 		vgonel(vp);
639 		VOP_UNLOCK(vp, 0);
640 		vdropl(vp);
641 		done++;
642 next_iter_mntunlocked:
643 		if ((count % 256) != 0)
644 			goto relock_mnt;
645 		goto yield;
646 next_iter:
647 		if ((count % 256) != 0)
648 			continue;
649 		MNT_IUNLOCK(mp);
650 yield:
651 		uio_yield();
652 relock_mnt:
653 		MNT_ILOCK(mp);
654 	}
655 	MNT_IUNLOCK(mp);
656 	vn_finished_write(mp);
657 	return done;
658 }
659 
660 /*
661  * Attempt to keep the free list at wantfreevnodes length.
662  */
663 static void
664 vnlru_free(int count)
665 {
666 	struct vnode *vp;
667 	int vfslocked;
668 
669 	mtx_assert(&vnode_free_list_mtx, MA_OWNED);
670 	for (; count > 0; count--) {
671 		vp = TAILQ_FIRST(&vnode_free_list);
672 		/*
673 		 * The list can be modified while the free_list_mtx
674 		 * has been dropped and vp could be NULL here.
675 		 */
676 		if (!vp)
677 			break;
678 		VNASSERT(vp->v_op != NULL, vp,
679 		    ("vnlru_free: vnode already reclaimed."));
680 		TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
681 		/*
682 		 * Don't recycle if we can't get the interlock.
683 		 */
684 		if (!VI_TRYLOCK(vp)) {
685 			TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
686 			continue;
687 		}
688 		VNASSERT(VCANRECYCLE(vp), vp,
689 		    ("vp inconsistent on freelist"));
690 		freevnodes--;
691 		vp->v_iflag &= ~VI_FREE;
692 		vholdl(vp);
693 		mtx_unlock(&vnode_free_list_mtx);
694 		VI_UNLOCK(vp);
695 		vfslocked = VFS_LOCK_GIANT(vp->v_mount);
696 		vtryrecycle(vp);
697 		VFS_UNLOCK_GIANT(vfslocked);
698 		/*
699 		 * If the recycled succeeded this vdrop will actually free
700 		 * the vnode.  If not it will simply place it back on
701 		 * the free list.
702 		 */
703 		vdrop(vp);
704 		mtx_lock(&vnode_free_list_mtx);
705 	}
706 }
707 /*
708  * Attempt to recycle vnodes in a context that is always safe to block.
709  * Calling vlrurecycle() from the bowels of filesystem code has some
710  * interesting deadlock problems.
711  */
712 static struct proc *vnlruproc;
713 static int vnlruproc_sig;
714 
715 static void
716 vnlru_proc(void)
717 {
718 	struct mount *mp, *nmp;
719 	int done;
720 	struct proc *p = vnlruproc;
721 	struct thread *td = curthread;
722 
723 	EVENTHANDLER_REGISTER(shutdown_pre_sync, kproc_shutdown, p,
724 	    SHUTDOWN_PRI_FIRST);
725 
726 	mtx_lock(&Giant);
727 
728 	for (;;) {
729 		kproc_suspend_check(p);
730 		mtx_lock(&vnode_free_list_mtx);
731 		if (freevnodes > wantfreevnodes)
732 			vnlru_free(freevnodes - wantfreevnodes);
733 		if (numvnodes <= desiredvnodes * 9 / 10) {
734 			vnlruproc_sig = 0;
735 			wakeup(&vnlruproc_sig);
736 			msleep(vnlruproc, &vnode_free_list_mtx,
737 			    PVFS|PDROP, "vlruwt", hz);
738 			continue;
739 		}
740 		mtx_unlock(&vnode_free_list_mtx);
741 		done = 0;
742 		mtx_lock(&mountlist_mtx);
743 		for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
744 			int vfsunlocked;
745 			if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
746 				nmp = TAILQ_NEXT(mp, mnt_list);
747 				continue;
748 			}
749 			if (!VFS_NEEDSGIANT(mp)) {
750 				mtx_unlock(&Giant);
751 				vfsunlocked = 1;
752 			} else
753 				vfsunlocked = 0;
754 			done += vlrureclaim(mp);
755 			if (vfsunlocked)
756 				mtx_lock(&Giant);
757 			mtx_lock(&mountlist_mtx);
758 			nmp = TAILQ_NEXT(mp, mnt_list);
759 			vfs_unbusy(mp, td);
760 		}
761 		mtx_unlock(&mountlist_mtx);
762 		if (done == 0) {
763 			EVENTHANDLER_INVOKE(vfs_lowvnodes, desiredvnodes / 10);
764 #if 0
765 			/* These messages are temporary debugging aids */
766 			if (vnlru_nowhere < 5)
767 				printf("vnlru process getting nowhere..\n");
768 			else if (vnlru_nowhere == 5)
769 				printf("vnlru process messages stopped.\n");
770 #endif
771 			vnlru_nowhere++;
772 			tsleep(vnlruproc, PPAUSE, "vlrup", hz * 3);
773 		} else
774 			uio_yield();
775 	}
776 }
777 
778 static struct kproc_desc vnlru_kp = {
779 	"vnlru",
780 	vnlru_proc,
781 	&vnlruproc
782 };
783 SYSINIT(vnlru, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &vnlru_kp)
784 
785 /*
786  * Routines having to do with the management of the vnode table.
787  */
788 
789 static void
790 vdestroy(struct vnode *vp)
791 {
792 	struct bufobj *bo;
793 
794 	CTR1(KTR_VFS, "vdestroy vp %p", vp);
795 	mtx_lock(&vnode_free_list_mtx);
796 	numvnodes--;
797 	mtx_unlock(&vnode_free_list_mtx);
798 	bo = &vp->v_bufobj;
799 	VNASSERT((vp->v_iflag & VI_FREE) == 0, vp,
800 	    ("cleaned vnode still on the free list."));
801 	VNASSERT(vp->v_data == NULL, vp, ("cleaned vnode isn't"));
802 	VNASSERT(vp->v_holdcnt == 0, vp, ("Non-zero hold count"));
803 	VNASSERT(vp->v_usecount == 0, vp, ("Non-zero use count"));
804 	VNASSERT(vp->v_writecount == 0, vp, ("Non-zero write count"));
805 	VNASSERT(bo->bo_numoutput == 0, vp, ("Clean vnode has pending I/O's"));
806 	VNASSERT(bo->bo_clean.bv_cnt == 0, vp, ("cleanbufcnt not 0"));
807 	VNASSERT(bo->bo_clean.bv_root == NULL, vp, ("cleanblkroot not NULL"));
808 	VNASSERT(bo->bo_dirty.bv_cnt == 0, vp, ("dirtybufcnt not 0"));
809 	VNASSERT(bo->bo_dirty.bv_root == NULL, vp, ("dirtyblkroot not NULL"));
810 	VNASSERT(TAILQ_EMPTY(&vp->v_cache_dst), vp, ("vp has namecache dst"));
811 	VNASSERT(LIST_EMPTY(&vp->v_cache_src), vp, ("vp has namecache src"));
812 	VI_UNLOCK(vp);
813 #ifdef MAC
814 	mac_vnode_destroy(vp);
815 #endif
816 	if (vp->v_pollinfo != NULL) {
817 		knlist_destroy(&vp->v_pollinfo->vpi_selinfo.si_note);
818 		mtx_destroy(&vp->v_pollinfo->vpi_lock);
819 		uma_zfree(vnodepoll_zone, vp->v_pollinfo);
820 	}
821 #ifdef INVARIANTS
822 	/* XXX Elsewhere we can detect an already freed vnode via NULL v_op. */
823 	vp->v_op = NULL;
824 #endif
825 	lockdestroy(vp->v_vnlock);
826 	mtx_destroy(&vp->v_interlock);
827 	uma_zfree(vnode_zone, vp);
828 }
829 
830 /*
831  * Try to recycle a freed vnode.  We abort if anyone picks up a reference
832  * before we actually vgone().  This function must be called with the vnode
833  * held to prevent the vnode from being returned to the free list midway
834  * through vgone().
835  */
836 static int
837 vtryrecycle(struct vnode *vp)
838 {
839 	struct mount *vnmp;
840 
841 	CTR1(KTR_VFS, "vtryrecycle: trying vp %p", vp);
842 	VNASSERT(vp->v_holdcnt, vp,
843 	    ("vtryrecycle: Recycling vp %p without a reference.", vp));
844 	/*
845 	 * This vnode may found and locked via some other list, if so we
846 	 * can't recycle it yet.
847 	 */
848 	if (VOP_LOCK(vp, LK_EXCLUSIVE | LK_NOWAIT) != 0)
849 		return (EWOULDBLOCK);
850 	/*
851 	 * Don't recycle if its filesystem is being suspended.
852 	 */
853 	if (vn_start_write(vp, &vnmp, V_NOWAIT) != 0) {
854 		VOP_UNLOCK(vp, 0);
855 		return (EBUSY);
856 	}
857 	/*
858 	 * If we got this far, we need to acquire the interlock and see if
859 	 * anyone picked up this vnode from another list.  If not, we will
860 	 * mark it with DOOMED via vgonel() so that anyone who does find it
861 	 * will skip over it.
862 	 */
863 	VI_LOCK(vp);
864 	if (vp->v_usecount) {
865 		VOP_UNLOCK(vp, LK_INTERLOCK);
866 		vn_finished_write(vnmp);
867 		return (EBUSY);
868 	}
869 	if ((vp->v_iflag & VI_DOOMED) == 0)
870 		vgonel(vp);
871 	VOP_UNLOCK(vp, LK_INTERLOCK);
872 	vn_finished_write(vnmp);
873 	CTR1(KTR_VFS, "vtryrecycle: recycled vp %p", vp);
874 	return (0);
875 }
876 
877 /*
878  * Return the next vnode from the free list.
879  */
880 int
881 getnewvnode(const char *tag, struct mount *mp, struct vop_vector *vops,
882     struct vnode **vpp)
883 {
884 	struct vnode *vp = NULL;
885 	struct bufobj *bo;
886 
887 	mtx_lock(&vnode_free_list_mtx);
888 	/*
889 	 * Lend our context to reclaim vnodes if they've exceeded the max.
890 	 */
891 	if (freevnodes > wantfreevnodes)
892 		vnlru_free(1);
893 	/*
894 	 * Wait for available vnodes.
895 	 */
896 	if (numvnodes > desiredvnodes) {
897 		if (mp != NULL && (mp->mnt_kern_flag & MNTK_SUSPEND)) {
898 			/*
899 			 * File system is beeing suspended, we cannot risk a
900 			 * deadlock here, so allocate new vnode anyway.
901 			 */
902 			if (freevnodes > wantfreevnodes)
903 				vnlru_free(freevnodes - wantfreevnodes);
904 			goto alloc;
905 		}
906 		if (vnlruproc_sig == 0) {
907 			vnlruproc_sig = 1;	/* avoid unnecessary wakeups */
908 			wakeup(vnlruproc);
909 		}
910 		msleep(&vnlruproc_sig, &vnode_free_list_mtx, PVFS,
911 		    "vlruwk", hz);
912 #if 0	/* XXX Not all VFS_VGET/ffs_vget callers check returns. */
913 		if (numvnodes > desiredvnodes) {
914 			mtx_unlock(&vnode_free_list_mtx);
915 			return (ENFILE);
916 		}
917 #endif
918 	}
919 alloc:
920 	numvnodes++;
921 	mtx_unlock(&vnode_free_list_mtx);
922 	vp = (struct vnode *) uma_zalloc(vnode_zone, M_WAITOK|M_ZERO);
923 	/*
924 	 * Setup locks.
925 	 */
926 	vp->v_vnlock = &vp->v_lock;
927 	mtx_init(&vp->v_interlock, "vnode interlock", NULL, MTX_DEF);
928 	/*
929 	 * By default, don't allow shared locks unless filesystems
930 	 * opt-in.
931 	 */
932 	lockinit(vp->v_vnlock, PVFS, tag, VLKTIMEOUT, LK_NOSHARE);
933 	/*
934 	 * Initialize bufobj.
935 	 */
936 	bo = &vp->v_bufobj;
937 	bo->__bo_vnode = vp;
938 	bo->bo_mtx = &vp->v_interlock;
939 	bo->bo_ops = &buf_ops_bio;
940 	bo->bo_private = vp;
941 	TAILQ_INIT(&bo->bo_clean.bv_hd);
942 	TAILQ_INIT(&bo->bo_dirty.bv_hd);
943 	/*
944 	 * Initialize namecache.
945 	 */
946 	LIST_INIT(&vp->v_cache_src);
947 	TAILQ_INIT(&vp->v_cache_dst);
948 	/*
949 	 * Finalize various vnode identity bits.
950 	 */
951 	vp->v_type = VNON;
952 	vp->v_tag = tag;
953 	vp->v_op = vops;
954 	v_incr_usecount(vp);
955 	vp->v_data = 0;
956 #ifdef MAC
957 	mac_vnode_init(vp);
958 	if (mp != NULL && (mp->mnt_flag & MNT_MULTILABEL) == 0)
959 		mac_vnode_associate_singlelabel(mp, vp);
960 	else if (mp == NULL)
961 		printf("NULL mp in getnewvnode()\n");
962 #endif
963 	if (mp != NULL) {
964 		bo->bo_bsize = mp->mnt_stat.f_iosize;
965 		if ((mp->mnt_kern_flag & MNTK_NOKNOTE) != 0)
966 			vp->v_vflag |= VV_NOKNOTE;
967 	}
968 
969 	CTR2(KTR_VFS, "getnewvnode: mp %p vp %p", mp, vp);
970 	*vpp = vp;
971 	return (0);
972 }
973 
974 /*
975  * Delete from old mount point vnode list, if on one.
976  */
977 static void
978 delmntque(struct vnode *vp)
979 {
980 	struct mount *mp;
981 
982 	mp = vp->v_mount;
983 	if (mp == NULL)
984 		return;
985 	MNT_ILOCK(mp);
986 	vp->v_mount = NULL;
987 	VNASSERT(mp->mnt_nvnodelistsize > 0, vp,
988 		("bad mount point vnode list size"));
989 	TAILQ_REMOVE(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
990 	mp->mnt_nvnodelistsize--;
991 	MNT_REL(mp);
992 	MNT_IUNLOCK(mp);
993 }
994 
995 static void
996 insmntque_stddtr(struct vnode *vp, void *dtr_arg)
997 {
998 
999 	vp->v_data = NULL;
1000 	vp->v_op = &dead_vnodeops;
1001 	/* XXX non mp-safe fs may still call insmntque with vnode
1002 	   unlocked */
1003 	if (!VOP_ISLOCKED(vp))
1004 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1005 	vgone(vp);
1006 	vput(vp);
1007 }
1008 
1009 /*
1010  * Insert into list of vnodes for the new mount point, if available.
1011  */
1012 int
1013 insmntque1(struct vnode *vp, struct mount *mp,
1014 	void (*dtr)(struct vnode *, void *), void *dtr_arg)
1015 {
1016 
1017 	KASSERT(vp->v_mount == NULL,
1018 		("insmntque: vnode already on per mount vnode list"));
1019 	VNASSERT(mp != NULL, vp, ("Don't call insmntque(foo, NULL)"));
1020 	MNT_ILOCK(mp);
1021 	if ((mp->mnt_kern_flag & MNTK_NOINSMNTQ) != 0 &&
1022 	    mp->mnt_nvnodelistsize == 0) {
1023 		MNT_IUNLOCK(mp);
1024 		if (dtr != NULL)
1025 			dtr(vp, dtr_arg);
1026 		return (EBUSY);
1027 	}
1028 	vp->v_mount = mp;
1029 	MNT_REF(mp);
1030 	TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
1031 	VNASSERT(mp->mnt_nvnodelistsize >= 0, vp,
1032 		("neg mount point vnode list size"));
1033 	mp->mnt_nvnodelistsize++;
1034 	MNT_IUNLOCK(mp);
1035 	return (0);
1036 }
1037 
1038 int
1039 insmntque(struct vnode *vp, struct mount *mp)
1040 {
1041 
1042 	return (insmntque1(vp, mp, insmntque_stddtr, NULL));
1043 }
1044 
1045 /*
1046  * Flush out and invalidate all buffers associated with a bufobj
1047  * Called with the underlying object locked.
1048  */
1049 int
1050 bufobj_invalbuf(struct bufobj *bo, int flags, struct thread *td, int slpflag,
1051     int slptimeo)
1052 {
1053 	int error;
1054 
1055 	BO_LOCK(bo);
1056 	if (flags & V_SAVE) {
1057 		error = bufobj_wwait(bo, slpflag, slptimeo);
1058 		if (error) {
1059 			BO_UNLOCK(bo);
1060 			return (error);
1061 		}
1062 		if (bo->bo_dirty.bv_cnt > 0) {
1063 			BO_UNLOCK(bo);
1064 			if ((error = BO_SYNC(bo, MNT_WAIT, td)) != 0)
1065 				return (error);
1066 			/*
1067 			 * XXX We could save a lock/unlock if this was only
1068 			 * enabled under INVARIANTS
1069 			 */
1070 			BO_LOCK(bo);
1071 			if (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0)
1072 				panic("vinvalbuf: dirty bufs");
1073 		}
1074 	}
1075 	/*
1076 	 * If you alter this loop please notice that interlock is dropped and
1077 	 * reacquired in flushbuflist.  Special care is needed to ensure that
1078 	 * no race conditions occur from this.
1079 	 */
1080 	do {
1081 		error = flushbuflist(&bo->bo_clean,
1082 		    flags, bo, slpflag, slptimeo);
1083 		if (error == 0)
1084 			error = flushbuflist(&bo->bo_dirty,
1085 			    flags, bo, slpflag, slptimeo);
1086 		if (error != 0 && error != EAGAIN) {
1087 			BO_UNLOCK(bo);
1088 			return (error);
1089 		}
1090 	} while (error != 0);
1091 
1092 	/*
1093 	 * Wait for I/O to complete.  XXX needs cleaning up.  The vnode can
1094 	 * have write I/O in-progress but if there is a VM object then the
1095 	 * VM object can also have read-I/O in-progress.
1096 	 */
1097 	do {
1098 		bufobj_wwait(bo, 0, 0);
1099 		BO_UNLOCK(bo);
1100 		if (bo->bo_object != NULL) {
1101 			VM_OBJECT_LOCK(bo->bo_object);
1102 			vm_object_pip_wait(bo->bo_object, "bovlbx");
1103 			VM_OBJECT_UNLOCK(bo->bo_object);
1104 		}
1105 		BO_LOCK(bo);
1106 	} while (bo->bo_numoutput > 0);
1107 	BO_UNLOCK(bo);
1108 
1109 	/*
1110 	 * Destroy the copy in the VM cache, too.
1111 	 */
1112 	if (bo->bo_object != NULL) {
1113 		VM_OBJECT_LOCK(bo->bo_object);
1114 		vm_object_page_remove(bo->bo_object, 0, 0,
1115 			(flags & V_SAVE) ? TRUE : FALSE);
1116 		VM_OBJECT_UNLOCK(bo->bo_object);
1117 	}
1118 
1119 #ifdef INVARIANTS
1120 	BO_LOCK(bo);
1121 	if ((flags & (V_ALT | V_NORMAL)) == 0 &&
1122 	    (bo->bo_dirty.bv_cnt > 0 || bo->bo_clean.bv_cnt > 0))
1123 		panic("vinvalbuf: flush failed");
1124 	BO_UNLOCK(bo);
1125 #endif
1126 	return (0);
1127 }
1128 
1129 /*
1130  * Flush out and invalidate all buffers associated with a vnode.
1131  * Called with the underlying object locked.
1132  */
1133 int
1134 vinvalbuf(struct vnode *vp, int flags, struct thread *td, int slpflag,
1135     int slptimeo)
1136 {
1137 
1138 	CTR2(KTR_VFS, "vinvalbuf vp %p flags %d", vp, flags);
1139 	ASSERT_VOP_LOCKED(vp, "vinvalbuf");
1140 	return (bufobj_invalbuf(&vp->v_bufobj, flags, td, slpflag, slptimeo));
1141 }
1142 
1143 /*
1144  * Flush out buffers on the specified list.
1145  *
1146  */
1147 static int
1148 flushbuflist( struct bufv *bufv, int flags, struct bufobj *bo, int slpflag,
1149     int slptimeo)
1150 {
1151 	struct buf *bp, *nbp;
1152 	int retval, error;
1153 	daddr_t lblkno;
1154 	b_xflags_t xflags;
1155 
1156 	ASSERT_BO_LOCKED(bo);
1157 
1158 	retval = 0;
1159 	TAILQ_FOREACH_SAFE(bp, &bufv->bv_hd, b_bobufs, nbp) {
1160 		if (((flags & V_NORMAL) && (bp->b_xflags & BX_ALTDATA)) ||
1161 		    ((flags & V_ALT) && (bp->b_xflags & BX_ALTDATA) == 0)) {
1162 			continue;
1163 		}
1164 		lblkno = 0;
1165 		xflags = 0;
1166 		if (nbp != NULL) {
1167 			lblkno = nbp->b_lblkno;
1168 			xflags = nbp->b_xflags &
1169 				(BX_BKGRDMARKER | BX_VNDIRTY | BX_VNCLEAN);
1170 		}
1171 		retval = EAGAIN;
1172 		error = BUF_TIMELOCK(bp,
1173 		    LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK, BO_MTX(bo),
1174 		    "flushbuf", slpflag, slptimeo);
1175 		if (error) {
1176 			BO_LOCK(bo);
1177 			return (error != ENOLCK ? error : EAGAIN);
1178 		}
1179 		KASSERT(bp->b_bufobj == bo,
1180 		    ("bp %p wrong b_bufobj %p should be %p",
1181 		    bp, bp->b_bufobj, bo));
1182 		if (bp->b_bufobj != bo) {	/* XXX: necessary ? */
1183 			BUF_UNLOCK(bp);
1184 			BO_LOCK(bo);
1185 			return (EAGAIN);
1186 		}
1187 		/*
1188 		 * XXX Since there are no node locks for NFS, I
1189 		 * believe there is a slight chance that a delayed
1190 		 * write will occur while sleeping just above, so
1191 		 * check for it.
1192 		 */
1193 		if (((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI) &&
1194 		    (flags & V_SAVE)) {
1195 			bremfree(bp);
1196 			bp->b_flags |= B_ASYNC;
1197 			bwrite(bp);
1198 			BO_LOCK(bo);
1199 			return (EAGAIN);	/* XXX: why not loop ? */
1200 		}
1201 		bremfree(bp);
1202 		bp->b_flags |= (B_INVAL | B_RELBUF);
1203 		bp->b_flags &= ~B_ASYNC;
1204 		brelse(bp);
1205 		BO_LOCK(bo);
1206 		if (nbp != NULL &&
1207 		    (nbp->b_bufobj != bo ||
1208 		     nbp->b_lblkno != lblkno ||
1209 		     (nbp->b_xflags &
1210 		      (BX_BKGRDMARKER | BX_VNDIRTY | BX_VNCLEAN)) != xflags))
1211 			break;			/* nbp invalid */
1212 	}
1213 	return (retval);
1214 }
1215 
1216 /*
1217  * Truncate a file's buffer and pages to a specified length.  This
1218  * is in lieu of the old vinvalbuf mechanism, which performed unneeded
1219  * sync activity.
1220  */
1221 int
1222 vtruncbuf(struct vnode *vp, struct ucred *cred, struct thread *td,
1223     off_t length, int blksize)
1224 {
1225 	struct buf *bp, *nbp;
1226 	int anyfreed;
1227 	int trunclbn;
1228 	struct bufobj *bo;
1229 
1230 	CTR2(KTR_VFS, "vtruncbuf vp %p length %jd", vp, length);
1231 	/*
1232 	 * Round up to the *next* lbn.
1233 	 */
1234 	trunclbn = (length + blksize - 1) / blksize;
1235 
1236 	ASSERT_VOP_LOCKED(vp, "vtruncbuf");
1237 restart:
1238 	VI_LOCK(vp);
1239 	bo = &vp->v_bufobj;
1240 	anyfreed = 1;
1241 	for (;anyfreed;) {
1242 		anyfreed = 0;
1243 		TAILQ_FOREACH_SAFE(bp, &bo->bo_clean.bv_hd, b_bobufs, nbp) {
1244 			if (bp->b_lblkno < trunclbn)
1245 				continue;
1246 			if (BUF_LOCK(bp,
1247 			    LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
1248 			    VI_MTX(vp)) == ENOLCK)
1249 				goto restart;
1250 
1251 			bremfree(bp);
1252 			bp->b_flags |= (B_INVAL | B_RELBUF);
1253 			bp->b_flags &= ~B_ASYNC;
1254 			brelse(bp);
1255 			anyfreed = 1;
1256 
1257 			if (nbp != NULL &&
1258 			    (((nbp->b_xflags & BX_VNCLEAN) == 0) ||
1259 			    (nbp->b_vp != vp) ||
1260 			    (nbp->b_flags & B_DELWRI))) {
1261 				goto restart;
1262 			}
1263 			VI_LOCK(vp);
1264 		}
1265 
1266 		TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
1267 			if (bp->b_lblkno < trunclbn)
1268 				continue;
1269 			if (BUF_LOCK(bp,
1270 			    LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
1271 			    VI_MTX(vp)) == ENOLCK)
1272 				goto restart;
1273 			bremfree(bp);
1274 			bp->b_flags |= (B_INVAL | B_RELBUF);
1275 			bp->b_flags &= ~B_ASYNC;
1276 			brelse(bp);
1277 			anyfreed = 1;
1278 			if (nbp != NULL &&
1279 			    (((nbp->b_xflags & BX_VNDIRTY) == 0) ||
1280 			    (nbp->b_vp != vp) ||
1281 			    (nbp->b_flags & B_DELWRI) == 0)) {
1282 				goto restart;
1283 			}
1284 			VI_LOCK(vp);
1285 		}
1286 	}
1287 
1288 	if (length > 0) {
1289 restartsync:
1290 		TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
1291 			if (bp->b_lblkno > 0)
1292 				continue;
1293 			/*
1294 			 * Since we hold the vnode lock this should only
1295 			 * fail if we're racing with the buf daemon.
1296 			 */
1297 			if (BUF_LOCK(bp,
1298 			    LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
1299 			    VI_MTX(vp)) == ENOLCK) {
1300 				goto restart;
1301 			}
1302 			VNASSERT((bp->b_flags & B_DELWRI), vp,
1303 			    ("buf(%p) on dirty queue without DELWRI", bp));
1304 
1305 			bremfree(bp);
1306 			bawrite(bp);
1307 			VI_LOCK(vp);
1308 			goto restartsync;
1309 		}
1310 	}
1311 
1312 	bufobj_wwait(bo, 0, 0);
1313 	VI_UNLOCK(vp);
1314 	vnode_pager_setsize(vp, length);
1315 
1316 	return (0);
1317 }
1318 
1319 /*
1320  * buf_splay() - splay tree core for the clean/dirty list of buffers in
1321  * 		 a vnode.
1322  *
1323  *	NOTE: We have to deal with the special case of a background bitmap
1324  *	buffer, a situation where two buffers will have the same logical
1325  *	block offset.  We want (1) only the foreground buffer to be accessed
1326  *	in a lookup and (2) must differentiate between the foreground and
1327  *	background buffer in the splay tree algorithm because the splay
1328  *	tree cannot normally handle multiple entities with the same 'index'.
1329  *	We accomplish this by adding differentiating flags to the splay tree's
1330  *	numerical domain.
1331  */
1332 static
1333 struct buf *
1334 buf_splay(daddr_t lblkno, b_xflags_t xflags, struct buf *root)
1335 {
1336 	struct buf dummy;
1337 	struct buf *lefttreemax, *righttreemin, *y;
1338 
1339 	if (root == NULL)
1340 		return (NULL);
1341 	lefttreemax = righttreemin = &dummy;
1342 	for (;;) {
1343 		if (lblkno < root->b_lblkno ||
1344 		    (lblkno == root->b_lblkno &&
1345 		    (xflags & BX_BKGRDMARKER) < (root->b_xflags & BX_BKGRDMARKER))) {
1346 			if ((y = root->b_left) == NULL)
1347 				break;
1348 			if (lblkno < y->b_lblkno) {
1349 				/* Rotate right. */
1350 				root->b_left = y->b_right;
1351 				y->b_right = root;
1352 				root = y;
1353 				if ((y = root->b_left) == NULL)
1354 					break;
1355 			}
1356 			/* Link into the new root's right tree. */
1357 			righttreemin->b_left = root;
1358 			righttreemin = root;
1359 		} else if (lblkno > root->b_lblkno ||
1360 		    (lblkno == root->b_lblkno &&
1361 		    (xflags & BX_BKGRDMARKER) > (root->b_xflags & BX_BKGRDMARKER))) {
1362 			if ((y = root->b_right) == NULL)
1363 				break;
1364 			if (lblkno > y->b_lblkno) {
1365 				/* Rotate left. */
1366 				root->b_right = y->b_left;
1367 				y->b_left = root;
1368 				root = y;
1369 				if ((y = root->b_right) == NULL)
1370 					break;
1371 			}
1372 			/* Link into the new root's left tree. */
1373 			lefttreemax->b_right = root;
1374 			lefttreemax = root;
1375 		} else {
1376 			break;
1377 		}
1378 		root = y;
1379 	}
1380 	/* Assemble the new root. */
1381 	lefttreemax->b_right = root->b_left;
1382 	righttreemin->b_left = root->b_right;
1383 	root->b_left = dummy.b_right;
1384 	root->b_right = dummy.b_left;
1385 	return (root);
1386 }
1387 
1388 static void
1389 buf_vlist_remove(struct buf *bp)
1390 {
1391 	struct buf *root;
1392 	struct bufv *bv;
1393 
1394 	KASSERT(bp->b_bufobj != NULL, ("No b_bufobj %p", bp));
1395 	ASSERT_BO_LOCKED(bp->b_bufobj);
1396 	KASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) !=
1397 	    (BX_VNDIRTY|BX_VNCLEAN),
1398 	    ("buf_vlist_remove: Buf %p is on two lists", bp));
1399 	if (bp->b_xflags & BX_VNDIRTY)
1400 		bv = &bp->b_bufobj->bo_dirty;
1401 	else
1402 		bv = &bp->b_bufobj->bo_clean;
1403 	if (bp != bv->bv_root) {
1404 		root = buf_splay(bp->b_lblkno, bp->b_xflags, bv->bv_root);
1405 		KASSERT(root == bp, ("splay lookup failed in remove"));
1406 	}
1407 	if (bp->b_left == NULL) {
1408 		root = bp->b_right;
1409 	} else {
1410 		root = buf_splay(bp->b_lblkno, bp->b_xflags, bp->b_left);
1411 		root->b_right = bp->b_right;
1412 	}
1413 	bv->bv_root = root;
1414 	TAILQ_REMOVE(&bv->bv_hd, bp, b_bobufs);
1415 	bv->bv_cnt--;
1416 	bp->b_xflags &= ~(BX_VNDIRTY | BX_VNCLEAN);
1417 }
1418 
1419 /*
1420  * Add the buffer to the sorted clean or dirty block list using a
1421  * splay tree algorithm.
1422  *
1423  * NOTE: xflags is passed as a constant, optimizing this inline function!
1424  */
1425 static void
1426 buf_vlist_add(struct buf *bp, struct bufobj *bo, b_xflags_t xflags)
1427 {
1428 	struct buf *root;
1429 	struct bufv *bv;
1430 
1431 	ASSERT_BO_LOCKED(bo);
1432 	KASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) == 0,
1433 	    ("buf_vlist_add: Buf %p has existing xflags %d", bp, bp->b_xflags));
1434 	bp->b_xflags |= xflags;
1435 	if (xflags & BX_VNDIRTY)
1436 		bv = &bo->bo_dirty;
1437 	else
1438 		bv = &bo->bo_clean;
1439 
1440 	root = buf_splay(bp->b_lblkno, bp->b_xflags, bv->bv_root);
1441 	if (root == NULL) {
1442 		bp->b_left = NULL;
1443 		bp->b_right = NULL;
1444 		TAILQ_INSERT_TAIL(&bv->bv_hd, bp, b_bobufs);
1445 	} else if (bp->b_lblkno < root->b_lblkno ||
1446 	    (bp->b_lblkno == root->b_lblkno &&
1447 	    (bp->b_xflags & BX_BKGRDMARKER) < (root->b_xflags & BX_BKGRDMARKER))) {
1448 		bp->b_left = root->b_left;
1449 		bp->b_right = root;
1450 		root->b_left = NULL;
1451 		TAILQ_INSERT_BEFORE(root, bp, b_bobufs);
1452 	} else {
1453 		bp->b_right = root->b_right;
1454 		bp->b_left = root;
1455 		root->b_right = NULL;
1456 		TAILQ_INSERT_AFTER(&bv->bv_hd, root, bp, b_bobufs);
1457 	}
1458 	bv->bv_cnt++;
1459 	bv->bv_root = bp;
1460 }
1461 
1462 /*
1463  * Lookup a buffer using the splay tree.  Note that we specifically avoid
1464  * shadow buffers used in background bitmap writes.
1465  *
1466  * This code isn't quite efficient as it could be because we are maintaining
1467  * two sorted lists and do not know which list the block resides in.
1468  *
1469  * During a "make buildworld" the desired buffer is found at one of
1470  * the roots more than 60% of the time.  Thus, checking both roots
1471  * before performing either splay eliminates unnecessary splays on the
1472  * first tree splayed.
1473  */
1474 struct buf *
1475 gbincore(struct bufobj *bo, daddr_t lblkno)
1476 {
1477 	struct buf *bp;
1478 
1479 	ASSERT_BO_LOCKED(bo);
1480 	if ((bp = bo->bo_clean.bv_root) != NULL &&
1481 	    bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
1482 		return (bp);
1483 	if ((bp = bo->bo_dirty.bv_root) != NULL &&
1484 	    bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
1485 		return (bp);
1486 	if ((bp = bo->bo_clean.bv_root) != NULL) {
1487 		bo->bo_clean.bv_root = bp = buf_splay(lblkno, 0, bp);
1488 		if (bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
1489 			return (bp);
1490 	}
1491 	if ((bp = bo->bo_dirty.bv_root) != NULL) {
1492 		bo->bo_dirty.bv_root = bp = buf_splay(lblkno, 0, bp);
1493 		if (bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
1494 			return (bp);
1495 	}
1496 	return (NULL);
1497 }
1498 
1499 /*
1500  * Associate a buffer with a vnode.
1501  */
1502 void
1503 bgetvp(struct vnode *vp, struct buf *bp)
1504 {
1505 
1506 	VNASSERT(bp->b_vp == NULL, bp->b_vp, ("bgetvp: not free"));
1507 
1508 	CTR3(KTR_BUF, "bgetvp(%p) vp %p flags %X", bp, vp, bp->b_flags);
1509 	VNASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) == 0, vp,
1510 	    ("bgetvp: bp already attached! %p", bp));
1511 
1512 	ASSERT_VI_LOCKED(vp, "bgetvp");
1513 	vholdl(vp);
1514 	if (VFS_NEEDSGIANT(vp->v_mount) ||
1515 	    vp->v_bufobj.bo_flag & BO_NEEDSGIANT)
1516 		bp->b_flags |= B_NEEDSGIANT;
1517 	bp->b_vp = vp;
1518 	bp->b_bufobj = &vp->v_bufobj;
1519 	/*
1520 	 * Insert onto list for new vnode.
1521 	 */
1522 	buf_vlist_add(bp, &vp->v_bufobj, BX_VNCLEAN);
1523 }
1524 
1525 /*
1526  * Disassociate a buffer from a vnode.
1527  */
1528 int
1529 brelvp(struct buf *bp)
1530 {
1531 	struct bufobj *bo;
1532 	struct vnode *vp;
1533 	int waiters;
1534 
1535 	CTR3(KTR_BUF, "brelvp(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
1536 	KASSERT(bp->b_vp != NULL, ("brelvp: NULL"));
1537 
1538 	/*
1539 	 * Delete from old vnode list, if on one.
1540 	 */
1541 	vp = bp->b_vp;		/* XXX */
1542 	bo = bp->b_bufobj;
1543 	BO_LOCK(bo);
1544 	if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN))
1545 		buf_vlist_remove(bp);
1546 	else
1547 		panic("brelvp: Buffer %p not on queue.", bp);
1548 	if ((bo->bo_flag & BO_ONWORKLST) && bo->bo_dirty.bv_cnt == 0) {
1549 		bo->bo_flag &= ~BO_ONWORKLST;
1550 		mtx_lock(&sync_mtx);
1551 		LIST_REMOVE(bo, bo_synclist);
1552 		syncer_worklist_len--;
1553 		mtx_unlock(&sync_mtx);
1554 	}
1555 	bp->b_flags &= ~B_NEEDSGIANT;
1556 	bp->b_vp = NULL;
1557 	bp->b_bufobj = NULL;
1558 	waiters = bp->b_waiters;
1559 	vdropl(vp);
1560 
1561 	return (waiters);
1562 }
1563 
1564 /*
1565  * Add an item to the syncer work queue.
1566  */
1567 static void
1568 vn_syncer_add_to_worklist(struct bufobj *bo, int delay)
1569 {
1570 	int slot;
1571 
1572 	ASSERT_BO_LOCKED(bo);
1573 
1574 	mtx_lock(&sync_mtx);
1575 	if (bo->bo_flag & BO_ONWORKLST)
1576 		LIST_REMOVE(bo, bo_synclist);
1577 	else {
1578 		bo->bo_flag |= BO_ONWORKLST;
1579 		syncer_worklist_len++;
1580 	}
1581 
1582 	if (delay > syncer_maxdelay - 2)
1583 		delay = syncer_maxdelay - 2;
1584 	slot = (syncer_delayno + delay) & syncer_mask;
1585 
1586 	LIST_INSERT_HEAD(&syncer_workitem_pending[slot], bo, bo_synclist);
1587 	mtx_unlock(&sync_mtx);
1588 }
1589 
1590 static int
1591 sysctl_vfs_worklist_len(SYSCTL_HANDLER_ARGS)
1592 {
1593 	int error, len;
1594 
1595 	mtx_lock(&sync_mtx);
1596 	len = syncer_worklist_len - sync_vnode_count;
1597 	mtx_unlock(&sync_mtx);
1598 	error = SYSCTL_OUT(req, &len, sizeof(len));
1599 	return (error);
1600 }
1601 
1602 SYSCTL_PROC(_vfs, OID_AUTO, worklist_len, CTLTYPE_INT | CTLFLAG_RD, NULL, 0,
1603     sysctl_vfs_worklist_len, "I", "Syncer thread worklist length");
1604 
1605 static struct proc *updateproc;
1606 static void sched_sync(void);
1607 static struct kproc_desc up_kp = {
1608 	"syncer",
1609 	sched_sync,
1610 	&updateproc
1611 };
1612 SYSINIT(syncer, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &up_kp)
1613 
1614 static int
1615 sync_vnode(struct synclist *slp, struct bufobj **bo, struct thread *td)
1616 {
1617 	struct vnode *vp;
1618 	struct mount *mp;
1619 	int vfslocked;
1620 
1621 	vfslocked = 0;
1622 restart:
1623 	*bo = LIST_FIRST(slp);
1624 	if (*bo == NULL) {
1625 		VFS_UNLOCK_GIANT(vfslocked);
1626 		return (0);
1627 	}
1628 	vp = (*bo)->__bo_vnode;	/* XXX */
1629 	if (VFS_NEEDSGIANT(vp->v_mount)) {
1630 		if (!vfslocked) {
1631 			vfslocked = 1;
1632 			if (mtx_trylock(&Giant) == 0) {
1633 				mtx_unlock(&sync_mtx);
1634 				mtx_lock(&Giant);
1635 				mtx_lock(&sync_mtx);
1636 				goto restart;
1637 			}
1638 		}
1639 	} else {
1640 		VFS_UNLOCK_GIANT(vfslocked);
1641 		vfslocked = 0;
1642 	}
1643 	if (VOP_ISLOCKED(vp) != 0) {
1644 		VFS_UNLOCK_GIANT(vfslocked);
1645 		return (1);
1646 	}
1647 	if (VI_TRYLOCK(vp) == 0) {
1648 		VFS_UNLOCK_GIANT(vfslocked);
1649 		return (1);
1650 	}
1651 	/*
1652 	 * We use vhold in case the vnode does not
1653 	 * successfully sync.  vhold prevents the vnode from
1654 	 * going away when we unlock the sync_mtx so that
1655 	 * we can acquire the vnode interlock.
1656 	 */
1657 	vholdl(vp);
1658 	mtx_unlock(&sync_mtx);
1659 	VI_UNLOCK(vp);
1660 	if (vn_start_write(vp, &mp, V_NOWAIT) != 0) {
1661 		vdrop(vp);
1662 		VFS_UNLOCK_GIANT(vfslocked);
1663 		mtx_lock(&sync_mtx);
1664 		return (1);
1665 	}
1666 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1667 	(void) VOP_FSYNC(vp, MNT_LAZY, td);
1668 	VOP_UNLOCK(vp, 0);
1669 	vn_finished_write(mp);
1670 	VI_LOCK(vp);
1671 	if (((*bo)->bo_flag & BO_ONWORKLST) != 0) {
1672 		/*
1673 		 * Put us back on the worklist.  The worklist
1674 		 * routine will remove us from our current
1675 		 * position and then add us back in at a later
1676 		 * position.
1677 		 */
1678 		vn_syncer_add_to_worklist(*bo, syncdelay);
1679 	}
1680 	vdropl(vp);
1681 	VFS_UNLOCK_GIANT(vfslocked);
1682 	mtx_lock(&sync_mtx);
1683 	return (0);
1684 }
1685 
1686 /*
1687  * System filesystem synchronizer daemon.
1688  */
1689 static void
1690 sched_sync(void)
1691 {
1692 	struct synclist *next;
1693 	struct synclist *slp;
1694 	struct bufobj *bo;
1695 	long starttime;
1696 	struct thread *td = curthread;
1697 	static int dummychan;
1698 	int last_work_seen;
1699 	int net_worklist_len;
1700 	int syncer_final_iter;
1701 	int first_printf;
1702 	int error;
1703 
1704 	last_work_seen = 0;
1705 	syncer_final_iter = 0;
1706 	first_printf = 1;
1707 	syncer_state = SYNCER_RUNNING;
1708 	starttime = time_uptime;
1709 	td->td_pflags |= TDP_NORUNNINGBUF;
1710 
1711 	EVENTHANDLER_REGISTER(shutdown_pre_sync, syncer_shutdown, td->td_proc,
1712 	    SHUTDOWN_PRI_LAST);
1713 
1714 	mtx_lock(&sync_mtx);
1715 	for (;;) {
1716 		if (syncer_state == SYNCER_FINAL_DELAY &&
1717 		    syncer_final_iter == 0) {
1718 			mtx_unlock(&sync_mtx);
1719 			kproc_suspend_check(td->td_proc);
1720 			mtx_lock(&sync_mtx);
1721 		}
1722 		net_worklist_len = syncer_worklist_len - sync_vnode_count;
1723 		if (syncer_state != SYNCER_RUNNING &&
1724 		    starttime != time_uptime) {
1725 			if (first_printf) {
1726 				printf("\nSyncing disks, vnodes remaining...");
1727 				first_printf = 0;
1728 			}
1729 			printf("%d ", net_worklist_len);
1730 		}
1731 		starttime = time_uptime;
1732 
1733 		/*
1734 		 * Push files whose dirty time has expired.  Be careful
1735 		 * of interrupt race on slp queue.
1736 		 *
1737 		 * Skip over empty worklist slots when shutting down.
1738 		 */
1739 		do {
1740 			slp = &syncer_workitem_pending[syncer_delayno];
1741 			syncer_delayno += 1;
1742 			if (syncer_delayno == syncer_maxdelay)
1743 				syncer_delayno = 0;
1744 			next = &syncer_workitem_pending[syncer_delayno];
1745 			/*
1746 			 * If the worklist has wrapped since the
1747 			 * it was emptied of all but syncer vnodes,
1748 			 * switch to the FINAL_DELAY state and run
1749 			 * for one more second.
1750 			 */
1751 			if (syncer_state == SYNCER_SHUTTING_DOWN &&
1752 			    net_worklist_len == 0 &&
1753 			    last_work_seen == syncer_delayno) {
1754 				syncer_state = SYNCER_FINAL_DELAY;
1755 				syncer_final_iter = SYNCER_SHUTDOWN_SPEEDUP;
1756 			}
1757 		} while (syncer_state != SYNCER_RUNNING && LIST_EMPTY(slp) &&
1758 		    syncer_worklist_len > 0);
1759 
1760 		/*
1761 		 * Keep track of the last time there was anything
1762 		 * on the worklist other than syncer vnodes.
1763 		 * Return to the SHUTTING_DOWN state if any
1764 		 * new work appears.
1765 		 */
1766 		if (net_worklist_len > 0 || syncer_state == SYNCER_RUNNING)
1767 			last_work_seen = syncer_delayno;
1768 		if (net_worklist_len > 0 && syncer_state == SYNCER_FINAL_DELAY)
1769 			syncer_state = SYNCER_SHUTTING_DOWN;
1770 		while (!LIST_EMPTY(slp)) {
1771 			error = sync_vnode(slp, &bo, td);
1772 			if (error == 1) {
1773 				LIST_REMOVE(bo, bo_synclist);
1774 				LIST_INSERT_HEAD(next, bo, bo_synclist);
1775 				continue;
1776 			}
1777 		}
1778 		if (syncer_state == SYNCER_FINAL_DELAY && syncer_final_iter > 0)
1779 			syncer_final_iter--;
1780 		/*
1781 		 * The variable rushjob allows the kernel to speed up the
1782 		 * processing of the filesystem syncer process. A rushjob
1783 		 * value of N tells the filesystem syncer to process the next
1784 		 * N seconds worth of work on its queue ASAP. Currently rushjob
1785 		 * is used by the soft update code to speed up the filesystem
1786 		 * syncer process when the incore state is getting so far
1787 		 * ahead of the disk that the kernel memory pool is being
1788 		 * threatened with exhaustion.
1789 		 */
1790 		if (rushjob > 0) {
1791 			rushjob -= 1;
1792 			continue;
1793 		}
1794 		/*
1795 		 * Just sleep for a short period of time between
1796 		 * iterations when shutting down to allow some I/O
1797 		 * to happen.
1798 		 *
1799 		 * If it has taken us less than a second to process the
1800 		 * current work, then wait. Otherwise start right over
1801 		 * again. We can still lose time if any single round
1802 		 * takes more than two seconds, but it does not really
1803 		 * matter as we are just trying to generally pace the
1804 		 * filesystem activity.
1805 		 */
1806 		if (syncer_state != SYNCER_RUNNING)
1807 			msleep(&dummychan, &sync_mtx, PPAUSE, "syncfnl",
1808 			    hz / SYNCER_SHUTDOWN_SPEEDUP);
1809 		else if (time_uptime == starttime)
1810 			msleep(&lbolt, &sync_mtx, PPAUSE, "syncer", 0);
1811 	}
1812 }
1813 
1814 /*
1815  * Request the syncer daemon to speed up its work.
1816  * We never push it to speed up more than half of its
1817  * normal turn time, otherwise it could take over the cpu.
1818  */
1819 int
1820 speedup_syncer(void)
1821 {
1822 	struct thread *td;
1823 	int ret = 0;
1824 
1825 	td = FIRST_THREAD_IN_PROC(updateproc);
1826 	mtx_lock(&sync_mtx);
1827 	if (rushjob < syncdelay / 2) {
1828 		rushjob += 1;
1829 		stat_rush_requests += 1;
1830 		ret = 1;
1831 	}
1832 	mtx_unlock(&sync_mtx);
1833 	sleepq_remove(td, &lbolt);
1834 	return (ret);
1835 }
1836 
1837 /*
1838  * Tell the syncer to speed up its work and run though its work
1839  * list several times, then tell it to shut down.
1840  */
1841 static void
1842 syncer_shutdown(void *arg, int howto)
1843 {
1844 	struct thread *td;
1845 
1846 	if (howto & RB_NOSYNC)
1847 		return;
1848 	td = FIRST_THREAD_IN_PROC(updateproc);
1849 	mtx_lock(&sync_mtx);
1850 	syncer_state = SYNCER_SHUTTING_DOWN;
1851 	rushjob = 0;
1852 	mtx_unlock(&sync_mtx);
1853 	sleepq_remove(td, &lbolt);
1854 	kproc_shutdown(arg, howto);
1855 }
1856 
1857 /*
1858  * Reassign a buffer from one vnode to another.
1859  * Used to assign file specific control information
1860  * (indirect blocks) to the vnode to which they belong.
1861  */
1862 void
1863 reassignbuf(struct buf *bp)
1864 {
1865 	struct vnode *vp;
1866 	struct bufobj *bo;
1867 	int delay;
1868 #ifdef INVARIANTS
1869 	struct bufv *bv;
1870 #endif
1871 
1872 	vp = bp->b_vp;
1873 	bo = bp->b_bufobj;
1874 	++reassignbufcalls;
1875 
1876 	CTR3(KTR_BUF, "reassignbuf(%p) vp %p flags %X",
1877 	    bp, bp->b_vp, bp->b_flags);
1878 	/*
1879 	 * B_PAGING flagged buffers cannot be reassigned because their vp
1880 	 * is not fully linked in.
1881 	 */
1882 	if (bp->b_flags & B_PAGING)
1883 		panic("cannot reassign paging buffer");
1884 
1885 	/*
1886 	 * Delete from old vnode list, if on one.
1887 	 */
1888 	VI_LOCK(vp);
1889 	if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN))
1890 		buf_vlist_remove(bp);
1891 	else
1892 		panic("reassignbuf: Buffer %p not on queue.", bp);
1893 	/*
1894 	 * If dirty, put on list of dirty buffers; otherwise insert onto list
1895 	 * of clean buffers.
1896 	 */
1897 	if (bp->b_flags & B_DELWRI) {
1898 		if ((bo->bo_flag & BO_ONWORKLST) == 0) {
1899 			switch (vp->v_type) {
1900 			case VDIR:
1901 				delay = dirdelay;
1902 				break;
1903 			case VCHR:
1904 				delay = metadelay;
1905 				break;
1906 			default:
1907 				delay = filedelay;
1908 			}
1909 			vn_syncer_add_to_worklist(bo, delay);
1910 		}
1911 		buf_vlist_add(bp, bo, BX_VNDIRTY);
1912 	} else {
1913 		buf_vlist_add(bp, bo, BX_VNCLEAN);
1914 
1915 		if ((bo->bo_flag & BO_ONWORKLST) && bo->bo_dirty.bv_cnt == 0) {
1916 			mtx_lock(&sync_mtx);
1917 			LIST_REMOVE(bo, bo_synclist);
1918 			syncer_worklist_len--;
1919 			mtx_unlock(&sync_mtx);
1920 			bo->bo_flag &= ~BO_ONWORKLST;
1921 		}
1922 	}
1923 #ifdef INVARIANTS
1924 	bv = &bo->bo_clean;
1925 	bp = TAILQ_FIRST(&bv->bv_hd);
1926 	KASSERT(bp == NULL || bp->b_bufobj == bo,
1927 	    ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
1928 	bp = TAILQ_LAST(&bv->bv_hd, buflists);
1929 	KASSERT(bp == NULL || bp->b_bufobj == bo,
1930 	    ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
1931 	bv = &bo->bo_dirty;
1932 	bp = TAILQ_FIRST(&bv->bv_hd);
1933 	KASSERT(bp == NULL || bp->b_bufobj == bo,
1934 	    ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
1935 	bp = TAILQ_LAST(&bv->bv_hd, buflists);
1936 	KASSERT(bp == NULL || bp->b_bufobj == bo,
1937 	    ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
1938 #endif
1939 	VI_UNLOCK(vp);
1940 }
1941 
1942 /*
1943  * Increment the use and hold counts on the vnode, taking care to reference
1944  * the driver's usecount if this is a chardev.  The vholdl() will remove
1945  * the vnode from the free list if it is presently free.  Requires the
1946  * vnode interlock and returns with it held.
1947  */
1948 static void
1949 v_incr_usecount(struct vnode *vp)
1950 {
1951 
1952 	CTR3(KTR_VFS, "v_incr_usecount: vp %p holdcnt %d usecount %d\n",
1953 	    vp, vp->v_holdcnt, vp->v_usecount);
1954 	vp->v_usecount++;
1955 	if (vp->v_type == VCHR && vp->v_rdev != NULL) {
1956 		dev_lock();
1957 		vp->v_rdev->si_usecount++;
1958 		dev_unlock();
1959 	}
1960 	vholdl(vp);
1961 }
1962 
1963 /*
1964  * Turn a holdcnt into a use+holdcnt such that only one call to
1965  * v_decr_usecount is needed.
1966  */
1967 static void
1968 v_upgrade_usecount(struct vnode *vp)
1969 {
1970 
1971 	CTR3(KTR_VFS, "v_upgrade_usecount: vp %p holdcnt %d usecount %d\n",
1972 	    vp, vp->v_holdcnt, vp->v_usecount);
1973 	vp->v_usecount++;
1974 	if (vp->v_type == VCHR && vp->v_rdev != NULL) {
1975 		dev_lock();
1976 		vp->v_rdev->si_usecount++;
1977 		dev_unlock();
1978 	}
1979 }
1980 
1981 /*
1982  * Decrement the vnode use and hold count along with the driver's usecount
1983  * if this is a chardev.  The vdropl() below releases the vnode interlock
1984  * as it may free the vnode.
1985  */
1986 static void
1987 v_decr_usecount(struct vnode *vp)
1988 {
1989 
1990 	CTR3(KTR_VFS, "v_decr_usecount: vp %p holdcnt %d usecount %d\n",
1991 	    vp, vp->v_holdcnt, vp->v_usecount);
1992 	ASSERT_VI_LOCKED(vp, __FUNCTION__);
1993 	VNASSERT(vp->v_usecount > 0, vp,
1994 	    ("v_decr_usecount: negative usecount"));
1995 	vp->v_usecount--;
1996 	if (vp->v_type == VCHR && vp->v_rdev != NULL) {
1997 		dev_lock();
1998 		vp->v_rdev->si_usecount--;
1999 		dev_unlock();
2000 	}
2001 	vdropl(vp);
2002 }
2003 
2004 /*
2005  * Decrement only the use count and driver use count.  This is intended to
2006  * be paired with a follow on vdropl() to release the remaining hold count.
2007  * In this way we may vgone() a vnode with a 0 usecount without risk of
2008  * having it end up on a free list because the hold count is kept above 0.
2009  */
2010 static void
2011 v_decr_useonly(struct vnode *vp)
2012 {
2013 
2014 	CTR3(KTR_VFS, "v_decr_useonly: vp %p holdcnt %d usecount %d\n",
2015 	    vp, vp->v_holdcnt, vp->v_usecount);
2016 	ASSERT_VI_LOCKED(vp, __FUNCTION__);
2017 	VNASSERT(vp->v_usecount > 0, vp,
2018 	    ("v_decr_useonly: negative usecount"));
2019 	vp->v_usecount--;
2020 	if (vp->v_type == VCHR && vp->v_rdev != NULL) {
2021 		dev_lock();
2022 		vp->v_rdev->si_usecount--;
2023 		dev_unlock();
2024 	}
2025 }
2026 
2027 /*
2028  * Grab a particular vnode from the free list, increment its
2029  * reference count and lock it. The vnode lock bit is set if the
2030  * vnode is being eliminated in vgone. The process is awakened
2031  * when the transition is completed, and an error returned to
2032  * indicate that the vnode is no longer usable (possibly having
2033  * been changed to a new filesystem type).
2034  */
2035 int
2036 vget(struct vnode *vp, int flags, struct thread *td)
2037 {
2038 	int oweinact;
2039 	int oldflags;
2040 	int error;
2041 
2042 	error = 0;
2043 	oldflags = flags;
2044 	oweinact = 0;
2045 	VFS_ASSERT_GIANT(vp->v_mount);
2046 	if ((flags & LK_INTERLOCK) == 0)
2047 		VI_LOCK(vp);
2048 	/*
2049 	 * If the inactive call was deferred because vput() was called
2050 	 * with a shared lock, we have to do it here before another thread
2051 	 * gets a reference to data that should be dead.
2052 	 */
2053 	if (vp->v_iflag & VI_OWEINACT) {
2054 		if (flags & LK_NOWAIT) {
2055 			VI_UNLOCK(vp);
2056 			return (EBUSY);
2057 		}
2058 		flags &= ~LK_TYPE_MASK;
2059 		flags |= LK_EXCLUSIVE;
2060 		oweinact = 1;
2061 	}
2062 	vholdl(vp);
2063 	if ((error = vn_lock(vp, flags | LK_INTERLOCK)) != 0) {
2064 		vdrop(vp);
2065 		return (error);
2066 	}
2067 	VI_LOCK(vp);
2068 	/* Upgrade our holdcnt to a usecount. */
2069 	v_upgrade_usecount(vp);
2070 	if (vp->v_iflag & VI_DOOMED && (flags & LK_RETRY) == 0)
2071 		panic("vget: vn_lock failed to return ENOENT\n");
2072 	if (oweinact) {
2073 		if (vp->v_iflag & VI_OWEINACT)
2074 			vinactive(vp, td);
2075 		VI_UNLOCK(vp);
2076 		if ((oldflags & LK_TYPE_MASK) == 0)
2077 			VOP_UNLOCK(vp, 0);
2078 	} else
2079 		VI_UNLOCK(vp);
2080 	return (0);
2081 }
2082 
2083 /*
2084  * Increase the reference count of a vnode.
2085  */
2086 void
2087 vref(struct vnode *vp)
2088 {
2089 
2090 	VI_LOCK(vp);
2091 	v_incr_usecount(vp);
2092 	VI_UNLOCK(vp);
2093 }
2094 
2095 /*
2096  * Return reference count of a vnode.
2097  *
2098  * The results of this call are only guaranteed when some mechanism other
2099  * than the VI lock is used to stop other processes from gaining references
2100  * to the vnode.  This may be the case if the caller holds the only reference.
2101  * This is also useful when stale data is acceptable as race conditions may
2102  * be accounted for by some other means.
2103  */
2104 int
2105 vrefcnt(struct vnode *vp)
2106 {
2107 	int usecnt;
2108 
2109 	VI_LOCK(vp);
2110 	usecnt = vp->v_usecount;
2111 	VI_UNLOCK(vp);
2112 
2113 	return (usecnt);
2114 }
2115 
2116 
2117 /*
2118  * Vnode put/release.
2119  * If count drops to zero, call inactive routine and return to freelist.
2120  */
2121 void
2122 vrele(struct vnode *vp)
2123 {
2124 	struct thread *td = curthread;	/* XXX */
2125 
2126 	KASSERT(vp != NULL, ("vrele: null vp"));
2127 	VFS_ASSERT_GIANT(vp->v_mount);
2128 
2129 	VI_LOCK(vp);
2130 
2131 	/* Skip this v_writecount check if we're going to panic below. */
2132 	VNASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1, vp,
2133 	    ("vrele: missed vn_close"));
2134 
2135 	if (vp->v_usecount > 1 || ((vp->v_iflag & VI_DOINGINACT) &&
2136 	    vp->v_usecount == 1)) {
2137 		v_decr_usecount(vp);
2138 		return;
2139 	}
2140 	if (vp->v_usecount != 1) {
2141 #ifdef DIAGNOSTIC
2142 		vprint("vrele: negative ref count", vp);
2143 #endif
2144 		VI_UNLOCK(vp);
2145 		panic("vrele: negative ref cnt");
2146 	}
2147 	/*
2148 	 * We want to hold the vnode until the inactive finishes to
2149 	 * prevent vgone() races.  We drop the use count here and the
2150 	 * hold count below when we're done.
2151 	 */
2152 	v_decr_useonly(vp);
2153 	/*
2154 	 * We must call VOP_INACTIVE with the node locked. Mark
2155 	 * as VI_DOINGINACT to avoid recursion.
2156 	 */
2157 	vp->v_iflag |= VI_OWEINACT;
2158 	if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK) == 0) {
2159 		VI_LOCK(vp);
2160 		if (vp->v_usecount > 0)
2161 			vp->v_iflag &= ~VI_OWEINACT;
2162 		if (vp->v_iflag & VI_OWEINACT)
2163 			vinactive(vp, td);
2164 		VOP_UNLOCK(vp, 0);
2165 	} else {
2166 		VI_LOCK(vp);
2167 		if (vp->v_usecount > 0)
2168 			vp->v_iflag &= ~VI_OWEINACT;
2169 	}
2170 	vdropl(vp);
2171 }
2172 
2173 /*
2174  * Release an already locked vnode.  This give the same effects as
2175  * unlock+vrele(), but takes less time and avoids releasing and
2176  * re-aquiring the lock (as vrele() acquires the lock internally.)
2177  */
2178 void
2179 vput(struct vnode *vp)
2180 {
2181 	struct thread *td = curthread;	/* XXX */
2182 	int error;
2183 
2184 	KASSERT(vp != NULL, ("vput: null vp"));
2185 	ASSERT_VOP_LOCKED(vp, "vput");
2186 	VFS_ASSERT_GIANT(vp->v_mount);
2187 	VI_LOCK(vp);
2188 	/* Skip this v_writecount check if we're going to panic below. */
2189 	VNASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1, vp,
2190 	    ("vput: missed vn_close"));
2191 	error = 0;
2192 
2193 	if (vp->v_usecount > 1 || ((vp->v_iflag & VI_DOINGINACT) &&
2194 	    vp->v_usecount == 1)) {
2195 		VOP_UNLOCK(vp, 0);
2196 		v_decr_usecount(vp);
2197 		return;
2198 	}
2199 
2200 	if (vp->v_usecount != 1) {
2201 #ifdef DIAGNOSTIC
2202 		vprint("vput: negative ref count", vp);
2203 #endif
2204 		panic("vput: negative ref cnt");
2205 	}
2206 	/*
2207 	 * We want to hold the vnode until the inactive finishes to
2208 	 * prevent vgone() races.  We drop the use count here and the
2209 	 * hold count below when we're done.
2210 	 */
2211 	v_decr_useonly(vp);
2212 	vp->v_iflag |= VI_OWEINACT;
2213 	if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
2214 		error = VOP_LOCK(vp, LK_UPGRADE|LK_INTERLOCK|LK_NOWAIT);
2215 		VI_LOCK(vp);
2216 		if (error) {
2217 			if (vp->v_usecount > 0)
2218 				vp->v_iflag &= ~VI_OWEINACT;
2219 			goto done;
2220 		}
2221 	}
2222 	if (vp->v_usecount > 0)
2223 		vp->v_iflag &= ~VI_OWEINACT;
2224 	if (vp->v_iflag & VI_OWEINACT)
2225 		vinactive(vp, td);
2226 	VOP_UNLOCK(vp, 0);
2227 done:
2228 	vdropl(vp);
2229 }
2230 
2231 /*
2232  * Somebody doesn't want the vnode recycled.
2233  */
2234 void
2235 vhold(struct vnode *vp)
2236 {
2237 
2238 	VI_LOCK(vp);
2239 	vholdl(vp);
2240 	VI_UNLOCK(vp);
2241 }
2242 
2243 void
2244 vholdl(struct vnode *vp)
2245 {
2246 
2247 	vp->v_holdcnt++;
2248 	if (VSHOULDBUSY(vp))
2249 		vbusy(vp);
2250 }
2251 
2252 /*
2253  * Note that there is one less who cares about this vnode.  vdrop() is the
2254  * opposite of vhold().
2255  */
2256 void
2257 vdrop(struct vnode *vp)
2258 {
2259 
2260 	VI_LOCK(vp);
2261 	vdropl(vp);
2262 }
2263 
2264 /*
2265  * Drop the hold count of the vnode.  If this is the last reference to
2266  * the vnode we will free it if it has been vgone'd otherwise it is
2267  * placed on the free list.
2268  */
2269 void
2270 vdropl(struct vnode *vp)
2271 {
2272 
2273 	ASSERT_VI_LOCKED(vp, "vdropl");
2274 	if (vp->v_holdcnt <= 0)
2275 		panic("vdrop: holdcnt %d", vp->v_holdcnt);
2276 	vp->v_holdcnt--;
2277 	if (vp->v_holdcnt == 0) {
2278 		if (vp->v_iflag & VI_DOOMED) {
2279 			vdestroy(vp);
2280 			return;
2281 		} else
2282 			vfree(vp);
2283 	}
2284 	VI_UNLOCK(vp);
2285 }
2286 
2287 /*
2288  * Call VOP_INACTIVE on the vnode and manage the DOINGINACT and OWEINACT
2289  * flags.  DOINGINACT prevents us from recursing in calls to vinactive.
2290  * OWEINACT tracks whether a vnode missed a call to inactive due to a
2291  * failed lock upgrade.
2292  */
2293 static void
2294 vinactive(struct vnode *vp, struct thread *td)
2295 {
2296 
2297 	ASSERT_VOP_LOCKED(vp, "vinactive");
2298 	ASSERT_VI_LOCKED(vp, "vinactive");
2299 	VNASSERT((vp->v_iflag & VI_DOINGINACT) == 0, vp,
2300 	    ("vinactive: recursed on VI_DOINGINACT"));
2301 	vp->v_iflag |= VI_DOINGINACT;
2302 	vp->v_iflag &= ~VI_OWEINACT;
2303 	VI_UNLOCK(vp);
2304 	VOP_INACTIVE(vp, td);
2305 	VI_LOCK(vp);
2306 	VNASSERT(vp->v_iflag & VI_DOINGINACT, vp,
2307 	    ("vinactive: lost VI_DOINGINACT"));
2308 	vp->v_iflag &= ~VI_DOINGINACT;
2309 }
2310 
2311 /*
2312  * Remove any vnodes in the vnode table belonging to mount point mp.
2313  *
2314  * If FORCECLOSE is not specified, there should not be any active ones,
2315  * return error if any are found (nb: this is a user error, not a
2316  * system error). If FORCECLOSE is specified, detach any active vnodes
2317  * that are found.
2318  *
2319  * If WRITECLOSE is set, only flush out regular file vnodes open for
2320  * writing.
2321  *
2322  * SKIPSYSTEM causes any vnodes marked VV_SYSTEM to be skipped.
2323  *
2324  * `rootrefs' specifies the base reference count for the root vnode
2325  * of this filesystem. The root vnode is considered busy if its
2326  * v_usecount exceeds this value. On a successful return, vflush(, td)
2327  * will call vrele() on the root vnode exactly rootrefs times.
2328  * If the SKIPSYSTEM or WRITECLOSE flags are specified, rootrefs must
2329  * be zero.
2330  */
2331 #ifdef DIAGNOSTIC
2332 static int busyprt = 0;		/* print out busy vnodes */
2333 SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "");
2334 #endif
2335 
2336 int
2337 vflush( struct mount *mp, int rootrefs, int flags, struct thread *td)
2338 {
2339 	struct vnode *vp, *mvp, *rootvp = NULL;
2340 	struct vattr vattr;
2341 	int busy = 0, error;
2342 
2343 	CTR1(KTR_VFS, "vflush: mp %p", mp);
2344 	if (rootrefs > 0) {
2345 		KASSERT((flags & (SKIPSYSTEM | WRITECLOSE)) == 0,
2346 		    ("vflush: bad args"));
2347 		/*
2348 		 * Get the filesystem root vnode. We can vput() it
2349 		 * immediately, since with rootrefs > 0, it won't go away.
2350 		 */
2351 		if ((error = VFS_ROOT(mp, LK_EXCLUSIVE, &rootvp, td)) != 0)
2352 			return (error);
2353 		vput(rootvp);
2354 
2355 	}
2356 	MNT_ILOCK(mp);
2357 loop:
2358 	MNT_VNODE_FOREACH(vp, mp, mvp) {
2359 
2360 		VI_LOCK(vp);
2361 		vholdl(vp);
2362 		MNT_IUNLOCK(mp);
2363 		error = vn_lock(vp, LK_INTERLOCK | LK_EXCLUSIVE);
2364 		if (error) {
2365 			vdrop(vp);
2366 			MNT_ILOCK(mp);
2367 			MNT_VNODE_FOREACH_ABORT_ILOCKED(mp, mvp);
2368 			goto loop;
2369 		}
2370 		/*
2371 		 * Skip over a vnodes marked VV_SYSTEM.
2372 		 */
2373 		if ((flags & SKIPSYSTEM) && (vp->v_vflag & VV_SYSTEM)) {
2374 			VOP_UNLOCK(vp, 0);
2375 			vdrop(vp);
2376 			MNT_ILOCK(mp);
2377 			continue;
2378 		}
2379 		/*
2380 		 * If WRITECLOSE is set, flush out unlinked but still open
2381 		 * files (even if open only for reading) and regular file
2382 		 * vnodes open for writing.
2383 		 */
2384 		if (flags & WRITECLOSE) {
2385 			error = VOP_GETATTR(vp, &vattr, td->td_ucred, td);
2386 			VI_LOCK(vp);
2387 
2388 			if ((vp->v_type == VNON ||
2389 			    (error == 0 && vattr.va_nlink > 0)) &&
2390 			    (vp->v_writecount == 0 || vp->v_type != VREG)) {
2391 				VOP_UNLOCK(vp, 0);
2392 				vdropl(vp);
2393 				MNT_ILOCK(mp);
2394 				continue;
2395 			}
2396 		} else
2397 			VI_LOCK(vp);
2398 		/*
2399 		 * With v_usecount == 0, all we need to do is clear out the
2400 		 * vnode data structures and we are done.
2401 		 *
2402 		 * If FORCECLOSE is set, forcibly close the vnode.
2403 		 */
2404 		if (vp->v_usecount == 0 || (flags & FORCECLOSE)) {
2405 			VNASSERT(vp->v_usecount == 0 ||
2406 			    (vp->v_type != VCHR && vp->v_type != VBLK), vp,
2407 			    ("device VNODE %p is FORCECLOSED", vp));
2408 			vgonel(vp);
2409 		} else {
2410 			busy++;
2411 #ifdef DIAGNOSTIC
2412 			if (busyprt)
2413 				vprint("vflush: busy vnode", vp);
2414 #endif
2415 		}
2416 		VOP_UNLOCK(vp, 0);
2417 		vdropl(vp);
2418 		MNT_ILOCK(mp);
2419 	}
2420 	MNT_IUNLOCK(mp);
2421 	if (rootrefs > 0 && (flags & FORCECLOSE) == 0) {
2422 		/*
2423 		 * If just the root vnode is busy, and if its refcount
2424 		 * is equal to `rootrefs', then go ahead and kill it.
2425 		 */
2426 		VI_LOCK(rootvp);
2427 		KASSERT(busy > 0, ("vflush: not busy"));
2428 		VNASSERT(rootvp->v_usecount >= rootrefs, rootvp,
2429 		    ("vflush: usecount %d < rootrefs %d",
2430 		     rootvp->v_usecount, rootrefs));
2431 		if (busy == 1 && rootvp->v_usecount == rootrefs) {
2432 			VOP_LOCK(rootvp, LK_EXCLUSIVE|LK_INTERLOCK);
2433 			vgone(rootvp);
2434 			VOP_UNLOCK(rootvp, 0);
2435 			busy = 0;
2436 		} else
2437 			VI_UNLOCK(rootvp);
2438 	}
2439 	if (busy)
2440 		return (EBUSY);
2441 	for (; rootrefs > 0; rootrefs--)
2442 		vrele(rootvp);
2443 	return (0);
2444 }
2445 
2446 /*
2447  * Recycle an unused vnode to the front of the free list.
2448  */
2449 int
2450 vrecycle(struct vnode *vp, struct thread *td)
2451 {
2452 	int recycled;
2453 
2454 	ASSERT_VOP_LOCKED(vp, "vrecycle");
2455 	recycled = 0;
2456 	VI_LOCK(vp);
2457 	if (vp->v_usecount == 0) {
2458 		recycled = 1;
2459 		vgonel(vp);
2460 	}
2461 	VI_UNLOCK(vp);
2462 	return (recycled);
2463 }
2464 
2465 /*
2466  * Eliminate all activity associated with a vnode
2467  * in preparation for reuse.
2468  */
2469 void
2470 vgone(struct vnode *vp)
2471 {
2472 	VI_LOCK(vp);
2473 	vgonel(vp);
2474 	VI_UNLOCK(vp);
2475 }
2476 
2477 /*
2478  * vgone, with the vp interlock held.
2479  */
2480 void
2481 vgonel(struct vnode *vp)
2482 {
2483 	struct thread *td;
2484 	int oweinact;
2485 	int active;
2486 	struct mount *mp;
2487 
2488 	CTR1(KTR_VFS, "vgonel: vp %p", vp);
2489 	ASSERT_VOP_LOCKED(vp, "vgonel");
2490 	ASSERT_VI_LOCKED(vp, "vgonel");
2491 	VNASSERT(vp->v_holdcnt, vp,
2492 	    ("vgonel: vp %p has no reference.", vp));
2493 	td = curthread;
2494 
2495 	/*
2496 	 * Don't vgonel if we're already doomed.
2497 	 */
2498 	if (vp->v_iflag & VI_DOOMED)
2499 		return;
2500 	vp->v_iflag |= VI_DOOMED;
2501 	/*
2502 	 * Check to see if the vnode is in use.  If so, we have to call
2503 	 * VOP_CLOSE() and VOP_INACTIVE().
2504 	 */
2505 	active = vp->v_usecount;
2506 	oweinact = (vp->v_iflag & VI_OWEINACT);
2507 	VI_UNLOCK(vp);
2508 	/*
2509 	 * Clean out any buffers associated with the vnode.
2510 	 * If the flush fails, just toss the buffers.
2511 	 */
2512 	mp = NULL;
2513 	if (!TAILQ_EMPTY(&vp->v_bufobj.bo_dirty.bv_hd))
2514 		(void) vn_start_secondary_write(vp, &mp, V_WAIT);
2515 	if (vinvalbuf(vp, V_SAVE, td, 0, 0) != 0)
2516 		vinvalbuf(vp, 0, td, 0, 0);
2517 
2518 	/*
2519 	 * If purging an active vnode, it must be closed and
2520 	 * deactivated before being reclaimed.
2521 	 */
2522 	if (active)
2523 		VOP_CLOSE(vp, FNONBLOCK, NOCRED, td);
2524 	if (oweinact || active) {
2525 		VI_LOCK(vp);
2526 		if ((vp->v_iflag & VI_DOINGINACT) == 0)
2527 			vinactive(vp, td);
2528 		VI_UNLOCK(vp);
2529 	}
2530 	/*
2531 	 * Reclaim the vnode.
2532 	 */
2533 	if (VOP_RECLAIM(vp, td))
2534 		panic("vgone: cannot reclaim");
2535 	if (mp != NULL)
2536 		vn_finished_secondary_write(mp);
2537 	VNASSERT(vp->v_object == NULL, vp,
2538 	    ("vop_reclaim left v_object vp=%p, tag=%s", vp, vp->v_tag));
2539 	/*
2540 	 * Delete from old mount point vnode list.
2541 	 */
2542 	delmntque(vp);
2543 	cache_purge(vp);
2544 	/*
2545 	 * Done with purge, reset to the standard lock and invalidate
2546 	 * the vnode.
2547 	 */
2548 	VI_LOCK(vp);
2549 	vp->v_vnlock = &vp->v_lock;
2550 	vp->v_op = &dead_vnodeops;
2551 	vp->v_tag = "none";
2552 	vp->v_type = VBAD;
2553 }
2554 
2555 /*
2556  * Calculate the total number of references to a special device.
2557  */
2558 int
2559 vcount(struct vnode *vp)
2560 {
2561 	int count;
2562 
2563 	dev_lock();
2564 	count = vp->v_rdev->si_usecount;
2565 	dev_unlock();
2566 	return (count);
2567 }
2568 
2569 /*
2570  * Same as above, but using the struct cdev *as argument
2571  */
2572 int
2573 count_dev(struct cdev *dev)
2574 {
2575 	int count;
2576 
2577 	dev_lock();
2578 	count = dev->si_usecount;
2579 	dev_unlock();
2580 	return(count);
2581 }
2582 
2583 /*
2584  * Print out a description of a vnode.
2585  */
2586 static char *typename[] =
2587 {"VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD",
2588  "VMARKER"};
2589 
2590 void
2591 vn_printf(struct vnode *vp, const char *fmt, ...)
2592 {
2593 	va_list ap;
2594 	char buf[256], buf2[16];
2595 	u_long flags;
2596 
2597 	va_start(ap, fmt);
2598 	vprintf(fmt, ap);
2599 	va_end(ap);
2600 	printf("%p: ", (void *)vp);
2601 	printf("tag %s, type %s\n", vp->v_tag, typename[vp->v_type]);
2602 	printf("    usecount %d, writecount %d, refcount %d mountedhere %p\n",
2603 	    vp->v_usecount, vp->v_writecount, vp->v_holdcnt, vp->v_mountedhere);
2604 	buf[0] = '\0';
2605 	buf[1] = '\0';
2606 	if (vp->v_vflag & VV_ROOT)
2607 		strlcat(buf, "|VV_ROOT", sizeof(buf));
2608 	if (vp->v_vflag & VV_ISTTY)
2609 		strlcat(buf, "|VV_ISTTY", sizeof(buf));
2610 	if (vp->v_vflag & VV_NOSYNC)
2611 		strlcat(buf, "|VV_NOSYNC", sizeof(buf));
2612 	if (vp->v_vflag & VV_CACHEDLABEL)
2613 		strlcat(buf, "|VV_CACHEDLABEL", sizeof(buf));
2614 	if (vp->v_vflag & VV_TEXT)
2615 		strlcat(buf, "|VV_TEXT", sizeof(buf));
2616 	if (vp->v_vflag & VV_COPYONWRITE)
2617 		strlcat(buf, "|VV_COPYONWRITE", sizeof(buf));
2618 	if (vp->v_vflag & VV_SYSTEM)
2619 		strlcat(buf, "|VV_SYSTEM", sizeof(buf));
2620 	if (vp->v_vflag & VV_PROCDEP)
2621 		strlcat(buf, "|VV_PROCDEP", sizeof(buf));
2622 	if (vp->v_vflag & VV_NOKNOTE)
2623 		strlcat(buf, "|VV_NOKNOTE", sizeof(buf));
2624 	if (vp->v_vflag & VV_DELETED)
2625 		strlcat(buf, "|VV_DELETED", sizeof(buf));
2626 	if (vp->v_vflag & VV_MD)
2627 		strlcat(buf, "|VV_MD", sizeof(buf));
2628 	flags = vp->v_vflag & ~(VV_ROOT | VV_ISTTY | VV_NOSYNC |
2629 	    VV_CACHEDLABEL | VV_TEXT | VV_COPYONWRITE | VV_SYSTEM | VV_PROCDEP |
2630 	    VV_NOKNOTE | VV_DELETED | VV_MD);
2631 	if (flags != 0) {
2632 		snprintf(buf2, sizeof(buf2), "|VV(0x%lx)", flags);
2633 		strlcat(buf, buf2, sizeof(buf));
2634 	}
2635 	if (vp->v_iflag & VI_MOUNT)
2636 		strlcat(buf, "|VI_MOUNT", sizeof(buf));
2637 	if (vp->v_iflag & VI_AGE)
2638 		strlcat(buf, "|VI_AGE", sizeof(buf));
2639 	if (vp->v_iflag & VI_DOOMED)
2640 		strlcat(buf, "|VI_DOOMED", sizeof(buf));
2641 	if (vp->v_iflag & VI_FREE)
2642 		strlcat(buf, "|VI_FREE", sizeof(buf));
2643 	if (vp->v_iflag & VI_OBJDIRTY)
2644 		strlcat(buf, "|VI_OBJDIRTY", sizeof(buf));
2645 	if (vp->v_iflag & VI_DOINGINACT)
2646 		strlcat(buf, "|VI_DOINGINACT", sizeof(buf));
2647 	if (vp->v_iflag & VI_OWEINACT)
2648 		strlcat(buf, "|VI_OWEINACT", sizeof(buf));
2649 	flags = vp->v_iflag & ~(VI_MOUNT | VI_AGE | VI_DOOMED | VI_FREE |
2650 	    VI_OBJDIRTY | VI_DOINGINACT | VI_OWEINACT);
2651 	if (flags != 0) {
2652 		snprintf(buf2, sizeof(buf2), "|VI(0x%lx)", flags);
2653 		strlcat(buf, buf2, sizeof(buf));
2654 	}
2655 	printf("    flags (%s)\n", buf + 1);
2656 	if (mtx_owned(VI_MTX(vp)))
2657 		printf(" VI_LOCKed");
2658 	if (vp->v_object != NULL)
2659 		printf("    v_object %p ref %d pages %d\n",
2660 		    vp->v_object, vp->v_object->ref_count,
2661 		    vp->v_object->resident_page_count);
2662 	printf("    ");
2663 	lockmgr_printinfo(vp->v_vnlock);
2664 	printf("\n");
2665 	if (vp->v_data != NULL)
2666 		VOP_PRINT(vp);
2667 }
2668 
2669 #ifdef DDB
2670 /*
2671  * List all of the locked vnodes in the system.
2672  * Called when debugging the kernel.
2673  */
2674 DB_SHOW_COMMAND(lockedvnods, lockedvnodes)
2675 {
2676 	struct mount *mp, *nmp;
2677 	struct vnode *vp;
2678 
2679 	/*
2680 	 * Note: because this is DDB, we can't obey the locking semantics
2681 	 * for these structures, which means we could catch an inconsistent
2682 	 * state and dereference a nasty pointer.  Not much to be done
2683 	 * about that.
2684 	 */
2685 	db_printf("Locked vnodes\n");
2686 	for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
2687 		nmp = TAILQ_NEXT(mp, mnt_list);
2688 		TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
2689 			if (vp->v_type != VMARKER &&
2690 			    VOP_ISLOCKED(vp))
2691 				vprint("", vp);
2692 		}
2693 		nmp = TAILQ_NEXT(mp, mnt_list);
2694 	}
2695 }
2696 
2697 /*
2698  * Show details about the given vnode.
2699  */
2700 DB_SHOW_COMMAND(vnode, db_show_vnode)
2701 {
2702 	struct vnode *vp;
2703 
2704 	if (!have_addr)
2705 		return;
2706 	vp = (struct vnode *)addr;
2707 	vn_printf(vp, "vnode ");
2708 }
2709 #endif	/* DDB */
2710 
2711 /*
2712  * Fill in a struct xvfsconf based on a struct vfsconf.
2713  */
2714 static void
2715 vfsconf2x(struct vfsconf *vfsp, struct xvfsconf *xvfsp)
2716 {
2717 
2718 	strcpy(xvfsp->vfc_name, vfsp->vfc_name);
2719 	xvfsp->vfc_typenum = vfsp->vfc_typenum;
2720 	xvfsp->vfc_refcount = vfsp->vfc_refcount;
2721 	xvfsp->vfc_flags = vfsp->vfc_flags;
2722 	/*
2723 	 * These are unused in userland, we keep them
2724 	 * to not break binary compatibility.
2725 	 */
2726 	xvfsp->vfc_vfsops = NULL;
2727 	xvfsp->vfc_next = NULL;
2728 }
2729 
2730 /*
2731  * Top level filesystem related information gathering.
2732  */
2733 static int
2734 sysctl_vfs_conflist(SYSCTL_HANDLER_ARGS)
2735 {
2736 	struct vfsconf *vfsp;
2737 	struct xvfsconf xvfsp;
2738 	int error;
2739 
2740 	error = 0;
2741 	TAILQ_FOREACH(vfsp, &vfsconf, vfc_list) {
2742 		bzero(&xvfsp, sizeof(xvfsp));
2743 		vfsconf2x(vfsp, &xvfsp);
2744 		error = SYSCTL_OUT(req, &xvfsp, sizeof xvfsp);
2745 		if (error)
2746 			break;
2747 	}
2748 	return (error);
2749 }
2750 
2751 SYSCTL_PROC(_vfs, OID_AUTO, conflist, CTLFLAG_RD, NULL, 0, sysctl_vfs_conflist,
2752     "S,xvfsconf", "List of all configured filesystems");
2753 
2754 #ifndef BURN_BRIDGES
2755 static int	sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS);
2756 
2757 static int
2758 vfs_sysctl(SYSCTL_HANDLER_ARGS)
2759 {
2760 	int *name = (int *)arg1 - 1;	/* XXX */
2761 	u_int namelen = arg2 + 1;	/* XXX */
2762 	struct vfsconf *vfsp;
2763 	struct xvfsconf xvfsp;
2764 
2765 	printf("WARNING: userland calling deprecated sysctl, "
2766 	    "please rebuild world\n");
2767 
2768 #if 1 || defined(COMPAT_PRELITE2)
2769 	/* Resolve ambiguity between VFS_VFSCONF and VFS_GENERIC. */
2770 	if (namelen == 1)
2771 		return (sysctl_ovfs_conf(oidp, arg1, arg2, req));
2772 #endif
2773 
2774 	switch (name[1]) {
2775 	case VFS_MAXTYPENUM:
2776 		if (namelen != 2)
2777 			return (ENOTDIR);
2778 		return (SYSCTL_OUT(req, &maxvfsconf, sizeof(int)));
2779 	case VFS_CONF:
2780 		if (namelen != 3)
2781 			return (ENOTDIR);	/* overloaded */
2782 		TAILQ_FOREACH(vfsp, &vfsconf, vfc_list)
2783 			if (vfsp->vfc_typenum == name[2])
2784 				break;
2785 		if (vfsp == NULL)
2786 			return (EOPNOTSUPP);
2787 		bzero(&xvfsp, sizeof(xvfsp));
2788 		vfsconf2x(vfsp, &xvfsp);
2789 		return (SYSCTL_OUT(req, &xvfsp, sizeof(xvfsp)));
2790 	}
2791 	return (EOPNOTSUPP);
2792 }
2793 
2794 static SYSCTL_NODE(_vfs, VFS_GENERIC, generic, CTLFLAG_RD | CTLFLAG_SKIP,
2795 	vfs_sysctl, "Generic filesystem");
2796 
2797 #if 1 || defined(COMPAT_PRELITE2)
2798 
2799 static int
2800 sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS)
2801 {
2802 	int error;
2803 	struct vfsconf *vfsp;
2804 	struct ovfsconf ovfs;
2805 
2806 	TAILQ_FOREACH(vfsp, &vfsconf, vfc_list) {
2807 		bzero(&ovfs, sizeof(ovfs));
2808 		ovfs.vfc_vfsops = vfsp->vfc_vfsops;	/* XXX used as flag */
2809 		strcpy(ovfs.vfc_name, vfsp->vfc_name);
2810 		ovfs.vfc_index = vfsp->vfc_typenum;
2811 		ovfs.vfc_refcount = vfsp->vfc_refcount;
2812 		ovfs.vfc_flags = vfsp->vfc_flags;
2813 		error = SYSCTL_OUT(req, &ovfs, sizeof ovfs);
2814 		if (error)
2815 			return error;
2816 	}
2817 	return 0;
2818 }
2819 
2820 #endif /* 1 || COMPAT_PRELITE2 */
2821 #endif /* !BURN_BRIDGES */
2822 
2823 #define KINFO_VNODESLOP		10
2824 #ifdef notyet
2825 /*
2826  * Dump vnode list (via sysctl).
2827  */
2828 /* ARGSUSED */
2829 static int
2830 sysctl_vnode(SYSCTL_HANDLER_ARGS)
2831 {
2832 	struct xvnode *xvn;
2833 	struct thread *td = req->td;
2834 	struct mount *mp;
2835 	struct vnode *vp;
2836 	int error, len, n;
2837 
2838 	/*
2839 	 * Stale numvnodes access is not fatal here.
2840 	 */
2841 	req->lock = 0;
2842 	len = (numvnodes + KINFO_VNODESLOP) * sizeof *xvn;
2843 	if (!req->oldptr)
2844 		/* Make an estimate */
2845 		return (SYSCTL_OUT(req, 0, len));
2846 
2847 	error = sysctl_wire_old_buffer(req, 0);
2848 	if (error != 0)
2849 		return (error);
2850 	xvn = malloc(len, M_TEMP, M_ZERO | M_WAITOK);
2851 	n = 0;
2852 	mtx_lock(&mountlist_mtx);
2853 	TAILQ_FOREACH(mp, &mountlist, mnt_list) {
2854 		if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td))
2855 			continue;
2856 		MNT_ILOCK(mp);
2857 		TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
2858 			if (n == len)
2859 				break;
2860 			vref(vp);
2861 			xvn[n].xv_size = sizeof *xvn;
2862 			xvn[n].xv_vnode = vp;
2863 			xvn[n].xv_id = 0;	/* XXX compat */
2864 #define XV_COPY(field) xvn[n].xv_##field = vp->v_##field
2865 			XV_COPY(usecount);
2866 			XV_COPY(writecount);
2867 			XV_COPY(holdcnt);
2868 			XV_COPY(mount);
2869 			XV_COPY(numoutput);
2870 			XV_COPY(type);
2871 #undef XV_COPY
2872 			xvn[n].xv_flag = vp->v_vflag;
2873 
2874 			switch (vp->v_type) {
2875 			case VREG:
2876 			case VDIR:
2877 			case VLNK:
2878 				break;
2879 			case VBLK:
2880 			case VCHR:
2881 				if (vp->v_rdev == NULL) {
2882 					vrele(vp);
2883 					continue;
2884 				}
2885 				xvn[n].xv_dev = dev2udev(vp->v_rdev);
2886 				break;
2887 			case VSOCK:
2888 				xvn[n].xv_socket = vp->v_socket;
2889 				break;
2890 			case VFIFO:
2891 				xvn[n].xv_fifo = vp->v_fifoinfo;
2892 				break;
2893 			case VNON:
2894 			case VBAD:
2895 			default:
2896 				/* shouldn't happen? */
2897 				vrele(vp);
2898 				continue;
2899 			}
2900 			vrele(vp);
2901 			++n;
2902 		}
2903 		MNT_IUNLOCK(mp);
2904 		mtx_lock(&mountlist_mtx);
2905 		vfs_unbusy(mp, td);
2906 		if (n == len)
2907 			break;
2908 	}
2909 	mtx_unlock(&mountlist_mtx);
2910 
2911 	error = SYSCTL_OUT(req, xvn, n * sizeof *xvn);
2912 	free(xvn, M_TEMP);
2913 	return (error);
2914 }
2915 
2916 SYSCTL_PROC(_kern, KERN_VNODE, vnode, CTLTYPE_OPAQUE|CTLFLAG_RD,
2917 	0, 0, sysctl_vnode, "S,xvnode", "");
2918 #endif
2919 
2920 /*
2921  * Unmount all filesystems. The list is traversed in reverse order
2922  * of mounting to avoid dependencies.
2923  */
2924 void
2925 vfs_unmountall(void)
2926 {
2927 	struct mount *mp;
2928 	struct thread *td;
2929 	int error;
2930 
2931 	KASSERT(curthread != NULL, ("vfs_unmountall: NULL curthread"));
2932 	td = curthread;
2933 	/*
2934 	 * Since this only runs when rebooting, it is not interlocked.
2935 	 */
2936 	while(!TAILQ_EMPTY(&mountlist)) {
2937 		mp = TAILQ_LAST(&mountlist, mntlist);
2938 		error = dounmount(mp, MNT_FORCE, td);
2939 		if (error) {
2940 			TAILQ_REMOVE(&mountlist, mp, mnt_list);
2941 			/*
2942 			 * XXX: Due to the way in which we mount the root
2943 			 * file system off of devfs, devfs will generate a
2944 			 * "busy" warning when we try to unmount it before
2945 			 * the root.  Don't print a warning as a result in
2946 			 * order to avoid false positive errors that may
2947 			 * cause needless upset.
2948 			 */
2949 			if (strcmp(mp->mnt_vfc->vfc_name, "devfs") != 0) {
2950 				printf("unmount of %s failed (",
2951 				    mp->mnt_stat.f_mntonname);
2952 				if (error == EBUSY)
2953 					printf("BUSY)\n");
2954 				else
2955 					printf("%d)\n", error);
2956 			}
2957 		} else {
2958 			/* The unmount has removed mp from the mountlist */
2959 		}
2960 	}
2961 }
2962 
2963 /*
2964  * perform msync on all vnodes under a mount point
2965  * the mount point must be locked.
2966  */
2967 void
2968 vfs_msync(struct mount *mp, int flags)
2969 {
2970 	struct vnode *vp, *mvp;
2971 	struct vm_object *obj;
2972 
2973 	MNT_ILOCK(mp);
2974 	MNT_VNODE_FOREACH(vp, mp, mvp) {
2975 		VI_LOCK(vp);
2976 		if ((vp->v_iflag & VI_OBJDIRTY) &&
2977 		    (flags == MNT_WAIT || VOP_ISLOCKED(vp) == 0)) {
2978 			MNT_IUNLOCK(mp);
2979 			if (!vget(vp,
2980 			    LK_EXCLUSIVE | LK_RETRY | LK_INTERLOCK,
2981 			    curthread)) {
2982 				if (vp->v_vflag & VV_NOSYNC) {	/* unlinked */
2983 					vput(vp);
2984 					MNT_ILOCK(mp);
2985 					continue;
2986 				}
2987 
2988 				obj = vp->v_object;
2989 				if (obj != NULL) {
2990 					VM_OBJECT_LOCK(obj);
2991 					vm_object_page_clean(obj, 0, 0,
2992 					    flags == MNT_WAIT ?
2993 					    OBJPC_SYNC : OBJPC_NOSYNC);
2994 					VM_OBJECT_UNLOCK(obj);
2995 				}
2996 				vput(vp);
2997 			}
2998 			MNT_ILOCK(mp);
2999 		} else
3000 			VI_UNLOCK(vp);
3001 	}
3002 	MNT_IUNLOCK(mp);
3003 }
3004 
3005 /*
3006  * Mark a vnode as free, putting it up for recycling.
3007  */
3008 static void
3009 vfree(struct vnode *vp)
3010 {
3011 
3012 	CTR1(KTR_VFS, "vfree vp %p", vp);
3013 	ASSERT_VI_LOCKED(vp, "vfree");
3014 	mtx_lock(&vnode_free_list_mtx);
3015 	VNASSERT(vp->v_op != NULL, vp, ("vfree: vnode already reclaimed."));
3016 	VNASSERT((vp->v_iflag & VI_FREE) == 0, vp, ("vnode already free"));
3017 	VNASSERT(VSHOULDFREE(vp), vp, ("vfree: freeing when we shouldn't"));
3018 	VNASSERT((vp->v_iflag & VI_DOOMED) == 0, vp,
3019 	    ("vfree: Freeing doomed vnode"));
3020 	if (vp->v_iflag & VI_AGE) {
3021 		TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
3022 	} else {
3023 		TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
3024 	}
3025 	freevnodes++;
3026 	vp->v_iflag &= ~VI_AGE;
3027 	vp->v_iflag |= VI_FREE;
3028 	mtx_unlock(&vnode_free_list_mtx);
3029 }
3030 
3031 /*
3032  * Opposite of vfree() - mark a vnode as in use.
3033  */
3034 static void
3035 vbusy(struct vnode *vp)
3036 {
3037 	CTR1(KTR_VFS, "vbusy vp %p", vp);
3038 	ASSERT_VI_LOCKED(vp, "vbusy");
3039 	VNASSERT((vp->v_iflag & VI_FREE) != 0, vp, ("vnode not free"));
3040 	VNASSERT(vp->v_op != NULL, vp, ("vbusy: vnode already reclaimed."));
3041 
3042 	mtx_lock(&vnode_free_list_mtx);
3043 	TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
3044 	freevnodes--;
3045 	vp->v_iflag &= ~(VI_FREE|VI_AGE);
3046 	mtx_unlock(&vnode_free_list_mtx);
3047 }
3048 
3049 /*
3050  * Initalize per-vnode helper structure to hold poll-related state.
3051  */
3052 void
3053 v_addpollinfo(struct vnode *vp)
3054 {
3055 	struct vpollinfo *vi;
3056 
3057 	vi = uma_zalloc(vnodepoll_zone, M_WAITOK);
3058 	if (vp->v_pollinfo != NULL) {
3059 		uma_zfree(vnodepoll_zone, vi);
3060 		return;
3061 	}
3062 	vp->v_pollinfo = vi;
3063 	mtx_init(&vp->v_pollinfo->vpi_lock, "vnode pollinfo", NULL, MTX_DEF);
3064 	knlist_init(&vp->v_pollinfo->vpi_selinfo.si_note, vp, vfs_knllock,
3065 	    vfs_knlunlock, vfs_knllocked);
3066 }
3067 
3068 /*
3069  * Record a process's interest in events which might happen to
3070  * a vnode.  Because poll uses the historic select-style interface
3071  * internally, this routine serves as both the ``check for any
3072  * pending events'' and the ``record my interest in future events''
3073  * functions.  (These are done together, while the lock is held,
3074  * to avoid race conditions.)
3075  */
3076 int
3077 vn_pollrecord(struct vnode *vp, struct thread *td, int events)
3078 {
3079 
3080 	if (vp->v_pollinfo == NULL)
3081 		v_addpollinfo(vp);
3082 	mtx_lock(&vp->v_pollinfo->vpi_lock);
3083 	if (vp->v_pollinfo->vpi_revents & events) {
3084 		/*
3085 		 * This leaves events we are not interested
3086 		 * in available for the other process which
3087 		 * which presumably had requested them
3088 		 * (otherwise they would never have been
3089 		 * recorded).
3090 		 */
3091 		events &= vp->v_pollinfo->vpi_revents;
3092 		vp->v_pollinfo->vpi_revents &= ~events;
3093 
3094 		mtx_unlock(&vp->v_pollinfo->vpi_lock);
3095 		return events;
3096 	}
3097 	vp->v_pollinfo->vpi_events |= events;
3098 	selrecord(td, &vp->v_pollinfo->vpi_selinfo);
3099 	mtx_unlock(&vp->v_pollinfo->vpi_lock);
3100 	return 0;
3101 }
3102 
3103 /*
3104  * Routine to create and manage a filesystem syncer vnode.
3105  */
3106 #define sync_close ((int (*)(struct  vop_close_args *))nullop)
3107 static int	sync_fsync(struct  vop_fsync_args *);
3108 static int	sync_inactive(struct  vop_inactive_args *);
3109 static int	sync_reclaim(struct  vop_reclaim_args *);
3110 
3111 static struct vop_vector sync_vnodeops = {
3112 	.vop_bypass =	VOP_EOPNOTSUPP,
3113 	.vop_close =	sync_close,		/* close */
3114 	.vop_fsync =	sync_fsync,		/* fsync */
3115 	.vop_inactive =	sync_inactive,	/* inactive */
3116 	.vop_reclaim =	sync_reclaim,	/* reclaim */
3117 	.vop_lock1 =	vop_stdlock,	/* lock */
3118 	.vop_unlock =	vop_stdunlock,	/* unlock */
3119 	.vop_islocked =	vop_stdislocked,	/* islocked */
3120 };
3121 
3122 /*
3123  * Create a new filesystem syncer vnode for the specified mount point.
3124  */
3125 int
3126 vfs_allocate_syncvnode(struct mount *mp)
3127 {
3128 	struct vnode *vp;
3129 	static long start, incr, next;
3130 	int error;
3131 
3132 	/* Allocate a new vnode */
3133 	if ((error = getnewvnode("syncer", mp, &sync_vnodeops, &vp)) != 0) {
3134 		mp->mnt_syncer = NULL;
3135 		return (error);
3136 	}
3137 	vp->v_type = VNON;
3138 	error = insmntque(vp, mp);
3139 	if (error != 0)
3140 		panic("vfs_allocate_syncvnode: insmntque failed");
3141 	/*
3142 	 * Place the vnode onto the syncer worklist. We attempt to
3143 	 * scatter them about on the list so that they will go off
3144 	 * at evenly distributed times even if all the filesystems
3145 	 * are mounted at once.
3146 	 */
3147 	next += incr;
3148 	if (next == 0 || next > syncer_maxdelay) {
3149 		start /= 2;
3150 		incr /= 2;
3151 		if (start == 0) {
3152 			start = syncer_maxdelay / 2;
3153 			incr = syncer_maxdelay;
3154 		}
3155 		next = start;
3156 	}
3157 	VI_LOCK(vp);
3158 	vn_syncer_add_to_worklist(&vp->v_bufobj,
3159 	    syncdelay > 0 ? next % syncdelay : 0);
3160 	/* XXX - vn_syncer_add_to_worklist() also grabs and drops sync_mtx. */
3161 	mtx_lock(&sync_mtx);
3162 	sync_vnode_count++;
3163 	mtx_unlock(&sync_mtx);
3164 	VI_UNLOCK(vp);
3165 	mp->mnt_syncer = vp;
3166 	return (0);
3167 }
3168 
3169 /*
3170  * Do a lazy sync of the filesystem.
3171  */
3172 static int
3173 sync_fsync(struct vop_fsync_args *ap)
3174 {
3175 	struct vnode *syncvp = ap->a_vp;
3176 	struct mount *mp = syncvp->v_mount;
3177 	struct thread *td = ap->a_td;
3178 	int error;
3179 	struct bufobj *bo;
3180 
3181 	/*
3182 	 * We only need to do something if this is a lazy evaluation.
3183 	 */
3184 	if (ap->a_waitfor != MNT_LAZY)
3185 		return (0);
3186 
3187 	/*
3188 	 * Move ourselves to the back of the sync list.
3189 	 */
3190 	bo = &syncvp->v_bufobj;
3191 	BO_LOCK(bo);
3192 	vn_syncer_add_to_worklist(bo, syncdelay);
3193 	BO_UNLOCK(bo);
3194 
3195 	/*
3196 	 * Walk the list of vnodes pushing all that are dirty and
3197 	 * not already on the sync list.
3198 	 */
3199 	mtx_lock(&mountlist_mtx);
3200 	if (vfs_busy(mp, LK_EXCLUSIVE | LK_NOWAIT, &mountlist_mtx, td) != 0) {
3201 		mtx_unlock(&mountlist_mtx);
3202 		return (0);
3203 	}
3204 	if (vn_start_write(NULL, &mp, V_NOWAIT) != 0) {
3205 		vfs_unbusy(mp, td);
3206 		return (0);
3207 	}
3208 	MNT_ILOCK(mp);
3209 	mp->mnt_noasync++;
3210 	mp->mnt_kern_flag &= ~MNTK_ASYNC;
3211 	MNT_IUNLOCK(mp);
3212 	vfs_msync(mp, MNT_NOWAIT);
3213 	error = VFS_SYNC(mp, MNT_LAZY, td);
3214 	MNT_ILOCK(mp);
3215 	mp->mnt_noasync--;
3216 	if ((mp->mnt_flag & MNT_ASYNC) != 0 && mp->mnt_noasync == 0)
3217 		mp->mnt_kern_flag |= MNTK_ASYNC;
3218 	MNT_IUNLOCK(mp);
3219 	vn_finished_write(mp);
3220 	vfs_unbusy(mp, td);
3221 	return (error);
3222 }
3223 
3224 /*
3225  * The syncer vnode is no referenced.
3226  */
3227 static int
3228 sync_inactive(struct vop_inactive_args *ap)
3229 {
3230 
3231 	vgone(ap->a_vp);
3232 	return (0);
3233 }
3234 
3235 /*
3236  * The syncer vnode is no longer needed and is being decommissioned.
3237  *
3238  * Modifications to the worklist must be protected by sync_mtx.
3239  */
3240 static int
3241 sync_reclaim(struct vop_reclaim_args *ap)
3242 {
3243 	struct vnode *vp = ap->a_vp;
3244 	struct bufobj *bo;
3245 
3246 	VI_LOCK(vp);
3247 	bo = &vp->v_bufobj;
3248 	vp->v_mount->mnt_syncer = NULL;
3249 	if (bo->bo_flag & BO_ONWORKLST) {
3250 		mtx_lock(&sync_mtx);
3251 		LIST_REMOVE(bo, bo_synclist);
3252 		syncer_worklist_len--;
3253 		sync_vnode_count--;
3254 		mtx_unlock(&sync_mtx);
3255 		bo->bo_flag &= ~BO_ONWORKLST;
3256 	}
3257 	VI_UNLOCK(vp);
3258 
3259 	return (0);
3260 }
3261 
3262 /*
3263  * Check if vnode represents a disk device
3264  */
3265 int
3266 vn_isdisk(struct vnode *vp, int *errp)
3267 {
3268 	int error;
3269 
3270 	error = 0;
3271 	dev_lock();
3272 	if (vp->v_type != VCHR)
3273 		error = ENOTBLK;
3274 	else if (vp->v_rdev == NULL)
3275 		error = ENXIO;
3276 	else if (vp->v_rdev->si_devsw == NULL)
3277 		error = ENXIO;
3278 	else if (!(vp->v_rdev->si_devsw->d_flags & D_DISK))
3279 		error = ENOTBLK;
3280 	dev_unlock();
3281 	if (errp != NULL)
3282 		*errp = error;
3283 	return (error == 0);
3284 }
3285 
3286 /*
3287  * Common filesystem object access control check routine.  Accepts a
3288  * vnode's type, "mode", uid and gid, requested access mode, credentials,
3289  * and optional call-by-reference privused argument allowing vaccess()
3290  * to indicate to the caller whether privilege was used to satisfy the
3291  * request (obsoleted).  Returns 0 on success, or an errno on failure.
3292  *
3293  * The ifdef'd CAPABILITIES version is here for reference, but is not
3294  * actually used.
3295  */
3296 int
3297 vaccess(enum vtype type, mode_t file_mode, uid_t file_uid, gid_t file_gid,
3298     mode_t acc_mode, struct ucred *cred, int *privused)
3299 {
3300 	mode_t dac_granted;
3301 	mode_t priv_granted;
3302 
3303 	/*
3304 	 * Look for a normal, non-privileged way to access the file/directory
3305 	 * as requested.  If it exists, go with that.
3306 	 */
3307 
3308 	if (privused != NULL)
3309 		*privused = 0;
3310 
3311 	dac_granted = 0;
3312 
3313 	/* Check the owner. */
3314 	if (cred->cr_uid == file_uid) {
3315 		dac_granted |= VADMIN;
3316 		if (file_mode & S_IXUSR)
3317 			dac_granted |= VEXEC;
3318 		if (file_mode & S_IRUSR)
3319 			dac_granted |= VREAD;
3320 		if (file_mode & S_IWUSR)
3321 			dac_granted |= (VWRITE | VAPPEND);
3322 
3323 		if ((acc_mode & dac_granted) == acc_mode)
3324 			return (0);
3325 
3326 		goto privcheck;
3327 	}
3328 
3329 	/* Otherwise, check the groups (first match) */
3330 	if (groupmember(file_gid, cred)) {
3331 		if (file_mode & S_IXGRP)
3332 			dac_granted |= VEXEC;
3333 		if (file_mode & S_IRGRP)
3334 			dac_granted |= VREAD;
3335 		if (file_mode & S_IWGRP)
3336 			dac_granted |= (VWRITE | VAPPEND);
3337 
3338 		if ((acc_mode & dac_granted) == acc_mode)
3339 			return (0);
3340 
3341 		goto privcheck;
3342 	}
3343 
3344 	/* Otherwise, check everyone else. */
3345 	if (file_mode & S_IXOTH)
3346 		dac_granted |= VEXEC;
3347 	if (file_mode & S_IROTH)
3348 		dac_granted |= VREAD;
3349 	if (file_mode & S_IWOTH)
3350 		dac_granted |= (VWRITE | VAPPEND);
3351 	if ((acc_mode & dac_granted) == acc_mode)
3352 		return (0);
3353 
3354 privcheck:
3355 	/*
3356 	 * Build a privilege mask to determine if the set of privileges
3357 	 * satisfies the requirements when combined with the granted mask
3358 	 * from above.  For each privilege, if the privilege is required,
3359 	 * bitwise or the request type onto the priv_granted mask.
3360 	 */
3361 	priv_granted = 0;
3362 
3363 	if (type == VDIR) {
3364 		/*
3365 		 * For directories, use PRIV_VFS_LOOKUP to satisfy VEXEC
3366 		 * requests, instead of PRIV_VFS_EXEC.
3367 		 */
3368 		if ((acc_mode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
3369 		    !priv_check_cred(cred, PRIV_VFS_LOOKUP, 0))
3370 			priv_granted |= VEXEC;
3371 	} else {
3372 		if ((acc_mode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
3373 		    !priv_check_cred(cred, PRIV_VFS_EXEC, 0))
3374 			priv_granted |= VEXEC;
3375 	}
3376 
3377 	if ((acc_mode & VREAD) && ((dac_granted & VREAD) == 0) &&
3378 	    !priv_check_cred(cred, PRIV_VFS_READ, 0))
3379 		priv_granted |= VREAD;
3380 
3381 	if ((acc_mode & VWRITE) && ((dac_granted & VWRITE) == 0) &&
3382 	    !priv_check_cred(cred, PRIV_VFS_WRITE, 0))
3383 		priv_granted |= (VWRITE | VAPPEND);
3384 
3385 	if ((acc_mode & VADMIN) && ((dac_granted & VADMIN) == 0) &&
3386 	    !priv_check_cred(cred, PRIV_VFS_ADMIN, 0))
3387 		priv_granted |= VADMIN;
3388 
3389 	if ((acc_mode & (priv_granted | dac_granted)) == acc_mode) {
3390 		/* XXX audit: privilege used */
3391 		if (privused != NULL)
3392 			*privused = 1;
3393 		return (0);
3394 	}
3395 
3396 	return ((acc_mode & VADMIN) ? EPERM : EACCES);
3397 }
3398 
3399 /*
3400  * Credential check based on process requesting service, and per-attribute
3401  * permissions.
3402  */
3403 int
3404 extattr_check_cred(struct vnode *vp, int attrnamespace, struct ucred *cred,
3405     struct thread *td, int access)
3406 {
3407 
3408 	/*
3409 	 * Kernel-invoked always succeeds.
3410 	 */
3411 	if (cred == NOCRED)
3412 		return (0);
3413 
3414 	/*
3415 	 * Do not allow privileged processes in jail to directly manipulate
3416 	 * system attributes.
3417 	 */
3418 	switch (attrnamespace) {
3419 	case EXTATTR_NAMESPACE_SYSTEM:
3420 		/* Potentially should be: return (EPERM); */
3421 		return (priv_check_cred(cred, PRIV_VFS_EXTATTR_SYSTEM, 0));
3422 	case EXTATTR_NAMESPACE_USER:
3423 		return (VOP_ACCESS(vp, access, cred, td));
3424 	default:
3425 		return (EPERM);
3426 	}
3427 }
3428 
3429 #ifdef DEBUG_VFS_LOCKS
3430 /*
3431  * This only exists to supress warnings from unlocked specfs accesses.  It is
3432  * no longer ok to have an unlocked VFS.
3433  */
3434 #define	IGNORE_LOCK(vp) ((vp)->v_type == VCHR || (vp)->v_type == VBAD)
3435 
3436 int vfs_badlock_ddb = 1;	/* Drop into debugger on violation. */
3437 SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_ddb, CTLFLAG_RW, &vfs_badlock_ddb, 0, "");
3438 
3439 int vfs_badlock_mutex = 1;	/* Check for interlock across VOPs. */
3440 SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_mutex, CTLFLAG_RW, &vfs_badlock_mutex, 0, "");
3441 
3442 int vfs_badlock_print = 1;	/* Print lock violations. */
3443 SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_print, CTLFLAG_RW, &vfs_badlock_print, 0, "");
3444 
3445 #ifdef KDB
3446 int vfs_badlock_backtrace = 1;	/* Print backtrace at lock violations. */
3447 SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_backtrace, CTLFLAG_RW, &vfs_badlock_backtrace, 0, "");
3448 #endif
3449 
3450 static void
3451 vfs_badlock(const char *msg, const char *str, struct vnode *vp)
3452 {
3453 
3454 #ifdef KDB
3455 	if (vfs_badlock_backtrace)
3456 		kdb_backtrace();
3457 #endif
3458 	if (vfs_badlock_print)
3459 		printf("%s: %p %s\n", str, (void *)vp, msg);
3460 	if (vfs_badlock_ddb)
3461 		kdb_enter(KDB_WHY_VFSLOCK, "lock violation");
3462 }
3463 
3464 void
3465 assert_vi_locked(struct vnode *vp, const char *str)
3466 {
3467 
3468 	if (vfs_badlock_mutex && !mtx_owned(VI_MTX(vp)))
3469 		vfs_badlock("interlock is not locked but should be", str, vp);
3470 }
3471 
3472 void
3473 assert_vi_unlocked(struct vnode *vp, const char *str)
3474 {
3475 
3476 	if (vfs_badlock_mutex && mtx_owned(VI_MTX(vp)))
3477 		vfs_badlock("interlock is locked but should not be", str, vp);
3478 }
3479 
3480 void
3481 assert_vop_locked(struct vnode *vp, const char *str)
3482 {
3483 
3484 	if (vp && !IGNORE_LOCK(vp) && VOP_ISLOCKED(vp) == 0)
3485 		vfs_badlock("is not locked but should be", str, vp);
3486 }
3487 
3488 void
3489 assert_vop_unlocked(struct vnode *vp, const char *str)
3490 {
3491 
3492 	if (vp && !IGNORE_LOCK(vp) &&
3493 	    VOP_ISLOCKED(vp) == LK_EXCLUSIVE)
3494 		vfs_badlock("is locked but should not be", str, vp);
3495 }
3496 
3497 void
3498 assert_vop_elocked(struct vnode *vp, const char *str)
3499 {
3500 
3501 	if (vp && !IGNORE_LOCK(vp) &&
3502 	    VOP_ISLOCKED(vp) != LK_EXCLUSIVE)
3503 		vfs_badlock("is not exclusive locked but should be", str, vp);
3504 }
3505 
3506 #if 0
3507 void
3508 assert_vop_elocked_other(struct vnode *vp, const char *str)
3509 {
3510 
3511 	if (vp && !IGNORE_LOCK(vp) &&
3512 	    VOP_ISLOCKED(vp) != LK_EXCLOTHER)
3513 		vfs_badlock("is not exclusive locked by another thread",
3514 		    str, vp);
3515 }
3516 
3517 void
3518 assert_vop_slocked(struct vnode *vp, const char *str)
3519 {
3520 
3521 	if (vp && !IGNORE_LOCK(vp) &&
3522 	    VOP_ISLOCKED(vp) != LK_SHARED)
3523 		vfs_badlock("is not locked shared but should be", str, vp);
3524 }
3525 #endif /* 0 */
3526 #endif /* DEBUG_VFS_LOCKS */
3527 
3528 void
3529 vop_rename_pre(void *ap)
3530 {
3531 	struct vop_rename_args *a = ap;
3532 
3533 #ifdef DEBUG_VFS_LOCKS
3534 	if (a->a_tvp)
3535 		ASSERT_VI_UNLOCKED(a->a_tvp, "VOP_RENAME");
3536 	ASSERT_VI_UNLOCKED(a->a_tdvp, "VOP_RENAME");
3537 	ASSERT_VI_UNLOCKED(a->a_fvp, "VOP_RENAME");
3538 	ASSERT_VI_UNLOCKED(a->a_fdvp, "VOP_RENAME");
3539 
3540 	/* Check the source (from). */
3541 	if (a->a_tdvp != a->a_fdvp && a->a_tvp != a->a_fdvp)
3542 		ASSERT_VOP_UNLOCKED(a->a_fdvp, "vop_rename: fdvp locked");
3543 	if (a->a_tvp != a->a_fvp)
3544 		ASSERT_VOP_UNLOCKED(a->a_fvp, "vop_rename: fvp locked");
3545 
3546 	/* Check the target. */
3547 	if (a->a_tvp)
3548 		ASSERT_VOP_LOCKED(a->a_tvp, "vop_rename: tvp not locked");
3549 	ASSERT_VOP_LOCKED(a->a_tdvp, "vop_rename: tdvp not locked");
3550 #endif
3551 	if (a->a_tdvp != a->a_fdvp)
3552 		vhold(a->a_fdvp);
3553 	if (a->a_tvp != a->a_fvp)
3554 		vhold(a->a_fvp);
3555 	vhold(a->a_tdvp);
3556 	if (a->a_tvp)
3557 		vhold(a->a_tvp);
3558 }
3559 
3560 void
3561 vop_strategy_pre(void *ap)
3562 {
3563 #ifdef DEBUG_VFS_LOCKS
3564 	struct vop_strategy_args *a;
3565 	struct buf *bp;
3566 
3567 	a = ap;
3568 	bp = a->a_bp;
3569 
3570 	/*
3571 	 * Cluster ops lock their component buffers but not the IO container.
3572 	 */
3573 	if ((bp->b_flags & B_CLUSTER) != 0)
3574 		return;
3575 
3576 	if (!BUF_ISLOCKED(bp)) {
3577 		if (vfs_badlock_print)
3578 			printf(
3579 			    "VOP_STRATEGY: bp is not locked but should be\n");
3580 		if (vfs_badlock_ddb)
3581 			kdb_enter(KDB_WHY_VFSLOCK, "lock violation");
3582 	}
3583 #endif
3584 }
3585 
3586 void
3587 vop_lookup_pre(void *ap)
3588 {
3589 #ifdef DEBUG_VFS_LOCKS
3590 	struct vop_lookup_args *a;
3591 	struct vnode *dvp;
3592 
3593 	a = ap;
3594 	dvp = a->a_dvp;
3595 	ASSERT_VI_UNLOCKED(dvp, "VOP_LOOKUP");
3596 	ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP");
3597 #endif
3598 }
3599 
3600 void
3601 vop_lookup_post(void *ap, int rc)
3602 {
3603 #ifdef DEBUG_VFS_LOCKS
3604 	struct vop_lookup_args *a;
3605 	struct vnode *dvp;
3606 	struct vnode *vp;
3607 
3608 	a = ap;
3609 	dvp = a->a_dvp;
3610 	vp = *(a->a_vpp);
3611 
3612 	ASSERT_VI_UNLOCKED(dvp, "VOP_LOOKUP");
3613 	ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP");
3614 
3615 	if (!rc)
3616 		ASSERT_VOP_LOCKED(vp, "VOP_LOOKUP (child)");
3617 #endif
3618 }
3619 
3620 void
3621 vop_lock_pre(void *ap)
3622 {
3623 #ifdef DEBUG_VFS_LOCKS
3624 	struct vop_lock1_args *a = ap;
3625 
3626 	if ((a->a_flags & LK_INTERLOCK) == 0)
3627 		ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
3628 	else
3629 		ASSERT_VI_LOCKED(a->a_vp, "VOP_LOCK");
3630 #endif
3631 }
3632 
3633 void
3634 vop_lock_post(void *ap, int rc)
3635 {
3636 #ifdef DEBUG_VFS_LOCKS
3637 	struct vop_lock1_args *a = ap;
3638 
3639 	ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
3640 	if (rc == 0)
3641 		ASSERT_VOP_LOCKED(a->a_vp, "VOP_LOCK");
3642 #endif
3643 }
3644 
3645 void
3646 vop_unlock_pre(void *ap)
3647 {
3648 #ifdef DEBUG_VFS_LOCKS
3649 	struct vop_unlock_args *a = ap;
3650 
3651 	if (a->a_flags & LK_INTERLOCK)
3652 		ASSERT_VI_LOCKED(a->a_vp, "VOP_UNLOCK");
3653 	ASSERT_VOP_LOCKED(a->a_vp, "VOP_UNLOCK");
3654 #endif
3655 }
3656 
3657 void
3658 vop_unlock_post(void *ap, int rc)
3659 {
3660 #ifdef DEBUG_VFS_LOCKS
3661 	struct vop_unlock_args *a = ap;
3662 
3663 	if (a->a_flags & LK_INTERLOCK)
3664 		ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNLOCK");
3665 #endif
3666 }
3667 
3668 void
3669 vop_create_post(void *ap, int rc)
3670 {
3671 	struct vop_create_args *a = ap;
3672 
3673 	if (!rc)
3674 		VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
3675 }
3676 
3677 void
3678 vop_link_post(void *ap, int rc)
3679 {
3680 	struct vop_link_args *a = ap;
3681 
3682 	if (!rc) {
3683 		VFS_KNOTE_LOCKED(a->a_vp, NOTE_LINK);
3684 		VFS_KNOTE_LOCKED(a->a_tdvp, NOTE_WRITE);
3685 	}
3686 }
3687 
3688 void
3689 vop_mkdir_post(void *ap, int rc)
3690 {
3691 	struct vop_mkdir_args *a = ap;
3692 
3693 	if (!rc)
3694 		VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE | NOTE_LINK);
3695 }
3696 
3697 void
3698 vop_mknod_post(void *ap, int rc)
3699 {
3700 	struct vop_mknod_args *a = ap;
3701 
3702 	if (!rc)
3703 		VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
3704 }
3705 
3706 void
3707 vop_remove_post(void *ap, int rc)
3708 {
3709 	struct vop_remove_args *a = ap;
3710 
3711 	if (!rc) {
3712 		VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
3713 		VFS_KNOTE_LOCKED(a->a_vp, NOTE_DELETE);
3714 	}
3715 }
3716 
3717 void
3718 vop_rename_post(void *ap, int rc)
3719 {
3720 	struct vop_rename_args *a = ap;
3721 
3722 	if (!rc) {
3723 		VFS_KNOTE_UNLOCKED(a->a_fdvp, NOTE_WRITE);
3724 		VFS_KNOTE_UNLOCKED(a->a_tdvp, NOTE_WRITE);
3725 		VFS_KNOTE_UNLOCKED(a->a_fvp, NOTE_RENAME);
3726 		if (a->a_tvp)
3727 			VFS_KNOTE_UNLOCKED(a->a_tvp, NOTE_DELETE);
3728 	}
3729 	if (a->a_tdvp != a->a_fdvp)
3730 		vdrop(a->a_fdvp);
3731 	if (a->a_tvp != a->a_fvp)
3732 		vdrop(a->a_fvp);
3733 	vdrop(a->a_tdvp);
3734 	if (a->a_tvp)
3735 		vdrop(a->a_tvp);
3736 }
3737 
3738 void
3739 vop_rmdir_post(void *ap, int rc)
3740 {
3741 	struct vop_rmdir_args *a = ap;
3742 
3743 	if (!rc) {
3744 		VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE | NOTE_LINK);
3745 		VFS_KNOTE_LOCKED(a->a_vp, NOTE_DELETE);
3746 	}
3747 }
3748 
3749 void
3750 vop_setattr_post(void *ap, int rc)
3751 {
3752 	struct vop_setattr_args *a = ap;
3753 
3754 	if (!rc)
3755 		VFS_KNOTE_LOCKED(a->a_vp, NOTE_ATTRIB);
3756 }
3757 
3758 void
3759 vop_symlink_post(void *ap, int rc)
3760 {
3761 	struct vop_symlink_args *a = ap;
3762 
3763 	if (!rc)
3764 		VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
3765 }
3766 
3767 static struct knlist fs_knlist;
3768 
3769 static void
3770 vfs_event_init(void *arg)
3771 {
3772 	knlist_init(&fs_knlist, NULL, NULL, NULL, NULL);
3773 }
3774 /* XXX - correct order? */
3775 SYSINIT(vfs_knlist, SI_SUB_VFS, SI_ORDER_ANY, vfs_event_init, NULL);
3776 
3777 void
3778 vfs_event_signal(fsid_t *fsid, u_int32_t event, intptr_t data __unused)
3779 {
3780 
3781 	KNOTE_UNLOCKED(&fs_knlist, event);
3782 }
3783 
3784 static int	filt_fsattach(struct knote *kn);
3785 static void	filt_fsdetach(struct knote *kn);
3786 static int	filt_fsevent(struct knote *kn, long hint);
3787 
3788 struct filterops fs_filtops =
3789 	{ 0, filt_fsattach, filt_fsdetach, filt_fsevent };
3790 
3791 static int
3792 filt_fsattach(struct knote *kn)
3793 {
3794 
3795 	kn->kn_flags |= EV_CLEAR;
3796 	knlist_add(&fs_knlist, kn, 0);
3797 	return (0);
3798 }
3799 
3800 static void
3801 filt_fsdetach(struct knote *kn)
3802 {
3803 
3804 	knlist_remove(&fs_knlist, kn, 0);
3805 }
3806 
3807 static int
3808 filt_fsevent(struct knote *kn, long hint)
3809 {
3810 
3811 	kn->kn_fflags |= hint;
3812 	return (kn->kn_fflags != 0);
3813 }
3814 
3815 static int
3816 sysctl_vfs_ctl(SYSCTL_HANDLER_ARGS)
3817 {
3818 	struct vfsidctl vc;
3819 	int error;
3820 	struct mount *mp;
3821 
3822 	error = SYSCTL_IN(req, &vc, sizeof(vc));
3823 	if (error)
3824 		return (error);
3825 	if (vc.vc_vers != VFS_CTL_VERS1)
3826 		return (EINVAL);
3827 	mp = vfs_getvfs(&vc.vc_fsid);
3828 	if (mp == NULL)
3829 		return (ENOENT);
3830 	/* ensure that a specific sysctl goes to the right filesystem. */
3831 	if (strcmp(vc.vc_fstypename, "*") != 0 &&
3832 	    strcmp(vc.vc_fstypename, mp->mnt_vfc->vfc_name) != 0) {
3833 		vfs_rel(mp);
3834 		return (EINVAL);
3835 	}
3836 	VCTLTOREQ(&vc, req);
3837 	error = VFS_SYSCTL(mp, vc.vc_op, req);
3838 	vfs_rel(mp);
3839 	return (error);
3840 }
3841 
3842 SYSCTL_PROC(_vfs, OID_AUTO, ctl, CTLFLAG_WR, NULL, 0, sysctl_vfs_ctl, "",
3843     "Sysctl by fsid");
3844 
3845 /*
3846  * Function to initialize a va_filerev field sensibly.
3847  * XXX: Wouldn't a random number make a lot more sense ??
3848  */
3849 u_quad_t
3850 init_va_filerev(void)
3851 {
3852 	struct bintime bt;
3853 
3854 	getbinuptime(&bt);
3855 	return (((u_quad_t)bt.sec << 32LL) | (bt.frac >> 32LL));
3856 }
3857 
3858 static int	filt_vfsread(struct knote *kn, long hint);
3859 static int	filt_vfswrite(struct knote *kn, long hint);
3860 static int	filt_vfsvnode(struct knote *kn, long hint);
3861 static void	filt_vfsdetach(struct knote *kn);
3862 static struct filterops vfsread_filtops =
3863 	{ 1, NULL, filt_vfsdetach, filt_vfsread };
3864 static struct filterops vfswrite_filtops =
3865 	{ 1, NULL, filt_vfsdetach, filt_vfswrite };
3866 static struct filterops vfsvnode_filtops =
3867 	{ 1, NULL, filt_vfsdetach, filt_vfsvnode };
3868 
3869 static void
3870 vfs_knllock(void *arg)
3871 {
3872 	struct vnode *vp = arg;
3873 
3874 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3875 }
3876 
3877 static void
3878 vfs_knlunlock(void *arg)
3879 {
3880 	struct vnode *vp = arg;
3881 
3882 	VOP_UNLOCK(vp, 0);
3883 }
3884 
3885 static int
3886 vfs_knllocked(void *arg)
3887 {
3888 	struct vnode *vp = arg;
3889 
3890 	return (VOP_ISLOCKED(vp) == LK_EXCLUSIVE);
3891 }
3892 
3893 int
3894 vfs_kqfilter(struct vop_kqfilter_args *ap)
3895 {
3896 	struct vnode *vp = ap->a_vp;
3897 	struct knote *kn = ap->a_kn;
3898 	struct knlist *knl;
3899 
3900 	switch (kn->kn_filter) {
3901 	case EVFILT_READ:
3902 		kn->kn_fop = &vfsread_filtops;
3903 		break;
3904 	case EVFILT_WRITE:
3905 		kn->kn_fop = &vfswrite_filtops;
3906 		break;
3907 	case EVFILT_VNODE:
3908 		kn->kn_fop = &vfsvnode_filtops;
3909 		break;
3910 	default:
3911 		return (EINVAL);
3912 	}
3913 
3914 	kn->kn_hook = (caddr_t)vp;
3915 
3916 	if (vp->v_pollinfo == NULL)
3917 		v_addpollinfo(vp);
3918 	if (vp->v_pollinfo == NULL)
3919 		return (ENOMEM);
3920 	knl = &vp->v_pollinfo->vpi_selinfo.si_note;
3921 	knlist_add(knl, kn, 0);
3922 
3923 	return (0);
3924 }
3925 
3926 /*
3927  * Detach knote from vnode
3928  */
3929 static void
3930 filt_vfsdetach(struct knote *kn)
3931 {
3932 	struct vnode *vp = (struct vnode *)kn->kn_hook;
3933 
3934 	KASSERT(vp->v_pollinfo != NULL, ("Missing v_pollinfo"));
3935 	knlist_remove(&vp->v_pollinfo->vpi_selinfo.si_note, kn, 0);
3936 }
3937 
3938 /*ARGSUSED*/
3939 static int
3940 filt_vfsread(struct knote *kn, long hint)
3941 {
3942 	struct vnode *vp = (struct vnode *)kn->kn_hook;
3943 	struct vattr va;
3944 
3945 	/*
3946 	 * filesystem is gone, so set the EOF flag and schedule
3947 	 * the knote for deletion.
3948 	 */
3949 	if (hint == NOTE_REVOKE) {
3950 		kn->kn_flags |= (EV_EOF | EV_ONESHOT);
3951 		return (1);
3952 	}
3953 
3954 	if (VOP_GETATTR(vp, &va, curthread->td_ucred, curthread))
3955 		return (0);
3956 
3957 	kn->kn_data = va.va_size - kn->kn_fp->f_offset;
3958 	return (kn->kn_data != 0);
3959 }
3960 
3961 /*ARGSUSED*/
3962 static int
3963 filt_vfswrite(struct knote *kn, long hint)
3964 {
3965 	/*
3966 	 * filesystem is gone, so set the EOF flag and schedule
3967 	 * the knote for deletion.
3968 	 */
3969 	if (hint == NOTE_REVOKE)
3970 		kn->kn_flags |= (EV_EOF | EV_ONESHOT);
3971 
3972 	kn->kn_data = 0;
3973 	return (1);
3974 }
3975 
3976 static int
3977 filt_vfsvnode(struct knote *kn, long hint)
3978 {
3979 	if (kn->kn_sfflags & hint)
3980 		kn->kn_fflags |= hint;
3981 	if (hint == NOTE_REVOKE) {
3982 		kn->kn_flags |= EV_EOF;
3983 		return (1);
3984 	}
3985 	return (kn->kn_fflags != 0);
3986 }
3987 
3988 int
3989 vfs_read_dirent(struct vop_readdir_args *ap, struct dirent *dp, off_t off)
3990 {
3991 	int error;
3992 
3993 	if (dp->d_reclen > ap->a_uio->uio_resid)
3994 		return (ENAMETOOLONG);
3995 	error = uiomove(dp, dp->d_reclen, ap->a_uio);
3996 	if (error) {
3997 		if (ap->a_ncookies != NULL) {
3998 			if (ap->a_cookies != NULL)
3999 				free(ap->a_cookies, M_TEMP);
4000 			ap->a_cookies = NULL;
4001 			*ap->a_ncookies = 0;
4002 		}
4003 		return (error);
4004 	}
4005 	if (ap->a_ncookies == NULL)
4006 		return (0);
4007 
4008 	KASSERT(ap->a_cookies,
4009 	    ("NULL ap->a_cookies value with non-NULL ap->a_ncookies!"));
4010 
4011 	*ap->a_cookies = realloc(*ap->a_cookies,
4012 	    (*ap->a_ncookies + 1) * sizeof(u_long), M_TEMP, M_WAITOK | M_ZERO);
4013 	(*ap->a_cookies)[*ap->a_ncookies] = off;
4014 	return (0);
4015 }
4016 
4017 /*
4018  * Mark for update the access time of the file if the filesystem
4019  * supports VA_MARK_ATIME.  This functionality is used by execve
4020  * and mmap, so we want to avoid the synchronous I/O implied by
4021  * directly setting va_atime for the sake of efficiency.
4022  */
4023 void
4024 vfs_mark_atime(struct vnode *vp, struct thread *td)
4025 {
4026 	struct vattr atimeattr;
4027 
4028 	if ((vp->v_mount->mnt_flag & (MNT_NOATIME | MNT_RDONLY)) == 0) {
4029 		VATTR_NULL(&atimeattr);
4030 		atimeattr.va_vaflags |= VA_MARK_ATIME;
4031 		(void)VOP_SETATTR(vp, &atimeattr, td->td_ucred, td);
4032 	}
4033 }
4034