40 */
41
42/*
43 * External virtual filesystem routines
44 */
45#include "opt_ddb.h"
46#include "opt_ffs.h"
47
48#include <sys/param.h>
49#include <sys/systm.h>
50#include <sys/bio.h>
51#include <sys/buf.h>
52#include <sys/conf.h>
53#include <sys/dirent.h>
54#include <sys/domain.h>
55#include <sys/eventhandler.h>
56#include <sys/fcntl.h>
57#include <sys/kernel.h>
58#include <sys/kthread.h>
59#include <sys/ktr.h>
60#include <sys/malloc.h>
61#include <sys/mount.h>
62#include <sys/namei.h>
63#include <sys/proc.h>
64#include <sys/reboot.h>
65#include <sys/socket.h>
66#include <sys/stat.h>
67#include <sys/sysctl.h>
68#include <sys/vmmeter.h>
69#include <sys/vnode.h>
70
71#include <machine/limits.h>
72#include <machine/mutex.h>
73
74#include <vm/vm.h>
75#include <vm/vm_object.h>
76#include <vm/vm_extern.h>
77#include <vm/pmap.h>
78#include <vm/vm_map.h>
79#include <vm/vm_page.h>
80#include <vm/vm_pager.h>
81#include <vm/vnode_pager.h>
82#include <vm/vm_zone.h>
83
84static MALLOC_DEFINE(M_NETADDR, "Export Host", "Export host address structure");
85
86static void insmntque __P((struct vnode *vp, struct mount *mp));
87static void vclean __P((struct vnode *vp, int flags, struct proc *p));
88static unsigned long numvnodes;
89SYSCTL_INT(_debug, OID_AUTO, numvnodes, CTLFLAG_RD, &numvnodes, 0, "");
90
91enum vtype iftovt_tab[16] = {
92 VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
93 VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
94};
95int vttoif_tab[9] = {
96 0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
97 S_IFSOCK, S_IFIFO, S_IFMT,
98};
99
100static TAILQ_HEAD(freelst, vnode) vnode_free_list; /* vnode free list */
101
102static u_long wantfreevnodes = 25;
103SYSCTL_INT(_debug, OID_AUTO, wantfreevnodes, CTLFLAG_RW, &wantfreevnodes, 0, "");
104static u_long freevnodes = 0;
105SYSCTL_INT(_debug, OID_AUTO, freevnodes, CTLFLAG_RD, &freevnodes, 0, "");
106
107static int reassignbufcalls;
108SYSCTL_INT(_vfs, OID_AUTO, reassignbufcalls, CTLFLAG_RW, &reassignbufcalls, 0, "");
109static int reassignbufloops;
110SYSCTL_INT(_vfs, OID_AUTO, reassignbufloops, CTLFLAG_RW, &reassignbufloops, 0, "");
111static int reassignbufsortgood;
112SYSCTL_INT(_vfs, OID_AUTO, reassignbufsortgood, CTLFLAG_RW, &reassignbufsortgood, 0, "");
113static int reassignbufsortbad;
114SYSCTL_INT(_vfs, OID_AUTO, reassignbufsortbad, CTLFLAG_RW, &reassignbufsortbad, 0, "");
115static int reassignbufmethod = 1;
116SYSCTL_INT(_vfs, OID_AUTO, reassignbufmethod, CTLFLAG_RW, &reassignbufmethod, 0, "");
117
118#ifdef ENABLE_VFS_IOOPT
119int vfs_ioopt = 0;
120SYSCTL_INT(_vfs, OID_AUTO, ioopt, CTLFLAG_RW, &vfs_ioopt, 0, "");
121#endif
122
123struct mntlist mountlist = TAILQ_HEAD_INITIALIZER(mountlist); /* mounted fs */
124struct simplelock mountlist_slock;
125struct simplelock mntvnode_slock;
126int nfs_mount_type = -1;
127#ifndef NULL_SIMPLELOCKS
128static struct simplelock mntid_slock;
129static struct simplelock vnode_free_list_slock;
130static struct simplelock spechash_slock;
131#endif
132struct nfs_public nfs_pub; /* publicly exported FS */
133static vm_zone_t vnode_zone;
134int prtactive = 0; /* 1 => print out reclaim of active vnodes */
135
136/*
137 * The workitem queue.
138 */
139#define SYNCER_MAXDELAY 32
140static int syncer_maxdelay = SYNCER_MAXDELAY; /* maximum delay time */
141time_t syncdelay = 30; /* max time to delay syncing data */
142time_t filedelay = 30; /* time to delay syncing files */
143SYSCTL_INT(_kern, OID_AUTO, filedelay, CTLFLAG_RW, &filedelay, 0, "");
144time_t dirdelay = 29; /* time to delay syncing directories */
145SYSCTL_INT(_kern, OID_AUTO, dirdelay, CTLFLAG_RW, &dirdelay, 0, "");
146time_t metadelay = 28; /* time to delay syncing metadata */
147SYSCTL_INT(_kern, OID_AUTO, metadelay, CTLFLAG_RW, &metadelay, 0, "");
148static int rushjob; /* number of slots to run ASAP */
149static int stat_rush_requests; /* number of times I/O speeded up */
150SYSCTL_INT(_debug, OID_AUTO, rush_requests, CTLFLAG_RW, &stat_rush_requests, 0, "");
151
152static int syncer_delayno = 0;
153static long syncer_mask;
154LIST_HEAD(synclist, vnode);
155static struct synclist *syncer_workitem_pending;
156
157int desiredvnodes;
158SYSCTL_INT(_kern, KERN_MAXVNODES, maxvnodes, CTLFLAG_RW,
159 &desiredvnodes, 0, "Maximum number of vnodes");
160
161static void vfs_free_addrlist __P((struct netexport *nep));
162static int vfs_free_netcred __P((struct radix_node *rn, void *w));
163static int vfs_hang_addrlist __P((struct mount *mp, struct netexport *nep,
164 struct export_args *argp));
165
166/*
167 * Initialize the vnode management data structures.
168 */
169void
170vntblinit()
171{
172
173 desiredvnodes = maxproc + cnt.v_page_count / 4;
174 simple_lock_init(&mntvnode_slock);
175 simple_lock_init(&mntid_slock);
176 simple_lock_init(&spechash_slock);
177 TAILQ_INIT(&vnode_free_list);
178 simple_lock_init(&vnode_free_list_slock);
179 vnode_zone = zinit("VNODE", sizeof (struct vnode), 0, 0, 5);
180 /*
181 * Initialize the filesystem syncer.
182 */
183 syncer_workitem_pending = hashinit(syncer_maxdelay, M_VNODE,
184 &syncer_mask);
185 syncer_maxdelay = syncer_mask + 1;
186}
187
188/*
189 * Mark a mount point as busy. Used to synchronize access and to delay
190 * unmounting. Interlock is not released on failure.
191 */
192int
193vfs_busy(mp, flags, interlkp, p)
194 struct mount *mp;
195 int flags;
196 struct simplelock *interlkp;
197 struct proc *p;
198{
199 int lkflags;
200
201 if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
202 if (flags & LK_NOWAIT)
203 return (ENOENT);
204 mp->mnt_kern_flag |= MNTK_MWAIT;
205 if (interlkp) {
206 simple_unlock(interlkp);
207 }
208 /*
209 * Since all busy locks are shared except the exclusive
210 * lock granted when unmounting, the only place that a
211 * wakeup needs to be done is at the release of the
212 * exclusive lock at the end of dounmount.
213 */
214 tsleep((caddr_t)mp, PVFS, "vfs_busy", 0);
215 if (interlkp) {
216 simple_lock(interlkp);
217 }
218 return (ENOENT);
219 }
220 lkflags = LK_SHARED | LK_NOPAUSE;
221 if (interlkp)
222 lkflags |= LK_INTERLOCK;
223 if (lockmgr(&mp->mnt_lock, lkflags, interlkp, p))
224 panic("vfs_busy: unexpected lock failure");
225 return (0);
226}
227
228/*
229 * Free a busy filesystem.
230 */
231void
232vfs_unbusy(mp, p)
233 struct mount *mp;
234 struct proc *p;
235{
236
237 lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, p);
238}
239
240/*
241 * Lookup a filesystem type, and if found allocate and initialize
242 * a mount structure for it.
243 *
244 * Devname is usually updated by mount(8) after booting.
245 */
246int
247vfs_rootmountalloc(fstypename, devname, mpp)
248 char *fstypename;
249 char *devname;
250 struct mount **mpp;
251{
252 struct proc *p = curproc; /* XXX */
253 struct vfsconf *vfsp;
254 struct mount *mp;
255
256 if (fstypename == NULL)
257 return (ENODEV);
258 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
259 if (!strcmp(vfsp->vfc_name, fstypename))
260 break;
261 if (vfsp == NULL)
262 return (ENODEV);
263 mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK);
264 bzero((char *)mp, (u_long)sizeof(struct mount));
265 lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE);
266 (void)vfs_busy(mp, LK_NOWAIT, 0, p);
267 LIST_INIT(&mp->mnt_vnodelist);
268 mp->mnt_vfc = vfsp;
269 mp->mnt_op = vfsp->vfc_vfsops;
270 mp->mnt_flag = MNT_RDONLY;
271 mp->mnt_vnodecovered = NULLVP;
272 vfsp->vfc_refcount++;
273 mp->mnt_iosize_max = DFLTPHYS;
274 mp->mnt_stat.f_type = vfsp->vfc_typenum;
275 mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
276 strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
277 mp->mnt_stat.f_mntonname[0] = '/';
278 mp->mnt_stat.f_mntonname[1] = 0;
279 (void) copystr(devname, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 0);
280 *mpp = mp;
281 return (0);
282}
283
284/*
285 * Find an appropriate filesystem to use for the root. If a filesystem
286 * has not been preselected, walk through the list of known filesystems
287 * trying those that have mountroot routines, and try them until one
288 * works or we have tried them all.
289 */
290#ifdef notdef /* XXX JH */
291int
292lite2_vfs_mountroot()
293{
294 struct vfsconf *vfsp;
295 extern int (*lite2_mountroot) __P((void));
296 int error;
297
298 if (lite2_mountroot != NULL)
299 return ((*lite2_mountroot)());
300 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
301 if (vfsp->vfc_mountroot == NULL)
302 continue;
303 if ((error = (*vfsp->vfc_mountroot)()) == 0)
304 return (0);
305 printf("%s_mountroot failed: %d\n", vfsp->vfc_name, error);
306 }
307 return (ENODEV);
308}
309#endif
310
311/*
312 * Lookup a mount point by filesystem identifier.
313 */
314struct mount *
315vfs_getvfs(fsid)
316 fsid_t *fsid;
317{
318 register struct mount *mp;
319
320 simple_lock(&mountlist_slock);
321 TAILQ_FOREACH(mp, &mountlist, mnt_list) {
322 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
323 mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
324 simple_unlock(&mountlist_slock);
325 return (mp);
326 }
327 }
328 simple_unlock(&mountlist_slock);
329 return ((struct mount *) 0);
330}
331
332/*
333 * Get a new unique fsid. Try to make its val[0] unique, since this value
334 * will be used to create fake device numbers for stat(). Also try (but
335 * not so hard) make its val[0] unique mod 2^16, since some emulators only
336 * support 16-bit device numbers. We end up with unique val[0]'s for the
337 * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
338 *
339 * Keep in mind that several mounts may be running in parallel. Starting
340 * the search one past where the previous search terminated is both a
341 * micro-optimization and a defense against returning the same fsid to
342 * different mounts.
343 */
344void
345vfs_getnewfsid(mp)
346 struct mount *mp;
347{
348 static u_int16_t mntid_base;
349 fsid_t tfsid;
350 int mtype;
351
352 simple_lock(&mntid_slock);
353 mtype = mp->mnt_vfc->vfc_typenum;
354 tfsid.val[1] = mtype;
355 mtype = (mtype & 0xFF) << 24;
356 for (;;) {
357 tfsid.val[0] = makeudev(255,
358 mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF));
359 mntid_base++;
360 if (vfs_getvfs(&tfsid) == NULL)
361 break;
362 }
363 mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
364 mp->mnt_stat.f_fsid.val[1] = tfsid.val[1];
365 simple_unlock(&mntid_slock);
366}
367
368/*
369 * Knob to control the precision of file timestamps:
370 *
371 * 0 = seconds only; nanoseconds zeroed.
372 * 1 = seconds and nanoseconds, accurate within 1/HZ.
373 * 2 = seconds and nanoseconds, truncated to microseconds.
374 * >=3 = seconds and nanoseconds, maximum precision.
375 */
376enum { TSP_SEC, TSP_HZ, TSP_USEC, TSP_NSEC };
377
378static int timestamp_precision = TSP_SEC;
379SYSCTL_INT(_vfs, OID_AUTO, timestamp_precision, CTLFLAG_RW,
380 ×tamp_precision, 0, "");
381
382/*
383 * Get a current timestamp.
384 */
385void
386vfs_timestamp(tsp)
387 struct timespec *tsp;
388{
389 struct timeval tv;
390
391 switch (timestamp_precision) {
392 case TSP_SEC:
393 tsp->tv_sec = time_second;
394 tsp->tv_nsec = 0;
395 break;
396 case TSP_HZ:
397 getnanotime(tsp);
398 break;
399 case TSP_USEC:
400 microtime(&tv);
401 TIMEVAL_TO_TIMESPEC(&tv, tsp);
402 break;
403 case TSP_NSEC:
404 default:
405 nanotime(tsp);
406 break;
407 }
408}
409
410/*
411 * Set vnode attributes to VNOVAL
412 */
413void
414vattr_null(vap)
415 register struct vattr *vap;
416{
417
418 vap->va_type = VNON;
419 vap->va_size = VNOVAL;
420 vap->va_bytes = VNOVAL;
421 vap->va_mode = VNOVAL;
422 vap->va_nlink = VNOVAL;
423 vap->va_uid = VNOVAL;
424 vap->va_gid = VNOVAL;
425 vap->va_fsid = VNOVAL;
426 vap->va_fileid = VNOVAL;
427 vap->va_blocksize = VNOVAL;
428 vap->va_rdev = VNOVAL;
429 vap->va_atime.tv_sec = VNOVAL;
430 vap->va_atime.tv_nsec = VNOVAL;
431 vap->va_mtime.tv_sec = VNOVAL;
432 vap->va_mtime.tv_nsec = VNOVAL;
433 vap->va_ctime.tv_sec = VNOVAL;
434 vap->va_ctime.tv_nsec = VNOVAL;
435 vap->va_flags = VNOVAL;
436 vap->va_gen = VNOVAL;
437 vap->va_vaflags = 0;
438}
439
440/*
441 * Routines having to do with the management of the vnode table.
442 */
443
444/*
445 * Return the next vnode from the free list.
446 */
447int
448getnewvnode(tag, mp, vops, vpp)
449 enum vtagtype tag;
450 struct mount *mp;
451 vop_t **vops;
452 struct vnode **vpp;
453{
454 int s, count;
455 struct proc *p = curproc; /* XXX */
456 struct vnode *vp = NULL;
457 struct mount *vnmp;
458 vm_object_t object;
459
460 /*
461 * We take the least recently used vnode from the freelist
462 * if we can get it and it has no cached pages, and no
463 * namecache entries are relative to it.
464 * Otherwise we allocate a new vnode
465 */
466
467 s = splbio();
468 simple_lock(&vnode_free_list_slock);
469
470 if (wantfreevnodes && freevnodes < wantfreevnodes) {
471 vp = NULL;
472 } else if (!wantfreevnodes && freevnodes <= desiredvnodes) {
473 /*
474 * XXX: this is only here to be backwards compatible
475 */
476 vp = NULL;
477 } else for (count = 0; count < freevnodes; count++) {
478 vp = TAILQ_FIRST(&vnode_free_list);
479 if (vp == NULL || vp->v_usecount)
480 panic("getnewvnode: free vnode isn't");
481 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
482 /*
483 * Don't recycle if active in the namecache or
484 * if it still has cached pages or we cannot get
485 * its interlock.
486 */
487 if (LIST_FIRST(&vp->v_cache_src) != NULL ||
488 (VOP_GETVOBJECT(vp, &object) == 0 &&
489 (object->resident_page_count || object->ref_count)) ||
490 !simple_lock_try(&vp->v_interlock)) {
491 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
492 vp = NULL;
493 continue;
494 }
495 /*
496 * Skip over it if its filesystem is being suspended.
497 */
498 if (vn_start_write(vp, &vnmp, V_NOWAIT) == 0)
499 break;
500 simple_unlock(&vp->v_interlock);
501 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
502 vp = NULL;
503 }
504 if (vp) {
505 vp->v_flag |= VDOOMED;
506 freevnodes--;
507 simple_unlock(&vnode_free_list_slock);
508 cache_purge(vp);
509 vp->v_lease = NULL;
510 if (vp->v_type != VBAD) {
511 vgonel(vp, p);
512 } else {
513 simple_unlock(&vp->v_interlock);
514 }
515 vn_finished_write(vnmp);
516
517#ifdef INVARIANTS
518 {
519 int s;
520
521 if (vp->v_data)
522 panic("cleaned vnode isn't");
523 s = splbio();
524 if (vp->v_numoutput)
525 panic("Clean vnode has pending I/O's");
526 splx(s);
527 if (vp->v_writecount != 0)
528 panic("Non-zero write count");
529 }
530#endif
531 vp->v_flag = 0;
532 vp->v_lastw = 0;
533 vp->v_lasta = 0;
534 vp->v_cstart = 0;
535 vp->v_clen = 0;
536 vp->v_socket = 0;
537 } else {
538 simple_unlock(&vnode_free_list_slock);
539 vp = (struct vnode *) zalloc(vnode_zone);
540 bzero((char *) vp, sizeof *vp);
541 simple_lock_init(&vp->v_interlock);
542 vp->v_dd = vp;
543 cache_purge(vp);
544 LIST_INIT(&vp->v_cache_src);
545 TAILQ_INIT(&vp->v_cache_dst);
546 numvnodes++;
547 }
548
549 TAILQ_INIT(&vp->v_cleanblkhd);
550 TAILQ_INIT(&vp->v_dirtyblkhd);
551 vp->v_type = VNON;
552 vp->v_tag = tag;
553 vp->v_op = vops;
554 insmntque(vp, mp);
555 *vpp = vp;
556 vp->v_usecount = 1;
557 vp->v_data = 0;
558 splx(s);
559
560 vfs_object_create(vp, p, p->p_ucred);
561 return (0);
562}
563
564/*
565 * Move a vnode from one mount queue to another.
566 */
567static void
568insmntque(vp, mp)
569 register struct vnode *vp;
570 register struct mount *mp;
571{
572
573 simple_lock(&mntvnode_slock);
574 /*
575 * Delete from old mount point vnode list, if on one.
576 */
577 if (vp->v_mount != NULL)
578 LIST_REMOVE(vp, v_mntvnodes);
579 /*
580 * Insert into list of vnodes for the new mount point, if available.
581 */
582 if ((vp->v_mount = mp) == NULL) {
583 simple_unlock(&mntvnode_slock);
584 return;
585 }
586 LIST_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes);
587 simple_unlock(&mntvnode_slock);
588}
589
590/*
591 * Update outstanding I/O count and do wakeup if requested.
592 */
593void
594vwakeup(bp)
595 register struct buf *bp;
596{
597 register struct vnode *vp;
598
599 bp->b_flags &= ~B_WRITEINPROG;
600 if ((vp = bp->b_vp)) {
601 vp->v_numoutput--;
602 if (vp->v_numoutput < 0)
603 panic("vwakeup: neg numoutput");
604 if ((vp->v_numoutput == 0) && (vp->v_flag & VBWAIT)) {
605 vp->v_flag &= ~VBWAIT;
606 wakeup((caddr_t) &vp->v_numoutput);
607 }
608 }
609}
610
611/*
612 * Flush out and invalidate all buffers associated with a vnode.
613 * Called with the underlying object locked.
614 */
615int
616vinvalbuf(vp, flags, cred, p, slpflag, slptimeo)
617 register struct vnode *vp;
618 int flags;
619 struct ucred *cred;
620 struct proc *p;
621 int slpflag, slptimeo;
622{
623 register struct buf *bp;
624 struct buf *nbp, *blist;
625 int s, error;
626 vm_object_t object;
627
628 if (flags & V_SAVE) {
629 s = splbio();
630 while (vp->v_numoutput) {
631 vp->v_flag |= VBWAIT;
632 error = tsleep((caddr_t)&vp->v_numoutput,
633 slpflag | (PRIBIO + 1), "vinvlbuf", slptimeo);
634 if (error) {
635 splx(s);
636 return (error);
637 }
638 }
639 if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
640 splx(s);
641 if ((error = VOP_FSYNC(vp, cred, MNT_WAIT, p)) != 0)
642 return (error);
643 s = splbio();
644 if (vp->v_numoutput > 0 ||
645 !TAILQ_EMPTY(&vp->v_dirtyblkhd))
646 panic("vinvalbuf: dirty bufs");
647 }
648 splx(s);
649 }
650 s = splbio();
651 for (;;) {
652 blist = TAILQ_FIRST(&vp->v_cleanblkhd);
653 if (!blist)
654 blist = TAILQ_FIRST(&vp->v_dirtyblkhd);
655 if (!blist)
656 break;
657
658 for (bp = blist; bp; bp = nbp) {
659 nbp = TAILQ_NEXT(bp, b_vnbufs);
660 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
661 error = BUF_TIMELOCK(bp,
662 LK_EXCLUSIVE | LK_SLEEPFAIL,
663 "vinvalbuf", slpflag, slptimeo);
664 if (error == ENOLCK)
665 break;
666 splx(s);
667 return (error);
668 }
669 /*
670 * XXX Since there are no node locks for NFS, I
671 * believe there is a slight chance that a delayed
672 * write will occur while sleeping just above, so
673 * check for it. Note that vfs_bio_awrite expects
674 * buffers to reside on a queue, while VOP_BWRITE and
675 * brelse do not.
676 */
677 if (((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI) &&
678 (flags & V_SAVE)) {
679
680 if (bp->b_vp == vp) {
681 if (bp->b_flags & B_CLUSTEROK) {
682 BUF_UNLOCK(bp);
683 vfs_bio_awrite(bp);
684 } else {
685 bremfree(bp);
686 bp->b_flags |= B_ASYNC;
687 BUF_WRITE(bp);
688 }
689 } else {
690 bremfree(bp);
691 (void) BUF_WRITE(bp);
692 }
693 break;
694 }
695 bremfree(bp);
696 bp->b_flags |= (B_INVAL | B_NOCACHE | B_RELBUF);
697 bp->b_flags &= ~B_ASYNC;
698 brelse(bp);
699 }
700 }
701
702 while (vp->v_numoutput > 0) {
703 vp->v_flag |= VBWAIT;
704 tsleep(&vp->v_numoutput, PVM, "vnvlbv", 0);
705 }
706
707 splx(s);
708
709 /*
710 * Destroy the copy in the VM cache, too.
711 */
712 simple_lock(&vp->v_interlock);
713 if (VOP_GETVOBJECT(vp, &object) == 0) {
714 vm_object_page_remove(object, 0, 0,
715 (flags & V_SAVE) ? TRUE : FALSE);
716 }
717 simple_unlock(&vp->v_interlock);
718
719 if (!TAILQ_EMPTY(&vp->v_dirtyblkhd) || !TAILQ_EMPTY(&vp->v_cleanblkhd))
720 panic("vinvalbuf: flush failed");
721 return (0);
722}
723
724/*
725 * Truncate a file's buffer and pages to a specified length. This
726 * is in lieu of the old vinvalbuf mechanism, which performed unneeded
727 * sync activity.
728 */
729int
730vtruncbuf(vp, cred, p, length, blksize)
731 register struct vnode *vp;
732 struct ucred *cred;
733 struct proc *p;
734 off_t length;
735 int blksize;
736{
737 register struct buf *bp;
738 struct buf *nbp;
739 int s, anyfreed;
740 int trunclbn;
741
742 /*
743 * Round up to the *next* lbn.
744 */
745 trunclbn = (length + blksize - 1) / blksize;
746
747 s = splbio();
748restart:
749 anyfreed = 1;
750 for (;anyfreed;) {
751 anyfreed = 0;
752 for (bp = TAILQ_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) {
753 nbp = TAILQ_NEXT(bp, b_vnbufs);
754 if (bp->b_lblkno >= trunclbn) {
755 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
756 BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
757 goto restart;
758 } else {
759 bremfree(bp);
760 bp->b_flags |= (B_INVAL | B_RELBUF);
761 bp->b_flags &= ~B_ASYNC;
762 brelse(bp);
763 anyfreed = 1;
764 }
765 if (nbp &&
766 (((nbp->b_xflags & BX_VNCLEAN) == 0) ||
767 (nbp->b_vp != vp) ||
768 (nbp->b_flags & B_DELWRI))) {
769 goto restart;
770 }
771 }
772 }
773
774 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
775 nbp = TAILQ_NEXT(bp, b_vnbufs);
776 if (bp->b_lblkno >= trunclbn) {
777 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
778 BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
779 goto restart;
780 } else {
781 bremfree(bp);
782 bp->b_flags |= (B_INVAL | B_RELBUF);
783 bp->b_flags &= ~B_ASYNC;
784 brelse(bp);
785 anyfreed = 1;
786 }
787 if (nbp &&
788 (((nbp->b_xflags & BX_VNDIRTY) == 0) ||
789 (nbp->b_vp != vp) ||
790 (nbp->b_flags & B_DELWRI) == 0)) {
791 goto restart;
792 }
793 }
794 }
795 }
796
797 if (length > 0) {
798restartsync:
799 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
800 nbp = TAILQ_NEXT(bp, b_vnbufs);
801 if ((bp->b_flags & B_DELWRI) && (bp->b_lblkno < 0)) {
802 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
803 BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
804 goto restart;
805 } else {
806 bremfree(bp);
807 if (bp->b_vp == vp) {
808 bp->b_flags |= B_ASYNC;
809 } else {
810 bp->b_flags &= ~B_ASYNC;
811 }
812 BUF_WRITE(bp);
813 }
814 goto restartsync;
815 }
816
817 }
818 }
819
820 while (vp->v_numoutput > 0) {
821 vp->v_flag |= VBWAIT;
822 tsleep(&vp->v_numoutput, PVM, "vbtrunc", 0);
823 }
824
825 splx(s);
826
827 vnode_pager_setsize(vp, length);
828
829 return (0);
830}
831
832/*
833 * Associate a buffer with a vnode.
834 */
835void
836bgetvp(vp, bp)
837 register struct vnode *vp;
838 register struct buf *bp;
839{
840 int s;
841
842 KASSERT(bp->b_vp == NULL, ("bgetvp: not free"));
843
844 vhold(vp);
845 bp->b_vp = vp;
846 bp->b_dev = vn_todev(vp);
847 /*
848 * Insert onto list for new vnode.
849 */
850 s = splbio();
851 bp->b_xflags |= BX_VNCLEAN;
852 bp->b_xflags &= ~BX_VNDIRTY;
853 TAILQ_INSERT_TAIL(&vp->v_cleanblkhd, bp, b_vnbufs);
854 splx(s);
855}
856
857/*
858 * Disassociate a buffer from a vnode.
859 */
860void
861brelvp(bp)
862 register struct buf *bp;
863{
864 struct vnode *vp;
865 struct buflists *listheadp;
866 int s;
867
868 KASSERT(bp->b_vp != NULL, ("brelvp: NULL"));
869
870 /*
871 * Delete from old vnode list, if on one.
872 */
873 vp = bp->b_vp;
874 s = splbio();
875 if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN)) {
876 if (bp->b_xflags & BX_VNDIRTY)
877 listheadp = &vp->v_dirtyblkhd;
878 else
879 listheadp = &vp->v_cleanblkhd;
880 TAILQ_REMOVE(listheadp, bp, b_vnbufs);
881 bp->b_xflags &= ~(BX_VNDIRTY | BX_VNCLEAN);
882 }
883 if ((vp->v_flag & VONWORKLST) && TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
884 vp->v_flag &= ~VONWORKLST;
885 LIST_REMOVE(vp, v_synclist);
886 }
887 splx(s);
888 bp->b_vp = (struct vnode *) 0;
889 vdrop(vp);
890}
891
892/*
893 * The workitem queue.
894 *
895 * It is useful to delay writes of file data and filesystem metadata
896 * for tens of seconds so that quickly created and deleted files need
897 * not waste disk bandwidth being created and removed. To realize this,
898 * we append vnodes to a "workitem" queue. When running with a soft
899 * updates implementation, most pending metadata dependencies should
900 * not wait for more than a few seconds. Thus, mounted on block devices
901 * are delayed only about a half the time that file data is delayed.
902 * Similarly, directory updates are more critical, so are only delayed
903 * about a third the time that file data is delayed. Thus, there are
904 * SYNCER_MAXDELAY queues that are processed round-robin at a rate of
905 * one each second (driven off the filesystem syncer process). The
906 * syncer_delayno variable indicates the next queue that is to be processed.
907 * Items that need to be processed soon are placed in this queue:
908 *
909 * syncer_workitem_pending[syncer_delayno]
910 *
911 * A delay of fifteen seconds is done by placing the request fifteen
912 * entries later in the queue:
913 *
914 * syncer_workitem_pending[(syncer_delayno + 15) & syncer_mask]
915 *
916 */
917
918/*
919 * Add an item to the syncer work queue.
920 */
921static void
922vn_syncer_add_to_worklist(struct vnode *vp, int delay)
923{
924 int s, slot;
925
926 s = splbio();
927
928 if (vp->v_flag & VONWORKLST) {
929 LIST_REMOVE(vp, v_synclist);
930 }
931
932 if (delay > syncer_maxdelay - 2)
933 delay = syncer_maxdelay - 2;
934 slot = (syncer_delayno + delay) & syncer_mask;
935
936 LIST_INSERT_HEAD(&syncer_workitem_pending[slot], vp, v_synclist);
937 vp->v_flag |= VONWORKLST;
938 splx(s);
939}
940
941struct proc *updateproc;
942static void sched_sync __P((void));
943static struct kproc_desc up_kp = {
944 "syncer",
945 sched_sync,
946 &updateproc
947};
948SYSINIT(syncer, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &up_kp)
949
950/*
951 * System filesystem synchronizer daemon.
952 */
953void
954sched_sync(void)
955{
956 struct synclist *slp;
957 struct vnode *vp;
958 struct mount *mp;
959 long starttime;
960 int s;
961 struct proc *p = updateproc;
962
963 mtx_enter(&Giant, MTX_DEF);
964
965 EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, p,
966 SHUTDOWN_PRI_LAST);
967
968 for (;;) {
969 kproc_suspend_loop(p);
970
971 starttime = time_second;
972
973 /*
974 * Push files whose dirty time has expired. Be careful
975 * of interrupt race on slp queue.
976 */
977 s = splbio();
978 slp = &syncer_workitem_pending[syncer_delayno];
979 syncer_delayno += 1;
980 if (syncer_delayno == syncer_maxdelay)
981 syncer_delayno = 0;
982 splx(s);
983
984 while ((vp = LIST_FIRST(slp)) != NULL) {
985 if (VOP_ISLOCKED(vp, NULL) == 0 &&
986 vn_start_write(vp, &mp, V_NOWAIT) == 0) {
987 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
988 (void) VOP_FSYNC(vp, p->p_ucred, MNT_LAZY, p);
989 VOP_UNLOCK(vp, 0, p);
990 vn_finished_write(mp);
991 }
992 s = splbio();
993 if (LIST_FIRST(slp) == vp) {
994 /*
995 * Note: v_tag VT_VFS vps can remain on the
996 * worklist too with no dirty blocks, but
997 * since sync_fsync() moves it to a different
998 * slot we are safe.
999 */
1000 if (TAILQ_EMPTY(&vp->v_dirtyblkhd) &&
1001 !vn_isdisk(vp, NULL))
1002 panic("sched_sync: fsync failed vp %p tag %d", vp, vp->v_tag);
1003 /*
1004 * Put us back on the worklist. The worklist
1005 * routine will remove us from our current
1006 * position and then add us back in at a later
1007 * position.
1008 */
1009 vn_syncer_add_to_worklist(vp, syncdelay);
1010 }
1011 splx(s);
1012 }
1013
1014 /*
1015 * Do soft update processing.
1016 */
1017#ifdef SOFTUPDATES
1018 softdep_process_worklist(NULL);
1019#endif
1020
1021 /*
1022 * The variable rushjob allows the kernel to speed up the
1023 * processing of the filesystem syncer process. A rushjob
1024 * value of N tells the filesystem syncer to process the next
1025 * N seconds worth of work on its queue ASAP. Currently rushjob
1026 * is used by the soft update code to speed up the filesystem
1027 * syncer process when the incore state is getting so far
1028 * ahead of the disk that the kernel memory pool is being
1029 * threatened with exhaustion.
1030 */
1031 if (rushjob > 0) {
1032 rushjob -= 1;
1033 continue;
1034 }
1035 /*
1036 * If it has taken us less than a second to process the
1037 * current work, then wait. Otherwise start right over
1038 * again. We can still lose time if any single round
1039 * takes more than two seconds, but it does not really
1040 * matter as we are just trying to generally pace the
1041 * filesystem activity.
1042 */
1043 if (time_second == starttime)
1044 tsleep(&lbolt, PPAUSE, "syncer", 0);
1045 }
1046}
1047
1048/*
1049 * Request the syncer daemon to speed up its work.
1050 * We never push it to speed up more than half of its
1051 * normal turn time, otherwise it could take over the cpu.
1052 */
1053int
1054speedup_syncer()
1055{
1056 int s;
1057
1058 s = splhigh();
1059 if (updateproc->p_wchan == &lbolt)
1060 setrunnable(updateproc);
1061 splx(s);
1062 if (rushjob < syncdelay / 2) {
1063 rushjob += 1;
1064 stat_rush_requests += 1;
1065 return (1);
1066 }
1067 return(0);
1068}
1069
1070/*
1071 * Associate a p-buffer with a vnode.
1072 *
1073 * Also sets B_PAGING flag to indicate that vnode is not fully associated
1074 * with the buffer. i.e. the bp has not been linked into the vnode or
1075 * ref-counted.
1076 */
1077void
1078pbgetvp(vp, bp)
1079 register struct vnode *vp;
1080 register struct buf *bp;
1081{
1082
1083 KASSERT(bp->b_vp == NULL, ("pbgetvp: not free"));
1084
1085 bp->b_vp = vp;
1086 bp->b_flags |= B_PAGING;
1087 bp->b_dev = vn_todev(vp);
1088}
1089
1090/*
1091 * Disassociate a p-buffer from a vnode.
1092 */
1093void
1094pbrelvp(bp)
1095 register struct buf *bp;
1096{
1097
1098 KASSERT(bp->b_vp != NULL, ("pbrelvp: NULL"));
1099
1100 /* XXX REMOVE ME */
1101 if (bp->b_vnbufs.tqe_next != NULL) {
1102 panic(
1103 "relpbuf(): b_vp was probably reassignbuf()d %p %x",
1104 bp,
1105 (int)bp->b_flags
1106 );
1107 }
1108 bp->b_vp = (struct vnode *) 0;
1109 bp->b_flags &= ~B_PAGING;
1110}
1111
1112void
1113pbreassignbuf(bp, newvp)
1114 struct buf *bp;
1115 struct vnode *newvp;
1116{
1117 if ((bp->b_flags & B_PAGING) == 0) {
1118 panic(
1119 "pbreassignbuf() on non phys bp %p",
1120 bp
1121 );
1122 }
1123 bp->b_vp = newvp;
1124}
1125
1126/*
1127 * Reassign a buffer from one vnode to another.
1128 * Used to assign file specific control information
1129 * (indirect blocks) to the vnode to which they belong.
1130 */
1131void
1132reassignbuf(bp, newvp)
1133 register struct buf *bp;
1134 register struct vnode *newvp;
1135{
1136 struct buflists *listheadp;
1137 int delay;
1138 int s;
1139
1140 if (newvp == NULL) {
1141 printf("reassignbuf: NULL");
1142 return;
1143 }
1144 ++reassignbufcalls;
1145
1146 /*
1147 * B_PAGING flagged buffers cannot be reassigned because their vp
1148 * is not fully linked in.
1149 */
1150 if (bp->b_flags & B_PAGING)
1151 panic("cannot reassign paging buffer");
1152
1153 s = splbio();
1154 /*
1155 * Delete from old vnode list, if on one.
1156 */
1157 if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN)) {
1158 if (bp->b_xflags & BX_VNDIRTY)
1159 listheadp = &bp->b_vp->v_dirtyblkhd;
1160 else
1161 listheadp = &bp->b_vp->v_cleanblkhd;
1162 TAILQ_REMOVE(listheadp, bp, b_vnbufs);
1163 bp->b_xflags &= ~(BX_VNDIRTY | BX_VNCLEAN);
1164 if (bp->b_vp != newvp) {
1165 vdrop(bp->b_vp);
1166 bp->b_vp = NULL; /* for clarification */
1167 }
1168 }
1169 /*
1170 * If dirty, put on list of dirty buffers; otherwise insert onto list
1171 * of clean buffers.
1172 */
1173 if (bp->b_flags & B_DELWRI) {
1174 struct buf *tbp;
1175
1176 listheadp = &newvp->v_dirtyblkhd;
1177 if ((newvp->v_flag & VONWORKLST) == 0) {
1178 switch (newvp->v_type) {
1179 case VDIR:
1180 delay = dirdelay;
1181 break;
1182 case VCHR:
1183 case VBLK:
1184 if (newvp->v_specmountpoint != NULL) {
1185 delay = metadelay;
1186 break;
1187 }
1188 /* fall through */
1189 default:
1190 delay = filedelay;
1191 }
1192 vn_syncer_add_to_worklist(newvp, delay);
1193 }
1194 bp->b_xflags |= BX_VNDIRTY;
1195 tbp = TAILQ_FIRST(listheadp);
1196 if (tbp == NULL ||
1197 bp->b_lblkno == 0 ||
1198 (bp->b_lblkno > 0 && tbp->b_lblkno < 0) ||
1199 (bp->b_lblkno > 0 && bp->b_lblkno < tbp->b_lblkno)) {
1200 TAILQ_INSERT_HEAD(listheadp, bp, b_vnbufs);
1201 ++reassignbufsortgood;
1202 } else if (bp->b_lblkno < 0) {
1203 TAILQ_INSERT_TAIL(listheadp, bp, b_vnbufs);
1204 ++reassignbufsortgood;
1205 } else if (reassignbufmethod == 1) {
1206 /*
1207 * New sorting algorithm, only handle sequential case,
1208 * otherwise append to end (but before metadata)
1209 */
1210 if ((tbp = gbincore(newvp, bp->b_lblkno - 1)) != NULL &&
1211 (tbp->b_xflags & BX_VNDIRTY)) {
1212 /*
1213 * Found the best place to insert the buffer
1214 */
1215 TAILQ_INSERT_AFTER(listheadp, tbp, bp, b_vnbufs);
1216 ++reassignbufsortgood;
1217 } else {
1218 /*
1219 * Missed, append to end, but before meta-data.
1220 * We know that the head buffer in the list is
1221 * not meta-data due to prior conditionals.
1222 *
1223 * Indirect effects: NFS second stage write
1224 * tends to wind up here, giving maximum
1225 * distance between the unstable write and the
1226 * commit rpc.
1227 */
1228 tbp = TAILQ_LAST(listheadp, buflists);
1229 while (tbp && tbp->b_lblkno < 0)
1230 tbp = TAILQ_PREV(tbp, buflists, b_vnbufs);
1231 TAILQ_INSERT_AFTER(listheadp, tbp, bp, b_vnbufs);
1232 ++reassignbufsortbad;
1233 }
1234 } else {
1235 /*
1236 * Old sorting algorithm, scan queue and insert
1237 */
1238 struct buf *ttbp;
1239 while ((ttbp = TAILQ_NEXT(tbp, b_vnbufs)) &&
1240 (ttbp->b_lblkno < bp->b_lblkno)) {
1241 ++reassignbufloops;
1242 tbp = ttbp;
1243 }
1244 TAILQ_INSERT_AFTER(listheadp, tbp, bp, b_vnbufs);
1245 }
1246 } else {
1247 bp->b_xflags |= BX_VNCLEAN;
1248 TAILQ_INSERT_TAIL(&newvp->v_cleanblkhd, bp, b_vnbufs);
1249 if ((newvp->v_flag & VONWORKLST) &&
1250 TAILQ_EMPTY(&newvp->v_dirtyblkhd)) {
1251 newvp->v_flag &= ~VONWORKLST;
1252 LIST_REMOVE(newvp, v_synclist);
1253 }
1254 }
1255 if (bp->b_vp != newvp) {
1256 bp->b_vp = newvp;
1257 vhold(bp->b_vp);
1258 }
1259 splx(s);
1260}
1261
1262/*
1263 * Create a vnode for a block device.
1264 * Used for mounting the root file system.
1265 * XXX: This now changed to a VCHR due to the block/char merging.
1266 */
1267int
1268bdevvp(dev, vpp)
1269 dev_t dev;
1270 struct vnode **vpp;
1271{
1272 register struct vnode *vp;
1273 struct vnode *nvp;
1274 int error;
1275
1276 if (dev == NODEV) {
1277 *vpp = NULLVP;
1278 return (ENXIO);
1279 }
1280 error = getnewvnode(VT_NON, (struct mount *)0, spec_vnodeop_p, &nvp);
1281 if (error) {
1282 *vpp = NULLVP;
1283 return (error);
1284 }
1285 vp = nvp;
1286 vp->v_type = VCHR;
1287 addalias(vp, dev);
1288 *vpp = vp;
1289 return (0);
1290}
1291
1292/*
1293 * Add vnode to the alias list hung off the dev_t.
1294 *
1295 * The reason for this gunk is that multiple vnodes can reference
1296 * the same physical device, so checking vp->v_usecount to see
1297 * how many users there are is inadequate; the v_usecount for
1298 * the vnodes need to be accumulated. vcount() does that.
1299 */
1300struct vnode *
1301addaliasu(nvp, nvp_rdev)
1302 struct vnode *nvp;
1303 udev_t nvp_rdev;
1304{
1305 struct vnode *ovp;
1306 vop_t **ops;
1307 dev_t dev;
1308
1309 if (nvp->v_type != VBLK && nvp->v_type != VCHR)
1310 panic("addaliasu on non-special vnode");
1311 dev = udev2dev(nvp_rdev, nvp->v_type == VBLK ? 1 : 0);
1312 /*
1313 * Check to see if we have a bdevvp vnode with no associated
1314 * filesystem. If so, we want to associate the filesystem of
1315 * the new newly instigated vnode with the bdevvp vnode and
1316 * discard the newly created vnode rather than leaving the
1317 * bdevvp vnode lying around with no associated filesystem.
1318 */
1319 if (vfinddev(dev, nvp->v_type, &ovp) == 0 || ovp->v_data != NULL) {
1320 addalias(nvp, dev);
1321 return (nvp);
1322 }
1323 /*
1324 * Discard unneeded vnode, but save its node specific data.
1325 * Note that if there is a lock, it is carried over in the
1326 * node specific data to the replacement vnode.
1327 */
1328 vref(ovp);
1329 ovp->v_data = nvp->v_data;
1330 ovp->v_tag = nvp->v_tag;
1331 nvp->v_data = NULL;
1332 ops = nvp->v_op;
1333 nvp->v_op = ovp->v_op;
1334 ovp->v_op = ops;
1335 insmntque(ovp, nvp->v_mount);
1336 vrele(nvp);
1337 vgone(nvp);
1338 return (ovp);
1339}
1340
1341void
1342addalias(nvp, dev)
1343 struct vnode *nvp;
1344 dev_t dev;
1345{
1346
1347 if (nvp->v_type != VBLK && nvp->v_type != VCHR)
1348 panic("addalias on non-special vnode");
1349
1350 nvp->v_rdev = dev;
1351 simple_lock(&spechash_slock);
1352 SLIST_INSERT_HEAD(&dev->si_hlist, nvp, v_specnext);
1353 simple_unlock(&spechash_slock);
1354}
1355
1356/*
1357 * Grab a particular vnode from the free list, increment its
1358 * reference count and lock it. The vnode lock bit is set if the
1359 * vnode is being eliminated in vgone. The process is awakened
1360 * when the transition is completed, and an error returned to
1361 * indicate that the vnode is no longer usable (possibly having
1362 * been changed to a new file system type).
1363 */
1364int
1365vget(vp, flags, p)
1366 register struct vnode *vp;
1367 int flags;
1368 struct proc *p;
1369{
1370 int error;
1371
1372 /*
1373 * If the vnode is in the process of being cleaned out for
1374 * another use, we wait for the cleaning to finish and then
1375 * return failure. Cleaning is determined by checking that
1376 * the VXLOCK flag is set.
1377 */
1378 if ((flags & LK_INTERLOCK) == 0) {
1379 simple_lock(&vp->v_interlock);
1380 }
1381 if (vp->v_flag & VXLOCK) {
1382 vp->v_flag |= VXWANT;
1383 simple_unlock(&vp->v_interlock);
1384 tsleep((caddr_t)vp, PINOD, "vget", 0);
1385 return (ENOENT);
1386 }
1387
1388 vp->v_usecount++;
1389
1390 if (VSHOULDBUSY(vp))
1391 vbusy(vp);
1392 if (flags & LK_TYPE_MASK) {
1393 if ((error = vn_lock(vp, flags | LK_INTERLOCK, p)) != 0) {
1394 /*
1395 * must expand vrele here because we do not want
1396 * to call VOP_INACTIVE if the reference count
1397 * drops back to zero since it was never really
1398 * active. We must remove it from the free list
1399 * before sleeping so that multiple processes do
1400 * not try to recycle it.
1401 */
1402 simple_lock(&vp->v_interlock);
1403 vp->v_usecount--;
1404 if (VSHOULDFREE(vp))
1405 vfree(vp);
1406 simple_unlock(&vp->v_interlock);
1407 }
1408 return (error);
1409 }
1410 simple_unlock(&vp->v_interlock);
1411 return (0);
1412}
1413
1414void
1415vref(struct vnode *vp)
1416{
1417 simple_lock(&vp->v_interlock);
1418 vp->v_usecount++;
1419 simple_unlock(&vp->v_interlock);
1420}
1421
1422/*
1423 * Vnode put/release.
1424 * If count drops to zero, call inactive routine and return to freelist.
1425 */
1426void
1427vrele(vp)
1428 struct vnode *vp;
1429{
1430 struct proc *p = curproc; /* XXX */
1431
1432 KASSERT(vp != NULL, ("vrele: null vp"));
1433 KASSERT(vp->v_writecount < vp->v_usecount, ("vrele: missed vn_close"));
1434
1435 simple_lock(&vp->v_interlock);
1436
1437 if (vp->v_usecount > 1) {
1438
1439 vp->v_usecount--;
1440 simple_unlock(&vp->v_interlock);
1441
1442 return;
1443 }
1444
1445 if (vp->v_usecount == 1) {
1446
1447 vp->v_usecount--;
1448 if (VSHOULDFREE(vp))
1449 vfree(vp);
1450 /*
1451 * If we are doing a vput, the node is already locked, and we must
1452 * call VOP_INACTIVE with the node locked. So, in the case of
1453 * vrele, we explicitly lock the vnode before calling VOP_INACTIVE.
1454 */
1455 if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, p) == 0) {
1456 VOP_INACTIVE(vp, p);
1457 }
1458
1459 } else {
1460#ifdef DIAGNOSTIC
1461 vprint("vrele: negative ref count", vp);
1462 simple_unlock(&vp->v_interlock);
1463#endif
1464 panic("vrele: negative ref cnt");
1465 }
1466}
1467
1468void
1469vput(vp)
1470 struct vnode *vp;
1471{
1472 struct proc *p = curproc; /* XXX */
1473
1474 KASSERT(vp != NULL, ("vput: null vp"));
1475 KASSERT(vp->v_writecount < vp->v_usecount, ("vput: missed vn_close"));
1476
1477 simple_lock(&vp->v_interlock);
1478
1479 if (vp->v_usecount > 1) {
1480
1481 vp->v_usecount--;
1482 VOP_UNLOCK(vp, LK_INTERLOCK, p);
1483 return;
1484
1485 }
1486
1487 if (vp->v_usecount == 1) {
1488
1489 vp->v_usecount--;
1490 if (VSHOULDFREE(vp))
1491 vfree(vp);
1492 /*
1493 * If we are doing a vput, the node is already locked, and we must
1494 * call VOP_INACTIVE with the node locked. So, in the case of
1495 * vrele, we explicitly lock the vnode before calling VOP_INACTIVE.
1496 */
1497 simple_unlock(&vp->v_interlock);
1498 VOP_INACTIVE(vp, p);
1499
1500 } else {
1501#ifdef DIAGNOSTIC
1502 vprint("vput: negative ref count", vp);
1503#endif
1504 panic("vput: negative ref cnt");
1505 }
1506}
1507
1508/*
1509 * Somebody doesn't want the vnode recycled.
1510 */
1511void
1512vhold(vp)
1513 register struct vnode *vp;
1514{
1515 int s;
1516
1517 s = splbio();
1518 vp->v_holdcnt++;
1519 if (VSHOULDBUSY(vp))
1520 vbusy(vp);
1521 splx(s);
1522}
1523
1524/*
1525 * One less who cares about this vnode.
1526 */
1527void
1528vdrop(vp)
1529 register struct vnode *vp;
1530{
1531 int s;
1532
1533 s = splbio();
1534 if (vp->v_holdcnt <= 0)
1535 panic("vdrop: holdcnt");
1536 vp->v_holdcnt--;
1537 if (VSHOULDFREE(vp))
1538 vfree(vp);
1539 splx(s);
1540}
1541
1542/*
1543 * Remove any vnodes in the vnode table belonging to mount point mp.
1544 *
1545 * If MNT_NOFORCE is specified, there should not be any active ones,
1546 * return error if any are found (nb: this is a user error, not a
1547 * system error). If MNT_FORCE is specified, detach any active vnodes
1548 * that are found.
1549 */
1550#ifdef DIAGNOSTIC
1551static int busyprt = 0; /* print out busy vnodes */
1552SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "");
1553#endif
1554
1555int
1556vflush(mp, skipvp, flags)
1557 struct mount *mp;
1558 struct vnode *skipvp;
1559 int flags;
1560{
1561 struct proc *p = curproc; /* XXX */
1562 struct vnode *vp, *nvp;
1563 int busy = 0;
1564
1565 simple_lock(&mntvnode_slock);
1566loop:
1567 for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp; vp = nvp) {
1568 /*
1569 * Make sure this vnode wasn't reclaimed in getnewvnode().
1570 * Start over if it has (it won't be on the list anymore).
1571 */
1572 if (vp->v_mount != mp)
1573 goto loop;
1574 nvp = LIST_NEXT(vp, v_mntvnodes);
1575 /*
1576 * Skip over a selected vnode.
1577 */
1578 if (vp == skipvp)
1579 continue;
1580
1581 simple_lock(&vp->v_interlock);
1582 /*
1583 * Skip over a vnodes marked VSYSTEM.
1584 */
1585 if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) {
1586 simple_unlock(&vp->v_interlock);
1587 continue;
1588 }
1589 /*
1590 * If WRITECLOSE is set, only flush out regular file vnodes
1591 * open for writing.
1592 */
1593 if ((flags & WRITECLOSE) &&
1594 (vp->v_writecount == 0 || vp->v_type != VREG)) {
1595 simple_unlock(&vp->v_interlock);
1596 continue;
1597 }
1598
1599 /*
1600 * With v_usecount == 0, all we need to do is clear out the
1601 * vnode data structures and we are done.
1602 */
1603 if (vp->v_usecount == 0) {
1604 simple_unlock(&mntvnode_slock);
1605 vgonel(vp, p);
1606 simple_lock(&mntvnode_slock);
1607 continue;
1608 }
1609
1610 /*
1611 * If FORCECLOSE is set, forcibly close the vnode. For block
1612 * or character devices, revert to an anonymous device. For
1613 * all other files, just kill them.
1614 */
1615 if (flags & FORCECLOSE) {
1616 simple_unlock(&mntvnode_slock);
1617 if (vp->v_type != VBLK && vp->v_type != VCHR) {
1618 vgonel(vp, p);
1619 } else {
1620 vclean(vp, 0, p);
1621 vp->v_op = spec_vnodeop_p;
1622 insmntque(vp, (struct mount *) 0);
1623 }
1624 simple_lock(&mntvnode_slock);
1625 continue;
1626 }
1627#ifdef DIAGNOSTIC
1628 if (busyprt)
1629 vprint("vflush: busy vnode", vp);
1630#endif
1631 simple_unlock(&vp->v_interlock);
1632 busy++;
1633 }
1634 simple_unlock(&mntvnode_slock);
1635 if (busy)
1636 return (EBUSY);
1637 return (0);
1638}
1639
1640/*
1641 * Disassociate the underlying file system from a vnode.
1642 */
1643static void
1644vclean(vp, flags, p)
1645 struct vnode *vp;
1646 int flags;
1647 struct proc *p;
1648{
1649 int active;
1650
1651 /*
1652 * Check to see if the vnode is in use. If so we have to reference it
1653 * before we clean it out so that its count cannot fall to zero and
1654 * generate a race against ourselves to recycle it.
1655 */
1656 if ((active = vp->v_usecount))
1657 vp->v_usecount++;
1658
1659 /*
1660 * Prevent the vnode from being recycled or brought into use while we
1661 * clean it out.
1662 */
1663 if (vp->v_flag & VXLOCK)
1664 panic("vclean: deadlock");
1665 vp->v_flag |= VXLOCK;
1666 /*
1667 * Even if the count is zero, the VOP_INACTIVE routine may still
1668 * have the object locked while it cleans it out. The VOP_LOCK
1669 * ensures that the VOP_INACTIVE routine is done with its work.
1670 * For active vnodes, it ensures that no other activity can
1671 * occur while the underlying object is being cleaned out.
1672 */
1673 VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, p);
1674
1675 /*
1676 * Clean out any buffers associated with the vnode.
1677 * If the flush fails, just toss the buffers.
1678 */
1679 if (flags & DOCLOSE) {
1680 if (TAILQ_FIRST(&vp->v_dirtyblkhd) != NULL)
1681 (void) vn_write_suspend_wait(vp, NULL, V_WAIT);
1682 if (vinvalbuf(vp, V_SAVE, NOCRED, p, 0, 0) != 0)
1683 vinvalbuf(vp, 0, NOCRED, p, 0, 0);
1684 }
1685
1686 VOP_DESTROYVOBJECT(vp);
1687
1688 /*
1689 * If purging an active vnode, it must be closed and
1690 * deactivated before being reclaimed. Note that the
1691 * VOP_INACTIVE will unlock the vnode.
1692 */
1693 if (active) {
1694 if (flags & DOCLOSE)
1695 VOP_CLOSE(vp, FNONBLOCK, NOCRED, p);
1696 VOP_INACTIVE(vp, p);
1697 } else {
1698 /*
1699 * Any other processes trying to obtain this lock must first
1700 * wait for VXLOCK to clear, then call the new lock operation.
1701 */
1702 VOP_UNLOCK(vp, 0, p);
1703 }
1704 /*
1705 * Reclaim the vnode.
1706 */
1707 if (VOP_RECLAIM(vp, p))
1708 panic("vclean: cannot reclaim");
1709
1710 if (active) {
1711 /*
1712 * Inline copy of vrele() since VOP_INACTIVE
1713 * has already been called.
1714 */
1715 simple_lock(&vp->v_interlock);
1716 if (--vp->v_usecount <= 0) {
1717#ifdef DIAGNOSTIC
1718 if (vp->v_usecount < 0 || vp->v_writecount != 0) {
1719 vprint("vclean: bad ref count", vp);
1720 panic("vclean: ref cnt");
1721 }
1722#endif
1723 vfree(vp);
1724 }
1725 simple_unlock(&vp->v_interlock);
1726 }
1727
1728 cache_purge(vp);
1729 if (vp->v_vnlock) {
1730 FREE(vp->v_vnlock, M_VNODE);
1731 vp->v_vnlock = NULL;
1732 }
1733
1734 if (VSHOULDFREE(vp))
1735 vfree(vp);
1736
1737 /*
1738 * Done with purge, notify sleepers of the grim news.
1739 */
1740 vp->v_op = dead_vnodeop_p;
1741 vn_pollgone(vp);
1742 vp->v_tag = VT_NON;
1743 vp->v_flag &= ~VXLOCK;
1744 if (vp->v_flag & VXWANT) {
1745 vp->v_flag &= ~VXWANT;
1746 wakeup((caddr_t) vp);
1747 }
1748}
1749
1750/*
1751 * Eliminate all activity associated with the requested vnode
1752 * and with all vnodes aliased to the requested vnode.
1753 */
1754int
1755vop_revoke(ap)
1756 struct vop_revoke_args /* {
1757 struct vnode *a_vp;
1758 int a_flags;
1759 } */ *ap;
1760{
1761 struct vnode *vp, *vq;
1762 dev_t dev;
1763
1764 KASSERT((ap->a_flags & REVOKEALL) != 0, ("vop_revoke"));
1765
1766 vp = ap->a_vp;
1767 /*
1768 * If a vgone (or vclean) is already in progress,
1769 * wait until it is done and return.
1770 */
1771 if (vp->v_flag & VXLOCK) {
1772 vp->v_flag |= VXWANT;
1773 simple_unlock(&vp->v_interlock);
1774 tsleep((caddr_t)vp, PINOD, "vop_revokeall", 0);
1775 return (0);
1776 }
1777 dev = vp->v_rdev;
1778 for (;;) {
1779 simple_lock(&spechash_slock);
1780 vq = SLIST_FIRST(&dev->si_hlist);
1781 simple_unlock(&spechash_slock);
1782 if (!vq)
1783 break;
1784 vgone(vq);
1785 }
1786 return (0);
1787}
1788
1789/*
1790 * Recycle an unused vnode to the front of the free list.
1791 * Release the passed interlock if the vnode will be recycled.
1792 */
1793int
1794vrecycle(vp, inter_lkp, p)
1795 struct vnode *vp;
1796 struct simplelock *inter_lkp;
1797 struct proc *p;
1798{
1799
1800 simple_lock(&vp->v_interlock);
1801 if (vp->v_usecount == 0) {
1802 if (inter_lkp) {
1803 simple_unlock(inter_lkp);
1804 }
1805 vgonel(vp, p);
1806 return (1);
1807 }
1808 simple_unlock(&vp->v_interlock);
1809 return (0);
1810}
1811
1812/*
1813 * Eliminate all activity associated with a vnode
1814 * in preparation for reuse.
1815 */
1816void
1817vgone(vp)
1818 register struct vnode *vp;
1819{
1820 struct proc *p = curproc; /* XXX */
1821
1822 simple_lock(&vp->v_interlock);
1823 vgonel(vp, p);
1824}
1825
1826/*
1827 * vgone, with the vp interlock held.
1828 */
1829void
1830vgonel(vp, p)
1831 struct vnode *vp;
1832 struct proc *p;
1833{
1834 int s;
1835
1836 /*
1837 * If a vgone (or vclean) is already in progress,
1838 * wait until it is done and return.
1839 */
1840 if (vp->v_flag & VXLOCK) {
1841 vp->v_flag |= VXWANT;
1842 simple_unlock(&vp->v_interlock);
1843 tsleep((caddr_t)vp, PINOD, "vgone", 0);
1844 return;
1845 }
1846
1847 /*
1848 * Clean out the filesystem specific data.
1849 */
1850 vclean(vp, DOCLOSE, p);
1851 simple_lock(&vp->v_interlock);
1852
1853 /*
1854 * Delete from old mount point vnode list, if on one.
1855 */
1856 if (vp->v_mount != NULL)
1857 insmntque(vp, (struct mount *)0);
1858 /*
1859 * If special device, remove it from special device alias list
1860 * if it is on one.
1861 */
1862 if ((vp->v_type == VBLK || vp->v_type == VCHR) && vp->v_rdev != NULL) {
1863 simple_lock(&spechash_slock);
| 40 */
41
42/*
43 * External virtual filesystem routines
44 */
45#include "opt_ddb.h"
46#include "opt_ffs.h"
47
48#include <sys/param.h>
49#include <sys/systm.h>
50#include <sys/bio.h>
51#include <sys/buf.h>
52#include <sys/conf.h>
53#include <sys/dirent.h>
54#include <sys/domain.h>
55#include <sys/eventhandler.h>
56#include <sys/fcntl.h>
57#include <sys/kernel.h>
58#include <sys/kthread.h>
59#include <sys/ktr.h>
60#include <sys/malloc.h>
61#include <sys/mount.h>
62#include <sys/namei.h>
63#include <sys/proc.h>
64#include <sys/reboot.h>
65#include <sys/socket.h>
66#include <sys/stat.h>
67#include <sys/sysctl.h>
68#include <sys/vmmeter.h>
69#include <sys/vnode.h>
70
71#include <machine/limits.h>
72#include <machine/mutex.h>
73
74#include <vm/vm.h>
75#include <vm/vm_object.h>
76#include <vm/vm_extern.h>
77#include <vm/pmap.h>
78#include <vm/vm_map.h>
79#include <vm/vm_page.h>
80#include <vm/vm_pager.h>
81#include <vm/vnode_pager.h>
82#include <vm/vm_zone.h>
83
84static MALLOC_DEFINE(M_NETADDR, "Export Host", "Export host address structure");
85
86static void insmntque __P((struct vnode *vp, struct mount *mp));
87static void vclean __P((struct vnode *vp, int flags, struct proc *p));
88static unsigned long numvnodes;
89SYSCTL_INT(_debug, OID_AUTO, numvnodes, CTLFLAG_RD, &numvnodes, 0, "");
90
91enum vtype iftovt_tab[16] = {
92 VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
93 VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
94};
95int vttoif_tab[9] = {
96 0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
97 S_IFSOCK, S_IFIFO, S_IFMT,
98};
99
100static TAILQ_HEAD(freelst, vnode) vnode_free_list; /* vnode free list */
101
102static u_long wantfreevnodes = 25;
103SYSCTL_INT(_debug, OID_AUTO, wantfreevnodes, CTLFLAG_RW, &wantfreevnodes, 0, "");
104static u_long freevnodes = 0;
105SYSCTL_INT(_debug, OID_AUTO, freevnodes, CTLFLAG_RD, &freevnodes, 0, "");
106
107static int reassignbufcalls;
108SYSCTL_INT(_vfs, OID_AUTO, reassignbufcalls, CTLFLAG_RW, &reassignbufcalls, 0, "");
109static int reassignbufloops;
110SYSCTL_INT(_vfs, OID_AUTO, reassignbufloops, CTLFLAG_RW, &reassignbufloops, 0, "");
111static int reassignbufsortgood;
112SYSCTL_INT(_vfs, OID_AUTO, reassignbufsortgood, CTLFLAG_RW, &reassignbufsortgood, 0, "");
113static int reassignbufsortbad;
114SYSCTL_INT(_vfs, OID_AUTO, reassignbufsortbad, CTLFLAG_RW, &reassignbufsortbad, 0, "");
115static int reassignbufmethod = 1;
116SYSCTL_INT(_vfs, OID_AUTO, reassignbufmethod, CTLFLAG_RW, &reassignbufmethod, 0, "");
117
118#ifdef ENABLE_VFS_IOOPT
119int vfs_ioopt = 0;
120SYSCTL_INT(_vfs, OID_AUTO, ioopt, CTLFLAG_RW, &vfs_ioopt, 0, "");
121#endif
122
123struct mntlist mountlist = TAILQ_HEAD_INITIALIZER(mountlist); /* mounted fs */
124struct simplelock mountlist_slock;
125struct simplelock mntvnode_slock;
126int nfs_mount_type = -1;
127#ifndef NULL_SIMPLELOCKS
128static struct simplelock mntid_slock;
129static struct simplelock vnode_free_list_slock;
130static struct simplelock spechash_slock;
131#endif
132struct nfs_public nfs_pub; /* publicly exported FS */
133static vm_zone_t vnode_zone;
134int prtactive = 0; /* 1 => print out reclaim of active vnodes */
135
136/*
137 * The workitem queue.
138 */
139#define SYNCER_MAXDELAY 32
140static int syncer_maxdelay = SYNCER_MAXDELAY; /* maximum delay time */
141time_t syncdelay = 30; /* max time to delay syncing data */
142time_t filedelay = 30; /* time to delay syncing files */
143SYSCTL_INT(_kern, OID_AUTO, filedelay, CTLFLAG_RW, &filedelay, 0, "");
144time_t dirdelay = 29; /* time to delay syncing directories */
145SYSCTL_INT(_kern, OID_AUTO, dirdelay, CTLFLAG_RW, &dirdelay, 0, "");
146time_t metadelay = 28; /* time to delay syncing metadata */
147SYSCTL_INT(_kern, OID_AUTO, metadelay, CTLFLAG_RW, &metadelay, 0, "");
148static int rushjob; /* number of slots to run ASAP */
149static int stat_rush_requests; /* number of times I/O speeded up */
150SYSCTL_INT(_debug, OID_AUTO, rush_requests, CTLFLAG_RW, &stat_rush_requests, 0, "");
151
152static int syncer_delayno = 0;
153static long syncer_mask;
154LIST_HEAD(synclist, vnode);
155static struct synclist *syncer_workitem_pending;
156
157int desiredvnodes;
158SYSCTL_INT(_kern, KERN_MAXVNODES, maxvnodes, CTLFLAG_RW,
159 &desiredvnodes, 0, "Maximum number of vnodes");
160
161static void vfs_free_addrlist __P((struct netexport *nep));
162static int vfs_free_netcred __P((struct radix_node *rn, void *w));
163static int vfs_hang_addrlist __P((struct mount *mp, struct netexport *nep,
164 struct export_args *argp));
165
166/*
167 * Initialize the vnode management data structures.
168 */
169void
170vntblinit()
171{
172
173 desiredvnodes = maxproc + cnt.v_page_count / 4;
174 simple_lock_init(&mntvnode_slock);
175 simple_lock_init(&mntid_slock);
176 simple_lock_init(&spechash_slock);
177 TAILQ_INIT(&vnode_free_list);
178 simple_lock_init(&vnode_free_list_slock);
179 vnode_zone = zinit("VNODE", sizeof (struct vnode), 0, 0, 5);
180 /*
181 * Initialize the filesystem syncer.
182 */
183 syncer_workitem_pending = hashinit(syncer_maxdelay, M_VNODE,
184 &syncer_mask);
185 syncer_maxdelay = syncer_mask + 1;
186}
187
188/*
189 * Mark a mount point as busy. Used to synchronize access and to delay
190 * unmounting. Interlock is not released on failure.
191 */
192int
193vfs_busy(mp, flags, interlkp, p)
194 struct mount *mp;
195 int flags;
196 struct simplelock *interlkp;
197 struct proc *p;
198{
199 int lkflags;
200
201 if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
202 if (flags & LK_NOWAIT)
203 return (ENOENT);
204 mp->mnt_kern_flag |= MNTK_MWAIT;
205 if (interlkp) {
206 simple_unlock(interlkp);
207 }
208 /*
209 * Since all busy locks are shared except the exclusive
210 * lock granted when unmounting, the only place that a
211 * wakeup needs to be done is at the release of the
212 * exclusive lock at the end of dounmount.
213 */
214 tsleep((caddr_t)mp, PVFS, "vfs_busy", 0);
215 if (interlkp) {
216 simple_lock(interlkp);
217 }
218 return (ENOENT);
219 }
220 lkflags = LK_SHARED | LK_NOPAUSE;
221 if (interlkp)
222 lkflags |= LK_INTERLOCK;
223 if (lockmgr(&mp->mnt_lock, lkflags, interlkp, p))
224 panic("vfs_busy: unexpected lock failure");
225 return (0);
226}
227
228/*
229 * Free a busy filesystem.
230 */
231void
232vfs_unbusy(mp, p)
233 struct mount *mp;
234 struct proc *p;
235{
236
237 lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, p);
238}
239
240/*
241 * Lookup a filesystem type, and if found allocate and initialize
242 * a mount structure for it.
243 *
244 * Devname is usually updated by mount(8) after booting.
245 */
246int
247vfs_rootmountalloc(fstypename, devname, mpp)
248 char *fstypename;
249 char *devname;
250 struct mount **mpp;
251{
252 struct proc *p = curproc; /* XXX */
253 struct vfsconf *vfsp;
254 struct mount *mp;
255
256 if (fstypename == NULL)
257 return (ENODEV);
258 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
259 if (!strcmp(vfsp->vfc_name, fstypename))
260 break;
261 if (vfsp == NULL)
262 return (ENODEV);
263 mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK);
264 bzero((char *)mp, (u_long)sizeof(struct mount));
265 lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE);
266 (void)vfs_busy(mp, LK_NOWAIT, 0, p);
267 LIST_INIT(&mp->mnt_vnodelist);
268 mp->mnt_vfc = vfsp;
269 mp->mnt_op = vfsp->vfc_vfsops;
270 mp->mnt_flag = MNT_RDONLY;
271 mp->mnt_vnodecovered = NULLVP;
272 vfsp->vfc_refcount++;
273 mp->mnt_iosize_max = DFLTPHYS;
274 mp->mnt_stat.f_type = vfsp->vfc_typenum;
275 mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
276 strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
277 mp->mnt_stat.f_mntonname[0] = '/';
278 mp->mnt_stat.f_mntonname[1] = 0;
279 (void) copystr(devname, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 0);
280 *mpp = mp;
281 return (0);
282}
283
284/*
285 * Find an appropriate filesystem to use for the root. If a filesystem
286 * has not been preselected, walk through the list of known filesystems
287 * trying those that have mountroot routines, and try them until one
288 * works or we have tried them all.
289 */
290#ifdef notdef /* XXX JH */
291int
292lite2_vfs_mountroot()
293{
294 struct vfsconf *vfsp;
295 extern int (*lite2_mountroot) __P((void));
296 int error;
297
298 if (lite2_mountroot != NULL)
299 return ((*lite2_mountroot)());
300 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
301 if (vfsp->vfc_mountroot == NULL)
302 continue;
303 if ((error = (*vfsp->vfc_mountroot)()) == 0)
304 return (0);
305 printf("%s_mountroot failed: %d\n", vfsp->vfc_name, error);
306 }
307 return (ENODEV);
308}
309#endif
310
311/*
312 * Lookup a mount point by filesystem identifier.
313 */
314struct mount *
315vfs_getvfs(fsid)
316 fsid_t *fsid;
317{
318 register struct mount *mp;
319
320 simple_lock(&mountlist_slock);
321 TAILQ_FOREACH(mp, &mountlist, mnt_list) {
322 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
323 mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
324 simple_unlock(&mountlist_slock);
325 return (mp);
326 }
327 }
328 simple_unlock(&mountlist_slock);
329 return ((struct mount *) 0);
330}
331
332/*
333 * Get a new unique fsid. Try to make its val[0] unique, since this value
334 * will be used to create fake device numbers for stat(). Also try (but
335 * not so hard) make its val[0] unique mod 2^16, since some emulators only
336 * support 16-bit device numbers. We end up with unique val[0]'s for the
337 * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
338 *
339 * Keep in mind that several mounts may be running in parallel. Starting
340 * the search one past where the previous search terminated is both a
341 * micro-optimization and a defense against returning the same fsid to
342 * different mounts.
343 */
344void
345vfs_getnewfsid(mp)
346 struct mount *mp;
347{
348 static u_int16_t mntid_base;
349 fsid_t tfsid;
350 int mtype;
351
352 simple_lock(&mntid_slock);
353 mtype = mp->mnt_vfc->vfc_typenum;
354 tfsid.val[1] = mtype;
355 mtype = (mtype & 0xFF) << 24;
356 for (;;) {
357 tfsid.val[0] = makeudev(255,
358 mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF));
359 mntid_base++;
360 if (vfs_getvfs(&tfsid) == NULL)
361 break;
362 }
363 mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
364 mp->mnt_stat.f_fsid.val[1] = tfsid.val[1];
365 simple_unlock(&mntid_slock);
366}
367
368/*
369 * Knob to control the precision of file timestamps:
370 *
371 * 0 = seconds only; nanoseconds zeroed.
372 * 1 = seconds and nanoseconds, accurate within 1/HZ.
373 * 2 = seconds and nanoseconds, truncated to microseconds.
374 * >=3 = seconds and nanoseconds, maximum precision.
375 */
376enum { TSP_SEC, TSP_HZ, TSP_USEC, TSP_NSEC };
377
378static int timestamp_precision = TSP_SEC;
379SYSCTL_INT(_vfs, OID_AUTO, timestamp_precision, CTLFLAG_RW,
380 ×tamp_precision, 0, "");
381
382/*
383 * Get a current timestamp.
384 */
385void
386vfs_timestamp(tsp)
387 struct timespec *tsp;
388{
389 struct timeval tv;
390
391 switch (timestamp_precision) {
392 case TSP_SEC:
393 tsp->tv_sec = time_second;
394 tsp->tv_nsec = 0;
395 break;
396 case TSP_HZ:
397 getnanotime(tsp);
398 break;
399 case TSP_USEC:
400 microtime(&tv);
401 TIMEVAL_TO_TIMESPEC(&tv, tsp);
402 break;
403 case TSP_NSEC:
404 default:
405 nanotime(tsp);
406 break;
407 }
408}
409
410/*
411 * Set vnode attributes to VNOVAL
412 */
413void
414vattr_null(vap)
415 register struct vattr *vap;
416{
417
418 vap->va_type = VNON;
419 vap->va_size = VNOVAL;
420 vap->va_bytes = VNOVAL;
421 vap->va_mode = VNOVAL;
422 vap->va_nlink = VNOVAL;
423 vap->va_uid = VNOVAL;
424 vap->va_gid = VNOVAL;
425 vap->va_fsid = VNOVAL;
426 vap->va_fileid = VNOVAL;
427 vap->va_blocksize = VNOVAL;
428 vap->va_rdev = VNOVAL;
429 vap->va_atime.tv_sec = VNOVAL;
430 vap->va_atime.tv_nsec = VNOVAL;
431 vap->va_mtime.tv_sec = VNOVAL;
432 vap->va_mtime.tv_nsec = VNOVAL;
433 vap->va_ctime.tv_sec = VNOVAL;
434 vap->va_ctime.tv_nsec = VNOVAL;
435 vap->va_flags = VNOVAL;
436 vap->va_gen = VNOVAL;
437 vap->va_vaflags = 0;
438}
439
440/*
441 * Routines having to do with the management of the vnode table.
442 */
443
444/*
445 * Return the next vnode from the free list.
446 */
447int
448getnewvnode(tag, mp, vops, vpp)
449 enum vtagtype tag;
450 struct mount *mp;
451 vop_t **vops;
452 struct vnode **vpp;
453{
454 int s, count;
455 struct proc *p = curproc; /* XXX */
456 struct vnode *vp = NULL;
457 struct mount *vnmp;
458 vm_object_t object;
459
460 /*
461 * We take the least recently used vnode from the freelist
462 * if we can get it and it has no cached pages, and no
463 * namecache entries are relative to it.
464 * Otherwise we allocate a new vnode
465 */
466
467 s = splbio();
468 simple_lock(&vnode_free_list_slock);
469
470 if (wantfreevnodes && freevnodes < wantfreevnodes) {
471 vp = NULL;
472 } else if (!wantfreevnodes && freevnodes <= desiredvnodes) {
473 /*
474 * XXX: this is only here to be backwards compatible
475 */
476 vp = NULL;
477 } else for (count = 0; count < freevnodes; count++) {
478 vp = TAILQ_FIRST(&vnode_free_list);
479 if (vp == NULL || vp->v_usecount)
480 panic("getnewvnode: free vnode isn't");
481 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
482 /*
483 * Don't recycle if active in the namecache or
484 * if it still has cached pages or we cannot get
485 * its interlock.
486 */
487 if (LIST_FIRST(&vp->v_cache_src) != NULL ||
488 (VOP_GETVOBJECT(vp, &object) == 0 &&
489 (object->resident_page_count || object->ref_count)) ||
490 !simple_lock_try(&vp->v_interlock)) {
491 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
492 vp = NULL;
493 continue;
494 }
495 /*
496 * Skip over it if its filesystem is being suspended.
497 */
498 if (vn_start_write(vp, &vnmp, V_NOWAIT) == 0)
499 break;
500 simple_unlock(&vp->v_interlock);
501 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
502 vp = NULL;
503 }
504 if (vp) {
505 vp->v_flag |= VDOOMED;
506 freevnodes--;
507 simple_unlock(&vnode_free_list_slock);
508 cache_purge(vp);
509 vp->v_lease = NULL;
510 if (vp->v_type != VBAD) {
511 vgonel(vp, p);
512 } else {
513 simple_unlock(&vp->v_interlock);
514 }
515 vn_finished_write(vnmp);
516
517#ifdef INVARIANTS
518 {
519 int s;
520
521 if (vp->v_data)
522 panic("cleaned vnode isn't");
523 s = splbio();
524 if (vp->v_numoutput)
525 panic("Clean vnode has pending I/O's");
526 splx(s);
527 if (vp->v_writecount != 0)
528 panic("Non-zero write count");
529 }
530#endif
531 vp->v_flag = 0;
532 vp->v_lastw = 0;
533 vp->v_lasta = 0;
534 vp->v_cstart = 0;
535 vp->v_clen = 0;
536 vp->v_socket = 0;
537 } else {
538 simple_unlock(&vnode_free_list_slock);
539 vp = (struct vnode *) zalloc(vnode_zone);
540 bzero((char *) vp, sizeof *vp);
541 simple_lock_init(&vp->v_interlock);
542 vp->v_dd = vp;
543 cache_purge(vp);
544 LIST_INIT(&vp->v_cache_src);
545 TAILQ_INIT(&vp->v_cache_dst);
546 numvnodes++;
547 }
548
549 TAILQ_INIT(&vp->v_cleanblkhd);
550 TAILQ_INIT(&vp->v_dirtyblkhd);
551 vp->v_type = VNON;
552 vp->v_tag = tag;
553 vp->v_op = vops;
554 insmntque(vp, mp);
555 *vpp = vp;
556 vp->v_usecount = 1;
557 vp->v_data = 0;
558 splx(s);
559
560 vfs_object_create(vp, p, p->p_ucred);
561 return (0);
562}
563
564/*
565 * Move a vnode from one mount queue to another.
566 */
567static void
568insmntque(vp, mp)
569 register struct vnode *vp;
570 register struct mount *mp;
571{
572
573 simple_lock(&mntvnode_slock);
574 /*
575 * Delete from old mount point vnode list, if on one.
576 */
577 if (vp->v_mount != NULL)
578 LIST_REMOVE(vp, v_mntvnodes);
579 /*
580 * Insert into list of vnodes for the new mount point, if available.
581 */
582 if ((vp->v_mount = mp) == NULL) {
583 simple_unlock(&mntvnode_slock);
584 return;
585 }
586 LIST_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes);
587 simple_unlock(&mntvnode_slock);
588}
589
590/*
591 * Update outstanding I/O count and do wakeup if requested.
592 */
593void
594vwakeup(bp)
595 register struct buf *bp;
596{
597 register struct vnode *vp;
598
599 bp->b_flags &= ~B_WRITEINPROG;
600 if ((vp = bp->b_vp)) {
601 vp->v_numoutput--;
602 if (vp->v_numoutput < 0)
603 panic("vwakeup: neg numoutput");
604 if ((vp->v_numoutput == 0) && (vp->v_flag & VBWAIT)) {
605 vp->v_flag &= ~VBWAIT;
606 wakeup((caddr_t) &vp->v_numoutput);
607 }
608 }
609}
610
611/*
612 * Flush out and invalidate all buffers associated with a vnode.
613 * Called with the underlying object locked.
614 */
615int
616vinvalbuf(vp, flags, cred, p, slpflag, slptimeo)
617 register struct vnode *vp;
618 int flags;
619 struct ucred *cred;
620 struct proc *p;
621 int slpflag, slptimeo;
622{
623 register struct buf *bp;
624 struct buf *nbp, *blist;
625 int s, error;
626 vm_object_t object;
627
628 if (flags & V_SAVE) {
629 s = splbio();
630 while (vp->v_numoutput) {
631 vp->v_flag |= VBWAIT;
632 error = tsleep((caddr_t)&vp->v_numoutput,
633 slpflag | (PRIBIO + 1), "vinvlbuf", slptimeo);
634 if (error) {
635 splx(s);
636 return (error);
637 }
638 }
639 if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
640 splx(s);
641 if ((error = VOP_FSYNC(vp, cred, MNT_WAIT, p)) != 0)
642 return (error);
643 s = splbio();
644 if (vp->v_numoutput > 0 ||
645 !TAILQ_EMPTY(&vp->v_dirtyblkhd))
646 panic("vinvalbuf: dirty bufs");
647 }
648 splx(s);
649 }
650 s = splbio();
651 for (;;) {
652 blist = TAILQ_FIRST(&vp->v_cleanblkhd);
653 if (!blist)
654 blist = TAILQ_FIRST(&vp->v_dirtyblkhd);
655 if (!blist)
656 break;
657
658 for (bp = blist; bp; bp = nbp) {
659 nbp = TAILQ_NEXT(bp, b_vnbufs);
660 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
661 error = BUF_TIMELOCK(bp,
662 LK_EXCLUSIVE | LK_SLEEPFAIL,
663 "vinvalbuf", slpflag, slptimeo);
664 if (error == ENOLCK)
665 break;
666 splx(s);
667 return (error);
668 }
669 /*
670 * XXX Since there are no node locks for NFS, I
671 * believe there is a slight chance that a delayed
672 * write will occur while sleeping just above, so
673 * check for it. Note that vfs_bio_awrite expects
674 * buffers to reside on a queue, while VOP_BWRITE and
675 * brelse do not.
676 */
677 if (((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI) &&
678 (flags & V_SAVE)) {
679
680 if (bp->b_vp == vp) {
681 if (bp->b_flags & B_CLUSTEROK) {
682 BUF_UNLOCK(bp);
683 vfs_bio_awrite(bp);
684 } else {
685 bremfree(bp);
686 bp->b_flags |= B_ASYNC;
687 BUF_WRITE(bp);
688 }
689 } else {
690 bremfree(bp);
691 (void) BUF_WRITE(bp);
692 }
693 break;
694 }
695 bremfree(bp);
696 bp->b_flags |= (B_INVAL | B_NOCACHE | B_RELBUF);
697 bp->b_flags &= ~B_ASYNC;
698 brelse(bp);
699 }
700 }
701
702 while (vp->v_numoutput > 0) {
703 vp->v_flag |= VBWAIT;
704 tsleep(&vp->v_numoutput, PVM, "vnvlbv", 0);
705 }
706
707 splx(s);
708
709 /*
710 * Destroy the copy in the VM cache, too.
711 */
712 simple_lock(&vp->v_interlock);
713 if (VOP_GETVOBJECT(vp, &object) == 0) {
714 vm_object_page_remove(object, 0, 0,
715 (flags & V_SAVE) ? TRUE : FALSE);
716 }
717 simple_unlock(&vp->v_interlock);
718
719 if (!TAILQ_EMPTY(&vp->v_dirtyblkhd) || !TAILQ_EMPTY(&vp->v_cleanblkhd))
720 panic("vinvalbuf: flush failed");
721 return (0);
722}
723
724/*
725 * Truncate a file's buffer and pages to a specified length. This
726 * is in lieu of the old vinvalbuf mechanism, which performed unneeded
727 * sync activity.
728 */
729int
730vtruncbuf(vp, cred, p, length, blksize)
731 register struct vnode *vp;
732 struct ucred *cred;
733 struct proc *p;
734 off_t length;
735 int blksize;
736{
737 register struct buf *bp;
738 struct buf *nbp;
739 int s, anyfreed;
740 int trunclbn;
741
742 /*
743 * Round up to the *next* lbn.
744 */
745 trunclbn = (length + blksize - 1) / blksize;
746
747 s = splbio();
748restart:
749 anyfreed = 1;
750 for (;anyfreed;) {
751 anyfreed = 0;
752 for (bp = TAILQ_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) {
753 nbp = TAILQ_NEXT(bp, b_vnbufs);
754 if (bp->b_lblkno >= trunclbn) {
755 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
756 BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
757 goto restart;
758 } else {
759 bremfree(bp);
760 bp->b_flags |= (B_INVAL | B_RELBUF);
761 bp->b_flags &= ~B_ASYNC;
762 brelse(bp);
763 anyfreed = 1;
764 }
765 if (nbp &&
766 (((nbp->b_xflags & BX_VNCLEAN) == 0) ||
767 (nbp->b_vp != vp) ||
768 (nbp->b_flags & B_DELWRI))) {
769 goto restart;
770 }
771 }
772 }
773
774 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
775 nbp = TAILQ_NEXT(bp, b_vnbufs);
776 if (bp->b_lblkno >= trunclbn) {
777 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
778 BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
779 goto restart;
780 } else {
781 bremfree(bp);
782 bp->b_flags |= (B_INVAL | B_RELBUF);
783 bp->b_flags &= ~B_ASYNC;
784 brelse(bp);
785 anyfreed = 1;
786 }
787 if (nbp &&
788 (((nbp->b_xflags & BX_VNDIRTY) == 0) ||
789 (nbp->b_vp != vp) ||
790 (nbp->b_flags & B_DELWRI) == 0)) {
791 goto restart;
792 }
793 }
794 }
795 }
796
797 if (length > 0) {
798restartsync:
799 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
800 nbp = TAILQ_NEXT(bp, b_vnbufs);
801 if ((bp->b_flags & B_DELWRI) && (bp->b_lblkno < 0)) {
802 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
803 BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL);
804 goto restart;
805 } else {
806 bremfree(bp);
807 if (bp->b_vp == vp) {
808 bp->b_flags |= B_ASYNC;
809 } else {
810 bp->b_flags &= ~B_ASYNC;
811 }
812 BUF_WRITE(bp);
813 }
814 goto restartsync;
815 }
816
817 }
818 }
819
820 while (vp->v_numoutput > 0) {
821 vp->v_flag |= VBWAIT;
822 tsleep(&vp->v_numoutput, PVM, "vbtrunc", 0);
823 }
824
825 splx(s);
826
827 vnode_pager_setsize(vp, length);
828
829 return (0);
830}
831
832/*
833 * Associate a buffer with a vnode.
834 */
835void
836bgetvp(vp, bp)
837 register struct vnode *vp;
838 register struct buf *bp;
839{
840 int s;
841
842 KASSERT(bp->b_vp == NULL, ("bgetvp: not free"));
843
844 vhold(vp);
845 bp->b_vp = vp;
846 bp->b_dev = vn_todev(vp);
847 /*
848 * Insert onto list for new vnode.
849 */
850 s = splbio();
851 bp->b_xflags |= BX_VNCLEAN;
852 bp->b_xflags &= ~BX_VNDIRTY;
853 TAILQ_INSERT_TAIL(&vp->v_cleanblkhd, bp, b_vnbufs);
854 splx(s);
855}
856
857/*
858 * Disassociate a buffer from a vnode.
859 */
860void
861brelvp(bp)
862 register struct buf *bp;
863{
864 struct vnode *vp;
865 struct buflists *listheadp;
866 int s;
867
868 KASSERT(bp->b_vp != NULL, ("brelvp: NULL"));
869
870 /*
871 * Delete from old vnode list, if on one.
872 */
873 vp = bp->b_vp;
874 s = splbio();
875 if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN)) {
876 if (bp->b_xflags & BX_VNDIRTY)
877 listheadp = &vp->v_dirtyblkhd;
878 else
879 listheadp = &vp->v_cleanblkhd;
880 TAILQ_REMOVE(listheadp, bp, b_vnbufs);
881 bp->b_xflags &= ~(BX_VNDIRTY | BX_VNCLEAN);
882 }
883 if ((vp->v_flag & VONWORKLST) && TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
884 vp->v_flag &= ~VONWORKLST;
885 LIST_REMOVE(vp, v_synclist);
886 }
887 splx(s);
888 bp->b_vp = (struct vnode *) 0;
889 vdrop(vp);
890}
891
892/*
893 * The workitem queue.
894 *
895 * It is useful to delay writes of file data and filesystem metadata
896 * for tens of seconds so that quickly created and deleted files need
897 * not waste disk bandwidth being created and removed. To realize this,
898 * we append vnodes to a "workitem" queue. When running with a soft
899 * updates implementation, most pending metadata dependencies should
900 * not wait for more than a few seconds. Thus, mounted on block devices
901 * are delayed only about a half the time that file data is delayed.
902 * Similarly, directory updates are more critical, so are only delayed
903 * about a third the time that file data is delayed. Thus, there are
904 * SYNCER_MAXDELAY queues that are processed round-robin at a rate of
905 * one each second (driven off the filesystem syncer process). The
906 * syncer_delayno variable indicates the next queue that is to be processed.
907 * Items that need to be processed soon are placed in this queue:
908 *
909 * syncer_workitem_pending[syncer_delayno]
910 *
911 * A delay of fifteen seconds is done by placing the request fifteen
912 * entries later in the queue:
913 *
914 * syncer_workitem_pending[(syncer_delayno + 15) & syncer_mask]
915 *
916 */
917
918/*
919 * Add an item to the syncer work queue.
920 */
921static void
922vn_syncer_add_to_worklist(struct vnode *vp, int delay)
923{
924 int s, slot;
925
926 s = splbio();
927
928 if (vp->v_flag & VONWORKLST) {
929 LIST_REMOVE(vp, v_synclist);
930 }
931
932 if (delay > syncer_maxdelay - 2)
933 delay = syncer_maxdelay - 2;
934 slot = (syncer_delayno + delay) & syncer_mask;
935
936 LIST_INSERT_HEAD(&syncer_workitem_pending[slot], vp, v_synclist);
937 vp->v_flag |= VONWORKLST;
938 splx(s);
939}
940
941struct proc *updateproc;
942static void sched_sync __P((void));
943static struct kproc_desc up_kp = {
944 "syncer",
945 sched_sync,
946 &updateproc
947};
948SYSINIT(syncer, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &up_kp)
949
950/*
951 * System filesystem synchronizer daemon.
952 */
953void
954sched_sync(void)
955{
956 struct synclist *slp;
957 struct vnode *vp;
958 struct mount *mp;
959 long starttime;
960 int s;
961 struct proc *p = updateproc;
962
963 mtx_enter(&Giant, MTX_DEF);
964
965 EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, p,
966 SHUTDOWN_PRI_LAST);
967
968 for (;;) {
969 kproc_suspend_loop(p);
970
971 starttime = time_second;
972
973 /*
974 * Push files whose dirty time has expired. Be careful
975 * of interrupt race on slp queue.
976 */
977 s = splbio();
978 slp = &syncer_workitem_pending[syncer_delayno];
979 syncer_delayno += 1;
980 if (syncer_delayno == syncer_maxdelay)
981 syncer_delayno = 0;
982 splx(s);
983
984 while ((vp = LIST_FIRST(slp)) != NULL) {
985 if (VOP_ISLOCKED(vp, NULL) == 0 &&
986 vn_start_write(vp, &mp, V_NOWAIT) == 0) {
987 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
988 (void) VOP_FSYNC(vp, p->p_ucred, MNT_LAZY, p);
989 VOP_UNLOCK(vp, 0, p);
990 vn_finished_write(mp);
991 }
992 s = splbio();
993 if (LIST_FIRST(slp) == vp) {
994 /*
995 * Note: v_tag VT_VFS vps can remain on the
996 * worklist too with no dirty blocks, but
997 * since sync_fsync() moves it to a different
998 * slot we are safe.
999 */
1000 if (TAILQ_EMPTY(&vp->v_dirtyblkhd) &&
1001 !vn_isdisk(vp, NULL))
1002 panic("sched_sync: fsync failed vp %p tag %d", vp, vp->v_tag);
1003 /*
1004 * Put us back on the worklist. The worklist
1005 * routine will remove us from our current
1006 * position and then add us back in at a later
1007 * position.
1008 */
1009 vn_syncer_add_to_worklist(vp, syncdelay);
1010 }
1011 splx(s);
1012 }
1013
1014 /*
1015 * Do soft update processing.
1016 */
1017#ifdef SOFTUPDATES
1018 softdep_process_worklist(NULL);
1019#endif
1020
1021 /*
1022 * The variable rushjob allows the kernel to speed up the
1023 * processing of the filesystem syncer process. A rushjob
1024 * value of N tells the filesystem syncer to process the next
1025 * N seconds worth of work on its queue ASAP. Currently rushjob
1026 * is used by the soft update code to speed up the filesystem
1027 * syncer process when the incore state is getting so far
1028 * ahead of the disk that the kernel memory pool is being
1029 * threatened with exhaustion.
1030 */
1031 if (rushjob > 0) {
1032 rushjob -= 1;
1033 continue;
1034 }
1035 /*
1036 * If it has taken us less than a second to process the
1037 * current work, then wait. Otherwise start right over
1038 * again. We can still lose time if any single round
1039 * takes more than two seconds, but it does not really
1040 * matter as we are just trying to generally pace the
1041 * filesystem activity.
1042 */
1043 if (time_second == starttime)
1044 tsleep(&lbolt, PPAUSE, "syncer", 0);
1045 }
1046}
1047
1048/*
1049 * Request the syncer daemon to speed up its work.
1050 * We never push it to speed up more than half of its
1051 * normal turn time, otherwise it could take over the cpu.
1052 */
1053int
1054speedup_syncer()
1055{
1056 int s;
1057
1058 s = splhigh();
1059 if (updateproc->p_wchan == &lbolt)
1060 setrunnable(updateproc);
1061 splx(s);
1062 if (rushjob < syncdelay / 2) {
1063 rushjob += 1;
1064 stat_rush_requests += 1;
1065 return (1);
1066 }
1067 return(0);
1068}
1069
1070/*
1071 * Associate a p-buffer with a vnode.
1072 *
1073 * Also sets B_PAGING flag to indicate that vnode is not fully associated
1074 * with the buffer. i.e. the bp has not been linked into the vnode or
1075 * ref-counted.
1076 */
1077void
1078pbgetvp(vp, bp)
1079 register struct vnode *vp;
1080 register struct buf *bp;
1081{
1082
1083 KASSERT(bp->b_vp == NULL, ("pbgetvp: not free"));
1084
1085 bp->b_vp = vp;
1086 bp->b_flags |= B_PAGING;
1087 bp->b_dev = vn_todev(vp);
1088}
1089
1090/*
1091 * Disassociate a p-buffer from a vnode.
1092 */
1093void
1094pbrelvp(bp)
1095 register struct buf *bp;
1096{
1097
1098 KASSERT(bp->b_vp != NULL, ("pbrelvp: NULL"));
1099
1100 /* XXX REMOVE ME */
1101 if (bp->b_vnbufs.tqe_next != NULL) {
1102 panic(
1103 "relpbuf(): b_vp was probably reassignbuf()d %p %x",
1104 bp,
1105 (int)bp->b_flags
1106 );
1107 }
1108 bp->b_vp = (struct vnode *) 0;
1109 bp->b_flags &= ~B_PAGING;
1110}
1111
1112void
1113pbreassignbuf(bp, newvp)
1114 struct buf *bp;
1115 struct vnode *newvp;
1116{
1117 if ((bp->b_flags & B_PAGING) == 0) {
1118 panic(
1119 "pbreassignbuf() on non phys bp %p",
1120 bp
1121 );
1122 }
1123 bp->b_vp = newvp;
1124}
1125
1126/*
1127 * Reassign a buffer from one vnode to another.
1128 * Used to assign file specific control information
1129 * (indirect blocks) to the vnode to which they belong.
1130 */
1131void
1132reassignbuf(bp, newvp)
1133 register struct buf *bp;
1134 register struct vnode *newvp;
1135{
1136 struct buflists *listheadp;
1137 int delay;
1138 int s;
1139
1140 if (newvp == NULL) {
1141 printf("reassignbuf: NULL");
1142 return;
1143 }
1144 ++reassignbufcalls;
1145
1146 /*
1147 * B_PAGING flagged buffers cannot be reassigned because their vp
1148 * is not fully linked in.
1149 */
1150 if (bp->b_flags & B_PAGING)
1151 panic("cannot reassign paging buffer");
1152
1153 s = splbio();
1154 /*
1155 * Delete from old vnode list, if on one.
1156 */
1157 if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN)) {
1158 if (bp->b_xflags & BX_VNDIRTY)
1159 listheadp = &bp->b_vp->v_dirtyblkhd;
1160 else
1161 listheadp = &bp->b_vp->v_cleanblkhd;
1162 TAILQ_REMOVE(listheadp, bp, b_vnbufs);
1163 bp->b_xflags &= ~(BX_VNDIRTY | BX_VNCLEAN);
1164 if (bp->b_vp != newvp) {
1165 vdrop(bp->b_vp);
1166 bp->b_vp = NULL; /* for clarification */
1167 }
1168 }
1169 /*
1170 * If dirty, put on list of dirty buffers; otherwise insert onto list
1171 * of clean buffers.
1172 */
1173 if (bp->b_flags & B_DELWRI) {
1174 struct buf *tbp;
1175
1176 listheadp = &newvp->v_dirtyblkhd;
1177 if ((newvp->v_flag & VONWORKLST) == 0) {
1178 switch (newvp->v_type) {
1179 case VDIR:
1180 delay = dirdelay;
1181 break;
1182 case VCHR:
1183 case VBLK:
1184 if (newvp->v_specmountpoint != NULL) {
1185 delay = metadelay;
1186 break;
1187 }
1188 /* fall through */
1189 default:
1190 delay = filedelay;
1191 }
1192 vn_syncer_add_to_worklist(newvp, delay);
1193 }
1194 bp->b_xflags |= BX_VNDIRTY;
1195 tbp = TAILQ_FIRST(listheadp);
1196 if (tbp == NULL ||
1197 bp->b_lblkno == 0 ||
1198 (bp->b_lblkno > 0 && tbp->b_lblkno < 0) ||
1199 (bp->b_lblkno > 0 && bp->b_lblkno < tbp->b_lblkno)) {
1200 TAILQ_INSERT_HEAD(listheadp, bp, b_vnbufs);
1201 ++reassignbufsortgood;
1202 } else if (bp->b_lblkno < 0) {
1203 TAILQ_INSERT_TAIL(listheadp, bp, b_vnbufs);
1204 ++reassignbufsortgood;
1205 } else if (reassignbufmethod == 1) {
1206 /*
1207 * New sorting algorithm, only handle sequential case,
1208 * otherwise append to end (but before metadata)
1209 */
1210 if ((tbp = gbincore(newvp, bp->b_lblkno - 1)) != NULL &&
1211 (tbp->b_xflags & BX_VNDIRTY)) {
1212 /*
1213 * Found the best place to insert the buffer
1214 */
1215 TAILQ_INSERT_AFTER(listheadp, tbp, bp, b_vnbufs);
1216 ++reassignbufsortgood;
1217 } else {
1218 /*
1219 * Missed, append to end, but before meta-data.
1220 * We know that the head buffer in the list is
1221 * not meta-data due to prior conditionals.
1222 *
1223 * Indirect effects: NFS second stage write
1224 * tends to wind up here, giving maximum
1225 * distance between the unstable write and the
1226 * commit rpc.
1227 */
1228 tbp = TAILQ_LAST(listheadp, buflists);
1229 while (tbp && tbp->b_lblkno < 0)
1230 tbp = TAILQ_PREV(tbp, buflists, b_vnbufs);
1231 TAILQ_INSERT_AFTER(listheadp, tbp, bp, b_vnbufs);
1232 ++reassignbufsortbad;
1233 }
1234 } else {
1235 /*
1236 * Old sorting algorithm, scan queue and insert
1237 */
1238 struct buf *ttbp;
1239 while ((ttbp = TAILQ_NEXT(tbp, b_vnbufs)) &&
1240 (ttbp->b_lblkno < bp->b_lblkno)) {
1241 ++reassignbufloops;
1242 tbp = ttbp;
1243 }
1244 TAILQ_INSERT_AFTER(listheadp, tbp, bp, b_vnbufs);
1245 }
1246 } else {
1247 bp->b_xflags |= BX_VNCLEAN;
1248 TAILQ_INSERT_TAIL(&newvp->v_cleanblkhd, bp, b_vnbufs);
1249 if ((newvp->v_flag & VONWORKLST) &&
1250 TAILQ_EMPTY(&newvp->v_dirtyblkhd)) {
1251 newvp->v_flag &= ~VONWORKLST;
1252 LIST_REMOVE(newvp, v_synclist);
1253 }
1254 }
1255 if (bp->b_vp != newvp) {
1256 bp->b_vp = newvp;
1257 vhold(bp->b_vp);
1258 }
1259 splx(s);
1260}
1261
1262/*
1263 * Create a vnode for a block device.
1264 * Used for mounting the root file system.
1265 * XXX: This now changed to a VCHR due to the block/char merging.
1266 */
1267int
1268bdevvp(dev, vpp)
1269 dev_t dev;
1270 struct vnode **vpp;
1271{
1272 register struct vnode *vp;
1273 struct vnode *nvp;
1274 int error;
1275
1276 if (dev == NODEV) {
1277 *vpp = NULLVP;
1278 return (ENXIO);
1279 }
1280 error = getnewvnode(VT_NON, (struct mount *)0, spec_vnodeop_p, &nvp);
1281 if (error) {
1282 *vpp = NULLVP;
1283 return (error);
1284 }
1285 vp = nvp;
1286 vp->v_type = VCHR;
1287 addalias(vp, dev);
1288 *vpp = vp;
1289 return (0);
1290}
1291
1292/*
1293 * Add vnode to the alias list hung off the dev_t.
1294 *
1295 * The reason for this gunk is that multiple vnodes can reference
1296 * the same physical device, so checking vp->v_usecount to see
1297 * how many users there are is inadequate; the v_usecount for
1298 * the vnodes need to be accumulated. vcount() does that.
1299 */
1300struct vnode *
1301addaliasu(nvp, nvp_rdev)
1302 struct vnode *nvp;
1303 udev_t nvp_rdev;
1304{
1305 struct vnode *ovp;
1306 vop_t **ops;
1307 dev_t dev;
1308
1309 if (nvp->v_type != VBLK && nvp->v_type != VCHR)
1310 panic("addaliasu on non-special vnode");
1311 dev = udev2dev(nvp_rdev, nvp->v_type == VBLK ? 1 : 0);
1312 /*
1313 * Check to see if we have a bdevvp vnode with no associated
1314 * filesystem. If so, we want to associate the filesystem of
1315 * the new newly instigated vnode with the bdevvp vnode and
1316 * discard the newly created vnode rather than leaving the
1317 * bdevvp vnode lying around with no associated filesystem.
1318 */
1319 if (vfinddev(dev, nvp->v_type, &ovp) == 0 || ovp->v_data != NULL) {
1320 addalias(nvp, dev);
1321 return (nvp);
1322 }
1323 /*
1324 * Discard unneeded vnode, but save its node specific data.
1325 * Note that if there is a lock, it is carried over in the
1326 * node specific data to the replacement vnode.
1327 */
1328 vref(ovp);
1329 ovp->v_data = nvp->v_data;
1330 ovp->v_tag = nvp->v_tag;
1331 nvp->v_data = NULL;
1332 ops = nvp->v_op;
1333 nvp->v_op = ovp->v_op;
1334 ovp->v_op = ops;
1335 insmntque(ovp, nvp->v_mount);
1336 vrele(nvp);
1337 vgone(nvp);
1338 return (ovp);
1339}
1340
1341void
1342addalias(nvp, dev)
1343 struct vnode *nvp;
1344 dev_t dev;
1345{
1346
1347 if (nvp->v_type != VBLK && nvp->v_type != VCHR)
1348 panic("addalias on non-special vnode");
1349
1350 nvp->v_rdev = dev;
1351 simple_lock(&spechash_slock);
1352 SLIST_INSERT_HEAD(&dev->si_hlist, nvp, v_specnext);
1353 simple_unlock(&spechash_slock);
1354}
1355
1356/*
1357 * Grab a particular vnode from the free list, increment its
1358 * reference count and lock it. The vnode lock bit is set if the
1359 * vnode is being eliminated in vgone. The process is awakened
1360 * when the transition is completed, and an error returned to
1361 * indicate that the vnode is no longer usable (possibly having
1362 * been changed to a new file system type).
1363 */
1364int
1365vget(vp, flags, p)
1366 register struct vnode *vp;
1367 int flags;
1368 struct proc *p;
1369{
1370 int error;
1371
1372 /*
1373 * If the vnode is in the process of being cleaned out for
1374 * another use, we wait for the cleaning to finish and then
1375 * return failure. Cleaning is determined by checking that
1376 * the VXLOCK flag is set.
1377 */
1378 if ((flags & LK_INTERLOCK) == 0) {
1379 simple_lock(&vp->v_interlock);
1380 }
1381 if (vp->v_flag & VXLOCK) {
1382 vp->v_flag |= VXWANT;
1383 simple_unlock(&vp->v_interlock);
1384 tsleep((caddr_t)vp, PINOD, "vget", 0);
1385 return (ENOENT);
1386 }
1387
1388 vp->v_usecount++;
1389
1390 if (VSHOULDBUSY(vp))
1391 vbusy(vp);
1392 if (flags & LK_TYPE_MASK) {
1393 if ((error = vn_lock(vp, flags | LK_INTERLOCK, p)) != 0) {
1394 /*
1395 * must expand vrele here because we do not want
1396 * to call VOP_INACTIVE if the reference count
1397 * drops back to zero since it was never really
1398 * active. We must remove it from the free list
1399 * before sleeping so that multiple processes do
1400 * not try to recycle it.
1401 */
1402 simple_lock(&vp->v_interlock);
1403 vp->v_usecount--;
1404 if (VSHOULDFREE(vp))
1405 vfree(vp);
1406 simple_unlock(&vp->v_interlock);
1407 }
1408 return (error);
1409 }
1410 simple_unlock(&vp->v_interlock);
1411 return (0);
1412}
1413
1414void
1415vref(struct vnode *vp)
1416{
1417 simple_lock(&vp->v_interlock);
1418 vp->v_usecount++;
1419 simple_unlock(&vp->v_interlock);
1420}
1421
1422/*
1423 * Vnode put/release.
1424 * If count drops to zero, call inactive routine and return to freelist.
1425 */
1426void
1427vrele(vp)
1428 struct vnode *vp;
1429{
1430 struct proc *p = curproc; /* XXX */
1431
1432 KASSERT(vp != NULL, ("vrele: null vp"));
1433 KASSERT(vp->v_writecount < vp->v_usecount, ("vrele: missed vn_close"));
1434
1435 simple_lock(&vp->v_interlock);
1436
1437 if (vp->v_usecount > 1) {
1438
1439 vp->v_usecount--;
1440 simple_unlock(&vp->v_interlock);
1441
1442 return;
1443 }
1444
1445 if (vp->v_usecount == 1) {
1446
1447 vp->v_usecount--;
1448 if (VSHOULDFREE(vp))
1449 vfree(vp);
1450 /*
1451 * If we are doing a vput, the node is already locked, and we must
1452 * call VOP_INACTIVE with the node locked. So, in the case of
1453 * vrele, we explicitly lock the vnode before calling VOP_INACTIVE.
1454 */
1455 if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, p) == 0) {
1456 VOP_INACTIVE(vp, p);
1457 }
1458
1459 } else {
1460#ifdef DIAGNOSTIC
1461 vprint("vrele: negative ref count", vp);
1462 simple_unlock(&vp->v_interlock);
1463#endif
1464 panic("vrele: negative ref cnt");
1465 }
1466}
1467
1468void
1469vput(vp)
1470 struct vnode *vp;
1471{
1472 struct proc *p = curproc; /* XXX */
1473
1474 KASSERT(vp != NULL, ("vput: null vp"));
1475 KASSERT(vp->v_writecount < vp->v_usecount, ("vput: missed vn_close"));
1476
1477 simple_lock(&vp->v_interlock);
1478
1479 if (vp->v_usecount > 1) {
1480
1481 vp->v_usecount--;
1482 VOP_UNLOCK(vp, LK_INTERLOCK, p);
1483 return;
1484
1485 }
1486
1487 if (vp->v_usecount == 1) {
1488
1489 vp->v_usecount--;
1490 if (VSHOULDFREE(vp))
1491 vfree(vp);
1492 /*
1493 * If we are doing a vput, the node is already locked, and we must
1494 * call VOP_INACTIVE with the node locked. So, in the case of
1495 * vrele, we explicitly lock the vnode before calling VOP_INACTIVE.
1496 */
1497 simple_unlock(&vp->v_interlock);
1498 VOP_INACTIVE(vp, p);
1499
1500 } else {
1501#ifdef DIAGNOSTIC
1502 vprint("vput: negative ref count", vp);
1503#endif
1504 panic("vput: negative ref cnt");
1505 }
1506}
1507
1508/*
1509 * Somebody doesn't want the vnode recycled.
1510 */
1511void
1512vhold(vp)
1513 register struct vnode *vp;
1514{
1515 int s;
1516
1517 s = splbio();
1518 vp->v_holdcnt++;
1519 if (VSHOULDBUSY(vp))
1520 vbusy(vp);
1521 splx(s);
1522}
1523
1524/*
1525 * One less who cares about this vnode.
1526 */
1527void
1528vdrop(vp)
1529 register struct vnode *vp;
1530{
1531 int s;
1532
1533 s = splbio();
1534 if (vp->v_holdcnt <= 0)
1535 panic("vdrop: holdcnt");
1536 vp->v_holdcnt--;
1537 if (VSHOULDFREE(vp))
1538 vfree(vp);
1539 splx(s);
1540}
1541
1542/*
1543 * Remove any vnodes in the vnode table belonging to mount point mp.
1544 *
1545 * If MNT_NOFORCE is specified, there should not be any active ones,
1546 * return error if any are found (nb: this is a user error, not a
1547 * system error). If MNT_FORCE is specified, detach any active vnodes
1548 * that are found.
1549 */
1550#ifdef DIAGNOSTIC
1551static int busyprt = 0; /* print out busy vnodes */
1552SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "");
1553#endif
1554
1555int
1556vflush(mp, skipvp, flags)
1557 struct mount *mp;
1558 struct vnode *skipvp;
1559 int flags;
1560{
1561 struct proc *p = curproc; /* XXX */
1562 struct vnode *vp, *nvp;
1563 int busy = 0;
1564
1565 simple_lock(&mntvnode_slock);
1566loop:
1567 for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp; vp = nvp) {
1568 /*
1569 * Make sure this vnode wasn't reclaimed in getnewvnode().
1570 * Start over if it has (it won't be on the list anymore).
1571 */
1572 if (vp->v_mount != mp)
1573 goto loop;
1574 nvp = LIST_NEXT(vp, v_mntvnodes);
1575 /*
1576 * Skip over a selected vnode.
1577 */
1578 if (vp == skipvp)
1579 continue;
1580
1581 simple_lock(&vp->v_interlock);
1582 /*
1583 * Skip over a vnodes marked VSYSTEM.
1584 */
1585 if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) {
1586 simple_unlock(&vp->v_interlock);
1587 continue;
1588 }
1589 /*
1590 * If WRITECLOSE is set, only flush out regular file vnodes
1591 * open for writing.
1592 */
1593 if ((flags & WRITECLOSE) &&
1594 (vp->v_writecount == 0 || vp->v_type != VREG)) {
1595 simple_unlock(&vp->v_interlock);
1596 continue;
1597 }
1598
1599 /*
1600 * With v_usecount == 0, all we need to do is clear out the
1601 * vnode data structures and we are done.
1602 */
1603 if (vp->v_usecount == 0) {
1604 simple_unlock(&mntvnode_slock);
1605 vgonel(vp, p);
1606 simple_lock(&mntvnode_slock);
1607 continue;
1608 }
1609
1610 /*
1611 * If FORCECLOSE is set, forcibly close the vnode. For block
1612 * or character devices, revert to an anonymous device. For
1613 * all other files, just kill them.
1614 */
1615 if (flags & FORCECLOSE) {
1616 simple_unlock(&mntvnode_slock);
1617 if (vp->v_type != VBLK && vp->v_type != VCHR) {
1618 vgonel(vp, p);
1619 } else {
1620 vclean(vp, 0, p);
1621 vp->v_op = spec_vnodeop_p;
1622 insmntque(vp, (struct mount *) 0);
1623 }
1624 simple_lock(&mntvnode_slock);
1625 continue;
1626 }
1627#ifdef DIAGNOSTIC
1628 if (busyprt)
1629 vprint("vflush: busy vnode", vp);
1630#endif
1631 simple_unlock(&vp->v_interlock);
1632 busy++;
1633 }
1634 simple_unlock(&mntvnode_slock);
1635 if (busy)
1636 return (EBUSY);
1637 return (0);
1638}
1639
1640/*
1641 * Disassociate the underlying file system from a vnode.
1642 */
1643static void
1644vclean(vp, flags, p)
1645 struct vnode *vp;
1646 int flags;
1647 struct proc *p;
1648{
1649 int active;
1650
1651 /*
1652 * Check to see if the vnode is in use. If so we have to reference it
1653 * before we clean it out so that its count cannot fall to zero and
1654 * generate a race against ourselves to recycle it.
1655 */
1656 if ((active = vp->v_usecount))
1657 vp->v_usecount++;
1658
1659 /*
1660 * Prevent the vnode from being recycled or brought into use while we
1661 * clean it out.
1662 */
1663 if (vp->v_flag & VXLOCK)
1664 panic("vclean: deadlock");
1665 vp->v_flag |= VXLOCK;
1666 /*
1667 * Even if the count is zero, the VOP_INACTIVE routine may still
1668 * have the object locked while it cleans it out. The VOP_LOCK
1669 * ensures that the VOP_INACTIVE routine is done with its work.
1670 * For active vnodes, it ensures that no other activity can
1671 * occur while the underlying object is being cleaned out.
1672 */
1673 VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, p);
1674
1675 /*
1676 * Clean out any buffers associated with the vnode.
1677 * If the flush fails, just toss the buffers.
1678 */
1679 if (flags & DOCLOSE) {
1680 if (TAILQ_FIRST(&vp->v_dirtyblkhd) != NULL)
1681 (void) vn_write_suspend_wait(vp, NULL, V_WAIT);
1682 if (vinvalbuf(vp, V_SAVE, NOCRED, p, 0, 0) != 0)
1683 vinvalbuf(vp, 0, NOCRED, p, 0, 0);
1684 }
1685
1686 VOP_DESTROYVOBJECT(vp);
1687
1688 /*
1689 * If purging an active vnode, it must be closed and
1690 * deactivated before being reclaimed. Note that the
1691 * VOP_INACTIVE will unlock the vnode.
1692 */
1693 if (active) {
1694 if (flags & DOCLOSE)
1695 VOP_CLOSE(vp, FNONBLOCK, NOCRED, p);
1696 VOP_INACTIVE(vp, p);
1697 } else {
1698 /*
1699 * Any other processes trying to obtain this lock must first
1700 * wait for VXLOCK to clear, then call the new lock operation.
1701 */
1702 VOP_UNLOCK(vp, 0, p);
1703 }
1704 /*
1705 * Reclaim the vnode.
1706 */
1707 if (VOP_RECLAIM(vp, p))
1708 panic("vclean: cannot reclaim");
1709
1710 if (active) {
1711 /*
1712 * Inline copy of vrele() since VOP_INACTIVE
1713 * has already been called.
1714 */
1715 simple_lock(&vp->v_interlock);
1716 if (--vp->v_usecount <= 0) {
1717#ifdef DIAGNOSTIC
1718 if (vp->v_usecount < 0 || vp->v_writecount != 0) {
1719 vprint("vclean: bad ref count", vp);
1720 panic("vclean: ref cnt");
1721 }
1722#endif
1723 vfree(vp);
1724 }
1725 simple_unlock(&vp->v_interlock);
1726 }
1727
1728 cache_purge(vp);
1729 if (vp->v_vnlock) {
1730 FREE(vp->v_vnlock, M_VNODE);
1731 vp->v_vnlock = NULL;
1732 }
1733
1734 if (VSHOULDFREE(vp))
1735 vfree(vp);
1736
1737 /*
1738 * Done with purge, notify sleepers of the grim news.
1739 */
1740 vp->v_op = dead_vnodeop_p;
1741 vn_pollgone(vp);
1742 vp->v_tag = VT_NON;
1743 vp->v_flag &= ~VXLOCK;
1744 if (vp->v_flag & VXWANT) {
1745 vp->v_flag &= ~VXWANT;
1746 wakeup((caddr_t) vp);
1747 }
1748}
1749
1750/*
1751 * Eliminate all activity associated with the requested vnode
1752 * and with all vnodes aliased to the requested vnode.
1753 */
1754int
1755vop_revoke(ap)
1756 struct vop_revoke_args /* {
1757 struct vnode *a_vp;
1758 int a_flags;
1759 } */ *ap;
1760{
1761 struct vnode *vp, *vq;
1762 dev_t dev;
1763
1764 KASSERT((ap->a_flags & REVOKEALL) != 0, ("vop_revoke"));
1765
1766 vp = ap->a_vp;
1767 /*
1768 * If a vgone (or vclean) is already in progress,
1769 * wait until it is done and return.
1770 */
1771 if (vp->v_flag & VXLOCK) {
1772 vp->v_flag |= VXWANT;
1773 simple_unlock(&vp->v_interlock);
1774 tsleep((caddr_t)vp, PINOD, "vop_revokeall", 0);
1775 return (0);
1776 }
1777 dev = vp->v_rdev;
1778 for (;;) {
1779 simple_lock(&spechash_slock);
1780 vq = SLIST_FIRST(&dev->si_hlist);
1781 simple_unlock(&spechash_slock);
1782 if (!vq)
1783 break;
1784 vgone(vq);
1785 }
1786 return (0);
1787}
1788
1789/*
1790 * Recycle an unused vnode to the front of the free list.
1791 * Release the passed interlock if the vnode will be recycled.
1792 */
1793int
1794vrecycle(vp, inter_lkp, p)
1795 struct vnode *vp;
1796 struct simplelock *inter_lkp;
1797 struct proc *p;
1798{
1799
1800 simple_lock(&vp->v_interlock);
1801 if (vp->v_usecount == 0) {
1802 if (inter_lkp) {
1803 simple_unlock(inter_lkp);
1804 }
1805 vgonel(vp, p);
1806 return (1);
1807 }
1808 simple_unlock(&vp->v_interlock);
1809 return (0);
1810}
1811
1812/*
1813 * Eliminate all activity associated with a vnode
1814 * in preparation for reuse.
1815 */
1816void
1817vgone(vp)
1818 register struct vnode *vp;
1819{
1820 struct proc *p = curproc; /* XXX */
1821
1822 simple_lock(&vp->v_interlock);
1823 vgonel(vp, p);
1824}
1825
1826/*
1827 * vgone, with the vp interlock held.
1828 */
1829void
1830vgonel(vp, p)
1831 struct vnode *vp;
1832 struct proc *p;
1833{
1834 int s;
1835
1836 /*
1837 * If a vgone (or vclean) is already in progress,
1838 * wait until it is done and return.
1839 */
1840 if (vp->v_flag & VXLOCK) {
1841 vp->v_flag |= VXWANT;
1842 simple_unlock(&vp->v_interlock);
1843 tsleep((caddr_t)vp, PINOD, "vgone", 0);
1844 return;
1845 }
1846
1847 /*
1848 * Clean out the filesystem specific data.
1849 */
1850 vclean(vp, DOCLOSE, p);
1851 simple_lock(&vp->v_interlock);
1852
1853 /*
1854 * Delete from old mount point vnode list, if on one.
1855 */
1856 if (vp->v_mount != NULL)
1857 insmntque(vp, (struct mount *)0);
1858 /*
1859 * If special device, remove it from special device alias list
1860 * if it is on one.
1861 */
1862 if ((vp->v_type == VBLK || vp->v_type == VCHR) && vp->v_rdev != NULL) {
1863 simple_lock(&spechash_slock);
|
1933 count += vq->v_usecount;
1934 simple_unlock(&spechash_slock);
1935 return (count);
1936}
1937
1938/*
1939 * Same as above, but using the dev_t as argument
1940 */
1941
1942int
1943count_dev(dev)
1944 dev_t dev;
1945{
1946 struct vnode *vp;
1947
1948 vp = SLIST_FIRST(&dev->si_hlist);
1949 if (vp == NULL)
1950 return (0);
1951 return(vcount(vp));
1952}
1953
1954/*
1955 * Print out a description of a vnode.
1956 */
1957static char *typename[] =
1958{"VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD"};
1959
1960void
1961vprint(label, vp)
1962 char *label;
1963 struct vnode *vp;
1964{
1965 char buf[96];
1966
1967 if (label != NULL)
1968 printf("%s: %p: ", label, (void *)vp);
1969 else
1970 printf("%p: ", (void *)vp);
1971 printf("type %s, usecount %d, writecount %d, refcount %d,",
1972 typename[vp->v_type], vp->v_usecount, vp->v_writecount,
1973 vp->v_holdcnt);
1974 buf[0] = '\0';
1975 if (vp->v_flag & VROOT)
1976 strcat(buf, "|VROOT");
1977 if (vp->v_flag & VTEXT)
1978 strcat(buf, "|VTEXT");
1979 if (vp->v_flag & VSYSTEM)
1980 strcat(buf, "|VSYSTEM");
1981 if (vp->v_flag & VXLOCK)
1982 strcat(buf, "|VXLOCK");
1983 if (vp->v_flag & VXWANT)
1984 strcat(buf, "|VXWANT");
1985 if (vp->v_flag & VBWAIT)
1986 strcat(buf, "|VBWAIT");
1987 if (vp->v_flag & VDOOMED)
1988 strcat(buf, "|VDOOMED");
1989 if (vp->v_flag & VFREE)
1990 strcat(buf, "|VFREE");
1991 if (vp->v_flag & VOBJBUF)
1992 strcat(buf, "|VOBJBUF");
1993 if (buf[0] != '\0')
1994 printf(" flags (%s)", &buf[1]);
1995 if (vp->v_data == NULL) {
1996 printf("\n");
1997 } else {
1998 printf("\n\t");
1999 VOP_PRINT(vp);
2000 }
2001}
2002
2003#ifdef DDB
2004#include <ddb/ddb.h>
2005/*
2006 * List all of the locked vnodes in the system.
2007 * Called when debugging the kernel.
2008 */
2009DB_SHOW_COMMAND(lockedvnodes, lockedvnodes)
2010{
2011 struct proc *p = curproc; /* XXX */
2012 struct mount *mp, *nmp;
2013 struct vnode *vp;
2014
2015 printf("Locked vnodes\n");
2016 simple_lock(&mountlist_slock);
2017 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
2018 if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
2019 nmp = TAILQ_NEXT(mp, mnt_list);
2020 continue;
2021 }
2022 LIST_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
2023 if (VOP_ISLOCKED(vp, NULL))
2024 vprint((char *)0, vp);
2025 }
2026 simple_lock(&mountlist_slock);
2027 nmp = TAILQ_NEXT(mp, mnt_list);
2028 vfs_unbusy(mp, p);
2029 }
2030 simple_unlock(&mountlist_slock);
2031}
2032#endif
2033
2034/*
2035 * Top level filesystem related information gathering.
2036 */
2037static int sysctl_ovfs_conf __P((SYSCTL_HANDLER_ARGS));
2038
2039static int
2040vfs_sysctl(SYSCTL_HANDLER_ARGS)
2041{
2042 int *name = (int *)arg1 - 1; /* XXX */
2043 u_int namelen = arg2 + 1; /* XXX */
2044 struct vfsconf *vfsp;
2045
2046#if 1 || defined(COMPAT_PRELITE2)
2047 /* Resolve ambiguity between VFS_VFSCONF and VFS_GENERIC. */
2048 if (namelen == 1)
2049 return (sysctl_ovfs_conf(oidp, arg1, arg2, req));
2050#endif
2051
2052#ifdef notyet
2053 /* all sysctl names at this level are at least name and field */
2054 if (namelen < 2)
2055 return (ENOTDIR); /* overloaded */
2056 if (name[0] != VFS_GENERIC) {
2057 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
2058 if (vfsp->vfc_typenum == name[0])
2059 break;
2060 if (vfsp == NULL)
2061 return (EOPNOTSUPP);
2062 return ((*vfsp->vfc_vfsops->vfs_sysctl)(&name[1], namelen - 1,
2063 oldp, oldlenp, newp, newlen, p));
2064 }
2065#endif
2066 switch (name[1]) {
2067 case VFS_MAXTYPENUM:
2068 if (namelen != 2)
2069 return (ENOTDIR);
2070 return (SYSCTL_OUT(req, &maxvfsconf, sizeof(int)));
2071 case VFS_CONF:
2072 if (namelen != 3)
2073 return (ENOTDIR); /* overloaded */
2074 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
2075 if (vfsp->vfc_typenum == name[2])
2076 break;
2077 if (vfsp == NULL)
2078 return (EOPNOTSUPP);
2079 return (SYSCTL_OUT(req, vfsp, sizeof *vfsp));
2080 }
2081 return (EOPNOTSUPP);
2082}
2083
2084SYSCTL_NODE(_vfs, VFS_GENERIC, generic, CTLFLAG_RD, vfs_sysctl,
2085 "Generic filesystem");
2086
2087#if 1 || defined(COMPAT_PRELITE2)
2088
2089static int
2090sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS)
2091{
2092 int error;
2093 struct vfsconf *vfsp;
2094 struct ovfsconf ovfs;
2095
2096 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
2097 ovfs.vfc_vfsops = vfsp->vfc_vfsops; /* XXX used as flag */
2098 strcpy(ovfs.vfc_name, vfsp->vfc_name);
2099 ovfs.vfc_index = vfsp->vfc_typenum;
2100 ovfs.vfc_refcount = vfsp->vfc_refcount;
2101 ovfs.vfc_flags = vfsp->vfc_flags;
2102 error = SYSCTL_OUT(req, &ovfs, sizeof ovfs);
2103 if (error)
2104 return error;
2105 }
2106 return 0;
2107}
2108
2109#endif /* 1 || COMPAT_PRELITE2 */
2110
2111#if 0
2112#define KINFO_VNODESLOP 10
2113/*
2114 * Dump vnode list (via sysctl).
2115 * Copyout address of vnode followed by vnode.
2116 */
2117/* ARGSUSED */
2118static int
2119sysctl_vnode(SYSCTL_HANDLER_ARGS)
2120{
2121 struct proc *p = curproc; /* XXX */
2122 struct mount *mp, *nmp;
2123 struct vnode *nvp, *vp;
2124 int error;
2125
2126#define VPTRSZ sizeof (struct vnode *)
2127#define VNODESZ sizeof (struct vnode)
2128
2129 req->lock = 0;
2130 if (!req->oldptr) /* Make an estimate */
2131 return (SYSCTL_OUT(req, 0,
2132 (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ)));
2133
2134 simple_lock(&mountlist_slock);
2135 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
2136 if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
2137 nmp = TAILQ_NEXT(mp, mnt_list);
2138 continue;
2139 }
2140again:
2141 simple_lock(&mntvnode_slock);
2142 for (vp = LIST_FIRST(&mp->mnt_vnodelist);
2143 vp != NULL;
2144 vp = nvp) {
2145 /*
2146 * Check that the vp is still associated with
2147 * this filesystem. RACE: could have been
2148 * recycled onto the same filesystem.
2149 */
2150 if (vp->v_mount != mp) {
2151 simple_unlock(&mntvnode_slock);
2152 goto again;
2153 }
2154 nvp = LIST_NEXT(vp, v_mntvnodes);
2155 simple_unlock(&mntvnode_slock);
2156 if ((error = SYSCTL_OUT(req, &vp, VPTRSZ)) ||
2157 (error = SYSCTL_OUT(req, vp, VNODESZ)))
2158 return (error);
2159 simple_lock(&mntvnode_slock);
2160 }
2161 simple_unlock(&mntvnode_slock);
2162 simple_lock(&mountlist_slock);
2163 nmp = TAILQ_NEXT(mp, mnt_list);
2164 vfs_unbusy(mp, p);
2165 }
2166 simple_unlock(&mountlist_slock);
2167
2168 return (0);
2169}
2170#endif
2171
2172/*
2173 * XXX
2174 * Exporting the vnode list on large systems causes them to crash.
2175 * Exporting the vnode list on medium systems causes sysctl to coredump.
2176 */
2177#if 0
2178SYSCTL_PROC(_kern, KERN_VNODE, vnode, CTLTYPE_OPAQUE|CTLFLAG_RD,
2179 0, 0, sysctl_vnode, "S,vnode", "");
2180#endif
2181
2182/*
2183 * Check to see if a filesystem is mounted on a block device.
2184 */
2185int
2186vfs_mountedon(vp)
2187 struct vnode *vp;
2188{
2189
2190 if (vp->v_specmountpoint != NULL)
2191 return (EBUSY);
2192 return (0);
2193}
2194
2195/*
2196 * Unmount all filesystems. The list is traversed in reverse order
2197 * of mounting to avoid dependencies.
2198 */
2199void
2200vfs_unmountall()
2201{
2202 struct mount *mp;
2203 struct proc *p;
2204 int error;
2205
2206 if (curproc != NULL)
2207 p = curproc;
2208 else
2209 p = initproc; /* XXX XXX should this be proc0? */
2210 /*
2211 * Since this only runs when rebooting, it is not interlocked.
2212 */
2213 while(!TAILQ_EMPTY(&mountlist)) {
2214 mp = TAILQ_LAST(&mountlist, mntlist);
2215 error = dounmount(mp, MNT_FORCE, p);
2216 if (error) {
2217 TAILQ_REMOVE(&mountlist, mp, mnt_list);
2218 printf("unmount of %s failed (",
2219 mp->mnt_stat.f_mntonname);
2220 if (error == EBUSY)
2221 printf("BUSY)\n");
2222 else
2223 printf("%d)\n", error);
2224 } else {
2225 /* The unmount has removed mp from the mountlist */
2226 }
2227 }
2228}
2229
2230/*
2231 * Build hash lists of net addresses and hang them off the mount point.
2232 * Called by ufs_mount() to set up the lists of export addresses.
2233 */
2234static int
2235vfs_hang_addrlist(mp, nep, argp)
2236 struct mount *mp;
2237 struct netexport *nep;
2238 struct export_args *argp;
2239{
2240 register struct netcred *np;
2241 register struct radix_node_head *rnh;
2242 register int i;
2243 struct radix_node *rn;
2244 struct sockaddr *saddr, *smask = 0;
2245 struct domain *dom;
2246 int error;
2247
2248 if (argp->ex_addrlen == 0) {
2249 if (mp->mnt_flag & MNT_DEFEXPORTED)
2250 return (EPERM);
2251 np = &nep->ne_defexported;
2252 np->netc_exflags = argp->ex_flags;
2253 np->netc_anon = argp->ex_anon;
2254 np->netc_anon.cr_ref = 1;
2255 mp->mnt_flag |= MNT_DEFEXPORTED;
2256 return (0);
2257 }
2258 i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen;
2259 np = (struct netcred *) malloc(i, M_NETADDR, M_WAITOK);
2260 bzero((caddr_t) np, i);
2261 saddr = (struct sockaddr *) (np + 1);
2262 if ((error = copyin(argp->ex_addr, (caddr_t) saddr, argp->ex_addrlen)))
2263 goto out;
2264 if (saddr->sa_len > argp->ex_addrlen)
2265 saddr->sa_len = argp->ex_addrlen;
2266 if (argp->ex_masklen) {
2267 smask = (struct sockaddr *) ((caddr_t) saddr + argp->ex_addrlen);
2268 error = copyin(argp->ex_mask, (caddr_t) smask, argp->ex_masklen);
2269 if (error)
2270 goto out;
2271 if (smask->sa_len > argp->ex_masklen)
2272 smask->sa_len = argp->ex_masklen;
2273 }
2274 i = saddr->sa_family;
2275 if ((rnh = nep->ne_rtable[i]) == 0) {
2276 /*
2277 * Seems silly to initialize every AF when most are not used,
2278 * do so on demand here
2279 */
2280 for (dom = domains; dom; dom = dom->dom_next)
2281 if (dom->dom_family == i && dom->dom_rtattach) {
2282 dom->dom_rtattach((void **) &nep->ne_rtable[i],
2283 dom->dom_rtoffset);
2284 break;
2285 }
2286 if ((rnh = nep->ne_rtable[i]) == 0) {
2287 error = ENOBUFS;
2288 goto out;
2289 }
2290 }
2291 rn = (*rnh->rnh_addaddr) ((caddr_t) saddr, (caddr_t) smask, rnh,
2292 np->netc_rnodes);
2293 if (rn == 0 || np != (struct netcred *) rn) { /* already exists */
2294 error = EPERM;
2295 goto out;
2296 }
2297 np->netc_exflags = argp->ex_flags;
2298 np->netc_anon = argp->ex_anon;
2299 np->netc_anon.cr_ref = 1;
2300 return (0);
2301out:
2302 free(np, M_NETADDR);
2303 return (error);
2304}
2305
2306/* ARGSUSED */
2307static int
2308vfs_free_netcred(rn, w)
2309 struct radix_node *rn;
2310 void *w;
2311{
2312 register struct radix_node_head *rnh = (struct radix_node_head *) w;
2313
2314 (*rnh->rnh_deladdr) (rn->rn_key, rn->rn_mask, rnh);
2315 free((caddr_t) rn, M_NETADDR);
2316 return (0);
2317}
2318
2319/*
2320 * Free the net address hash lists that are hanging off the mount points.
2321 */
2322static void
2323vfs_free_addrlist(nep)
2324 struct netexport *nep;
2325{
2326 register int i;
2327 register struct radix_node_head *rnh;
2328
2329 for (i = 0; i <= AF_MAX; i++)
2330 if ((rnh = nep->ne_rtable[i])) {
2331 (*rnh->rnh_walktree) (rnh, vfs_free_netcred,
2332 (caddr_t) rnh);
2333 free((caddr_t) rnh, M_RTABLE);
2334 nep->ne_rtable[i] = 0;
2335 }
2336}
2337
2338int
2339vfs_export(mp, nep, argp)
2340 struct mount *mp;
2341 struct netexport *nep;
2342 struct export_args *argp;
2343{
2344 int error;
2345
2346 if (argp->ex_flags & MNT_DELEXPORT) {
2347 if (mp->mnt_flag & MNT_EXPUBLIC) {
2348 vfs_setpublicfs(NULL, NULL, NULL);
2349 mp->mnt_flag &= ~MNT_EXPUBLIC;
2350 }
2351 vfs_free_addrlist(nep);
2352 mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED);
2353 }
2354 if (argp->ex_flags & MNT_EXPORTED) {
2355 if (argp->ex_flags & MNT_EXPUBLIC) {
2356 if ((error = vfs_setpublicfs(mp, nep, argp)) != 0)
2357 return (error);
2358 mp->mnt_flag |= MNT_EXPUBLIC;
2359 }
2360 if ((error = vfs_hang_addrlist(mp, nep, argp)))
2361 return (error);
2362 mp->mnt_flag |= MNT_EXPORTED;
2363 }
2364 return (0);
2365}
2366
2367
2368/*
2369 * Set the publicly exported filesystem (WebNFS). Currently, only
2370 * one public filesystem is possible in the spec (RFC 2054 and 2055)
2371 */
2372int
2373vfs_setpublicfs(mp, nep, argp)
2374 struct mount *mp;
2375 struct netexport *nep;
2376 struct export_args *argp;
2377{
2378 int error;
2379 struct vnode *rvp;
2380 char *cp;
2381
2382 /*
2383 * mp == NULL -> invalidate the current info, the FS is
2384 * no longer exported. May be called from either vfs_export
2385 * or unmount, so check if it hasn't already been done.
2386 */
2387 if (mp == NULL) {
2388 if (nfs_pub.np_valid) {
2389 nfs_pub.np_valid = 0;
2390 if (nfs_pub.np_index != NULL) {
2391 FREE(nfs_pub.np_index, M_TEMP);
2392 nfs_pub.np_index = NULL;
2393 }
2394 }
2395 return (0);
2396 }
2397
2398 /*
2399 * Only one allowed at a time.
2400 */
2401 if (nfs_pub.np_valid != 0 && mp != nfs_pub.np_mount)
2402 return (EBUSY);
2403
2404 /*
2405 * Get real filehandle for root of exported FS.
2406 */
2407 bzero((caddr_t)&nfs_pub.np_handle, sizeof(nfs_pub.np_handle));
2408 nfs_pub.np_handle.fh_fsid = mp->mnt_stat.f_fsid;
2409
2410 if ((error = VFS_ROOT(mp, &rvp)))
2411 return (error);
2412
2413 if ((error = VFS_VPTOFH(rvp, &nfs_pub.np_handle.fh_fid)))
2414 return (error);
2415
2416 vput(rvp);
2417
2418 /*
2419 * If an indexfile was specified, pull it in.
2420 */
2421 if (argp->ex_indexfile != NULL) {
2422 MALLOC(nfs_pub.np_index, char *, MAXNAMLEN + 1, M_TEMP,
2423 M_WAITOK);
2424 error = copyinstr(argp->ex_indexfile, nfs_pub.np_index,
2425 MAXNAMLEN, (size_t *)0);
2426 if (!error) {
2427 /*
2428 * Check for illegal filenames.
2429 */
2430 for (cp = nfs_pub.np_index; *cp; cp++) {
2431 if (*cp == '/') {
2432 error = EINVAL;
2433 break;
2434 }
2435 }
2436 }
2437 if (error) {
2438 FREE(nfs_pub.np_index, M_TEMP);
2439 return (error);
2440 }
2441 }
2442
2443 nfs_pub.np_mount = mp;
2444 nfs_pub.np_valid = 1;
2445 return (0);
2446}
2447
2448struct netcred *
2449vfs_export_lookup(mp, nep, nam)
2450 register struct mount *mp;
2451 struct netexport *nep;
2452 struct sockaddr *nam;
2453{
2454 register struct netcred *np;
2455 register struct radix_node_head *rnh;
2456 struct sockaddr *saddr;
2457
2458 np = NULL;
2459 if (mp->mnt_flag & MNT_EXPORTED) {
2460 /*
2461 * Lookup in the export list first.
2462 */
2463 if (nam != NULL) {
2464 saddr = nam;
2465 rnh = nep->ne_rtable[saddr->sa_family];
2466 if (rnh != NULL) {
2467 np = (struct netcred *)
2468 (*rnh->rnh_matchaddr)((caddr_t)saddr,
2469 rnh);
2470 if (np && np->netc_rnodes->rn_flags & RNF_ROOT)
2471 np = NULL;
2472 }
2473 }
2474 /*
2475 * If no address match, use the default if it exists.
2476 */
2477 if (np == NULL && mp->mnt_flag & MNT_DEFEXPORTED)
2478 np = &nep->ne_defexported;
2479 }
2480 return (np);
2481}
2482
2483/*
2484 * perform msync on all vnodes under a mount point
2485 * the mount point must be locked.
2486 */
2487void
2488vfs_msync(struct mount *mp, int flags) {
2489 struct vnode *vp, *nvp;
2490 struct vm_object *obj;
2491 int anyio, tries;
2492
2493 tries = 5;
2494loop:
2495 anyio = 0;
2496 for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp != NULL; vp = nvp) {
2497
2498 nvp = LIST_NEXT(vp, v_mntvnodes);
2499
2500 if (vp->v_mount != mp) {
2501 goto loop;
2502 }
2503
2504 if (vp->v_flag & VXLOCK) /* XXX: what if MNT_WAIT? */
2505 continue;
2506
2507 if (flags != MNT_WAIT) {
2508 if (VOP_GETVOBJECT(vp, &obj) != 0 ||
2509 (obj->flags & OBJ_MIGHTBEDIRTY) == 0)
2510 continue;
2511 if (VOP_ISLOCKED(vp, NULL))
2512 continue;
2513 }
2514
2515 simple_lock(&vp->v_interlock);
2516 if (VOP_GETVOBJECT(vp, &obj) == 0 &&
2517 (obj->flags & OBJ_MIGHTBEDIRTY)) {
2518 if (!vget(vp,
2519 LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY | LK_NOOBJ, curproc)) {
2520 if (VOP_GETVOBJECT(vp, &obj) == 0) {
2521 vm_object_page_clean(obj, 0, 0, flags == MNT_WAIT ? OBJPC_SYNC : OBJPC_NOSYNC);
2522 anyio = 1;
2523 }
2524 vput(vp);
2525 }
2526 } else {
2527 simple_unlock(&vp->v_interlock);
2528 }
2529 }
2530 if (anyio && (--tries > 0))
2531 goto loop;
2532}
2533
2534/*
2535 * Create the VM object needed for VMIO and mmap support. This
2536 * is done for all VREG files in the system. Some filesystems might
2537 * afford the additional metadata buffering capability of the
2538 * VMIO code by making the device node be VMIO mode also.
2539 *
2540 * vp must be locked when vfs_object_create is called.
2541 */
2542int
2543vfs_object_create(vp, p, cred)
2544 struct vnode *vp;
2545 struct proc *p;
2546 struct ucred *cred;
2547{
2548 return (VOP_CREATEVOBJECT(vp, cred, p));
2549}
2550
2551void
2552vfree(vp)
2553 struct vnode *vp;
2554{
2555 int s;
2556
2557 s = splbio();
2558 simple_lock(&vnode_free_list_slock);
2559 KASSERT((vp->v_flag & VFREE) == 0, ("vnode already free"));
2560 if (vp->v_flag & VAGE) {
2561 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
2562 } else {
2563 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
2564 }
2565 freevnodes++;
2566 simple_unlock(&vnode_free_list_slock);
2567 vp->v_flag &= ~VAGE;
2568 vp->v_flag |= VFREE;
2569 splx(s);
2570}
2571
2572void
2573vbusy(vp)
2574 struct vnode *vp;
2575{
2576 int s;
2577
2578 s = splbio();
2579 simple_lock(&vnode_free_list_slock);
2580 KASSERT((vp->v_flag & VFREE) != 0, ("vnode not free"));
2581 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
2582 freevnodes--;
2583 simple_unlock(&vnode_free_list_slock);
2584 vp->v_flag &= ~(VFREE|VAGE);
2585 splx(s);
2586}
2587
2588/*
2589 * Record a process's interest in events which might happen to
2590 * a vnode. Because poll uses the historic select-style interface
2591 * internally, this routine serves as both the ``check for any
2592 * pending events'' and the ``record my interest in future events''
2593 * functions. (These are done together, while the lock is held,
2594 * to avoid race conditions.)
2595 */
2596int
2597vn_pollrecord(vp, p, events)
2598 struct vnode *vp;
2599 struct proc *p;
2600 short events;
2601{
2602 simple_lock(&vp->v_pollinfo.vpi_lock);
2603 if (vp->v_pollinfo.vpi_revents & events) {
2604 /*
2605 * This leaves events we are not interested
2606 * in available for the other process which
2607 * which presumably had requested them
2608 * (otherwise they would never have been
2609 * recorded).
2610 */
2611 events &= vp->v_pollinfo.vpi_revents;
2612 vp->v_pollinfo.vpi_revents &= ~events;
2613
2614 simple_unlock(&vp->v_pollinfo.vpi_lock);
2615 return events;
2616 }
2617 vp->v_pollinfo.vpi_events |= events;
2618 selrecord(p, &vp->v_pollinfo.vpi_selinfo);
2619 simple_unlock(&vp->v_pollinfo.vpi_lock);
2620 return 0;
2621}
2622
2623/*
2624 * Note the occurrence of an event. If the VN_POLLEVENT macro is used,
2625 * it is possible for us to miss an event due to race conditions, but
2626 * that condition is expected to be rare, so for the moment it is the
2627 * preferred interface.
2628 */
2629void
2630vn_pollevent(vp, events)
2631 struct vnode *vp;
2632 short events;
2633{
2634 simple_lock(&vp->v_pollinfo.vpi_lock);
2635 if (vp->v_pollinfo.vpi_events & events) {
2636 /*
2637 * We clear vpi_events so that we don't
2638 * call selwakeup() twice if two events are
2639 * posted before the polling process(es) is
2640 * awakened. This also ensures that we take at
2641 * most one selwakeup() if the polling process
2642 * is no longer interested. However, it does
2643 * mean that only one event can be noticed at
2644 * a time. (Perhaps we should only clear those
2645 * event bits which we note?) XXX
2646 */
2647 vp->v_pollinfo.vpi_events = 0; /* &= ~events ??? */
2648 vp->v_pollinfo.vpi_revents |= events;
2649 selwakeup(&vp->v_pollinfo.vpi_selinfo);
2650 }
2651 simple_unlock(&vp->v_pollinfo.vpi_lock);
2652}
2653
2654/*
2655 * Wake up anyone polling on vp because it is being revoked.
2656 * This depends on dead_poll() returning POLLHUP for correct
2657 * behavior.
2658 */
2659void
2660vn_pollgone(vp)
2661 struct vnode *vp;
2662{
2663 simple_lock(&vp->v_pollinfo.vpi_lock);
2664 if (vp->v_pollinfo.vpi_events) {
2665 vp->v_pollinfo.vpi_events = 0;
2666 selwakeup(&vp->v_pollinfo.vpi_selinfo);
2667 }
2668 simple_unlock(&vp->v_pollinfo.vpi_lock);
2669}
2670
2671
2672
2673/*
2674 * Routine to create and manage a filesystem syncer vnode.
2675 */
2676#define sync_close ((int (*) __P((struct vop_close_args *)))nullop)
2677static int sync_fsync __P((struct vop_fsync_args *));
2678static int sync_inactive __P((struct vop_inactive_args *));
2679static int sync_reclaim __P((struct vop_reclaim_args *));
2680#define sync_lock ((int (*) __P((struct vop_lock_args *)))vop_nolock)
2681#define sync_unlock ((int (*) __P((struct vop_unlock_args *)))vop_nounlock)
2682static int sync_print __P((struct vop_print_args *));
2683#define sync_islocked ((int(*) __P((struct vop_islocked_args *)))vop_noislocked)
2684
2685static vop_t **sync_vnodeop_p;
2686static struct vnodeopv_entry_desc sync_vnodeop_entries[] = {
2687 { &vop_default_desc, (vop_t *) vop_eopnotsupp },
2688 { &vop_close_desc, (vop_t *) sync_close }, /* close */
2689 { &vop_fsync_desc, (vop_t *) sync_fsync }, /* fsync */
2690 { &vop_inactive_desc, (vop_t *) sync_inactive }, /* inactive */
2691 { &vop_reclaim_desc, (vop_t *) sync_reclaim }, /* reclaim */
2692 { &vop_lock_desc, (vop_t *) sync_lock }, /* lock */
2693 { &vop_unlock_desc, (vop_t *) sync_unlock }, /* unlock */
2694 { &vop_print_desc, (vop_t *) sync_print }, /* print */
2695 { &vop_islocked_desc, (vop_t *) sync_islocked }, /* islocked */
2696 { NULL, NULL }
2697};
2698static struct vnodeopv_desc sync_vnodeop_opv_desc =
2699 { &sync_vnodeop_p, sync_vnodeop_entries };
2700
2701VNODEOP_SET(sync_vnodeop_opv_desc);
2702
2703/*
2704 * Create a new filesystem syncer vnode for the specified mount point.
2705 */
2706int
2707vfs_allocate_syncvnode(mp)
2708 struct mount *mp;
2709{
2710 struct vnode *vp;
2711 static long start, incr, next;
2712 int error;
2713
2714 /* Allocate a new vnode */
2715 if ((error = getnewvnode(VT_VFS, mp, sync_vnodeop_p, &vp)) != 0) {
2716 mp->mnt_syncer = NULL;
2717 return (error);
2718 }
2719 vp->v_type = VNON;
2720 /*
2721 * Place the vnode onto the syncer worklist. We attempt to
2722 * scatter them about on the list so that they will go off
2723 * at evenly distributed times even if all the filesystems
2724 * are mounted at once.
2725 */
2726 next += incr;
2727 if (next == 0 || next > syncer_maxdelay) {
2728 start /= 2;
2729 incr /= 2;
2730 if (start == 0) {
2731 start = syncer_maxdelay / 2;
2732 incr = syncer_maxdelay;
2733 }
2734 next = start;
2735 }
2736 vn_syncer_add_to_worklist(vp, syncdelay > 0 ? next % syncdelay : 0);
2737 mp->mnt_syncer = vp;
2738 return (0);
2739}
2740
2741/*
2742 * Do a lazy sync of the filesystem.
2743 */
2744static int
2745sync_fsync(ap)
2746 struct vop_fsync_args /* {
2747 struct vnode *a_vp;
2748 struct ucred *a_cred;
2749 int a_waitfor;
2750 struct proc *a_p;
2751 } */ *ap;
2752{
2753 struct vnode *syncvp = ap->a_vp;
2754 struct mount *mp = syncvp->v_mount;
2755 struct proc *p = ap->a_p;
2756 int asyncflag;
2757
2758 /*
2759 * We only need to do something if this is a lazy evaluation.
2760 */
2761 if (ap->a_waitfor != MNT_LAZY)
2762 return (0);
2763
2764 /*
2765 * Move ourselves to the back of the sync list.
2766 */
2767 vn_syncer_add_to_worklist(syncvp, syncdelay);
2768
2769 /*
2770 * Walk the list of vnodes pushing all that are dirty and
2771 * not already on the sync list.
2772 */
2773 simple_lock(&mountlist_slock);
2774 if (vfs_busy(mp, LK_EXCLUSIVE | LK_NOWAIT, &mountlist_slock, p) != 0) {
2775 simple_unlock(&mountlist_slock);
2776 return (0);
2777 }
2778 if (vn_start_write(NULL, &mp, V_NOWAIT) != 0) {
2779 vfs_unbusy(mp, p);
2780 simple_unlock(&mountlist_slock);
2781 return (0);
2782 }
2783 asyncflag = mp->mnt_flag & MNT_ASYNC;
2784 mp->mnt_flag &= ~MNT_ASYNC;
2785 vfs_msync(mp, MNT_NOWAIT);
2786 VFS_SYNC(mp, MNT_LAZY, ap->a_cred, p);
2787 if (asyncflag)
2788 mp->mnt_flag |= MNT_ASYNC;
2789 vn_finished_write(mp);
2790 vfs_unbusy(mp, p);
2791 return (0);
2792}
2793
2794/*
2795 * The syncer vnode is no referenced.
2796 */
2797static int
2798sync_inactive(ap)
2799 struct vop_inactive_args /* {
2800 struct vnode *a_vp;
2801 struct proc *a_p;
2802 } */ *ap;
2803{
2804
2805 vgone(ap->a_vp);
2806 return (0);
2807}
2808
2809/*
2810 * The syncer vnode is no longer needed and is being decommissioned.
2811 *
2812 * Modifications to the worklist must be protected at splbio().
2813 */
2814static int
2815sync_reclaim(ap)
2816 struct vop_reclaim_args /* {
2817 struct vnode *a_vp;
2818 } */ *ap;
2819{
2820 struct vnode *vp = ap->a_vp;
2821 int s;
2822
2823 s = splbio();
2824 vp->v_mount->mnt_syncer = NULL;
2825 if (vp->v_flag & VONWORKLST) {
2826 LIST_REMOVE(vp, v_synclist);
2827 vp->v_flag &= ~VONWORKLST;
2828 }
2829 splx(s);
2830
2831 return (0);
2832}
2833
2834/*
2835 * Print out a syncer vnode.
2836 */
2837static int
2838sync_print(ap)
2839 struct vop_print_args /* {
2840 struct vnode *a_vp;
2841 } */ *ap;
2842{
2843 struct vnode *vp = ap->a_vp;
2844
2845 printf("syncer vnode");
2846 if (vp->v_vnlock != NULL)
2847 lockmgr_printinfo(vp->v_vnlock);
2848 printf("\n");
2849 return (0);
2850}
2851
2852/*
2853 * extract the dev_t from a VBLK or VCHR
2854 */
2855dev_t
2856vn_todev(vp)
2857 struct vnode *vp;
2858{
2859 if (vp->v_type != VBLK && vp->v_type != VCHR)
2860 return (NODEV);
2861 return (vp->v_rdev);
2862}
2863
2864/*
2865 * Check if vnode represents a disk device
2866 */
2867int
2868vn_isdisk(vp, errp)
2869 struct vnode *vp;
2870 int *errp;
2871{
2872 struct cdevsw *cdevsw;
2873
2874 if (vp->v_type != VBLK && vp->v_type != VCHR) {
2875 if (errp != NULL)
2876 *errp = ENOTBLK;
2877 return (0);
2878 }
2879 if (vp->v_rdev == NULL) {
2880 if (errp != NULL)
2881 *errp = ENXIO;
2882 return (0);
2883 }
2884 cdevsw = devsw(vp->v_rdev);
2885 if (cdevsw == NULL) {
2886 if (errp != NULL)
2887 *errp = ENXIO;
2888 return (0);
2889 }
2890 if (!(cdevsw->d_flags & D_DISK)) {
2891 if (errp != NULL)
2892 *errp = ENOTBLK;
2893 return (0);
2894 }
2895 if (errp != NULL)
2896 *errp = 0;
2897 return (1);
2898}
2899
2900void
2901NDFREE(ndp, flags)
2902 struct nameidata *ndp;
2903 const uint flags;
2904{
2905 if (!(flags & NDF_NO_FREE_PNBUF) &&
2906 (ndp->ni_cnd.cn_flags & HASBUF)) {
2907 zfree(namei_zone, ndp->ni_cnd.cn_pnbuf);
2908 ndp->ni_cnd.cn_flags &= ~HASBUF;
2909 }
2910 if (!(flags & NDF_NO_DVP_UNLOCK) &&
2911 (ndp->ni_cnd.cn_flags & LOCKPARENT) &&
2912 ndp->ni_dvp != ndp->ni_vp)
2913 VOP_UNLOCK(ndp->ni_dvp, 0, ndp->ni_cnd.cn_proc);
2914 if (!(flags & NDF_NO_DVP_RELE) &&
2915 (ndp->ni_cnd.cn_flags & (LOCKPARENT|WANTPARENT))) {
2916 vrele(ndp->ni_dvp);
2917 ndp->ni_dvp = NULL;
2918 }
2919 if (!(flags & NDF_NO_VP_UNLOCK) &&
2920 (ndp->ni_cnd.cn_flags & LOCKLEAF) && ndp->ni_vp)
2921 VOP_UNLOCK(ndp->ni_vp, 0, ndp->ni_cnd.cn_proc);
2922 if (!(flags & NDF_NO_VP_RELE) &&
2923 ndp->ni_vp) {
2924 vrele(ndp->ni_vp);
2925 ndp->ni_vp = NULL;
2926 }
2927 if (!(flags & NDF_NO_STARTDIR_RELE) &&
2928 (ndp->ni_cnd.cn_flags & SAVESTART)) {
2929 vrele(ndp->ni_startdir);
2930 ndp->ni_startdir = NULL;
2931 }
2932}
2933
2934int
2935vaccess(type, file_mode, file_uid, file_gid, acc_mode, cred, privused)
2936 enum vtype type;
2937 mode_t file_mode;
2938 uid_t file_uid;
2939 gid_t file_gid;
2940 mode_t acc_mode;
2941 struct ucred *cred;
2942 int *privused;
2943{
2944 mode_t dac_granted;
2945#ifdef CAPABILITIES
2946 mode_t cap_granted;
2947#endif
2948
2949 /*
2950 * Look for a normal, non-privileged way to access the file/directory
2951 * as requested. If it exists, go with that.
2952 */
2953
2954 if (privused != NULL)
2955 *privused = 0;
2956
2957 dac_granted = 0;
2958
2959 /* Check the owner. */
2960 if (cred->cr_uid == file_uid) {
2961 if (file_mode & S_IXUSR)
2962 dac_granted |= VEXEC;
2963 if (file_mode & S_IRUSR)
2964 dac_granted |= VREAD;
2965 if (file_mode & S_IWUSR)
2966 dac_granted |= VWRITE;
2967
2968 if ((acc_mode & dac_granted) == acc_mode)
2969 return (0);
2970
2971 goto privcheck;
2972 }
2973
2974 /* Otherwise, check the groups (first match) */
2975 if (groupmember(file_gid, cred)) {
2976 if (file_mode & S_IXGRP)
2977 dac_granted |= VEXEC;
2978 if (file_mode & S_IRGRP)
2979 dac_granted |= VREAD;
2980 if (file_mode & S_IWGRP)
2981 dac_granted |= VWRITE;
2982
2983 if ((acc_mode & dac_granted) == acc_mode)
2984 return (0);
2985
2986 goto privcheck;
2987 }
2988
2989 /* Otherwise, check everyone else. */
2990 if (file_mode & S_IXOTH)
2991 dac_granted |= VEXEC;
2992 if (file_mode & S_IROTH)
2993 dac_granted |= VREAD;
2994 if (file_mode & S_IWOTH)
2995 dac_granted |= VWRITE;
2996 if ((acc_mode & dac_granted) == acc_mode)
2997 return (0);
2998
2999privcheck:
3000 if (!suser_xxx(cred, NULL, PRISON_ROOT)) {
3001 /* XXX audit: privilege used */
3002 if (privused != NULL)
3003 *privused = 1;
3004 return (0);
3005 }
3006
3007#ifdef CAPABILITIES
3008 /*
3009 * Build a capability mask to determine if the set of capabilities
3010 * satisfies the requirements when combined with the granted mask
3011 * from above.
3012 * For each capability, if the capability is required, bitwise
3013 * or the request type onto the cap_granted mask.
3014 */
3015 cap_granted = 0;
3016 if ((acc_mode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
3017 !cap_check_xxx(cred, NULL, CAP_DAC_EXECUTE, PRISON_ROOT))
3018 cap_granted |= VEXEC;
3019
3020 if ((acc_mode & VREAD) && ((dac_granted & VREAD) == 0) &&
3021 !cap_check_xxx(cred, NULL, CAP_DAC_READ_SEARCH, PRISON_ROOT))
3022 cap_granted |= VREAD;
3023
3024 if ((acc_mode & VWRITE) && ((dac_granted & VWRITE) == 0) &&
3025 !cap_check_xxx(cred, NULL, CAP_DAC_WRITE, PRISON_ROOT))
3026 cap_granted |= VWRITE;
3027
3028 if ((acc_mode & (cap_granted | dac_granted)) == acc_mode) {
3029 /* XXX audit: privilege used */
3030 if (privused != NULL)
3031 *privused = 1;
3032 return (0);
3033 }
3034#endif
3035
3036 return (EACCES);
3037}
| 1933 count += vq->v_usecount;
1934 simple_unlock(&spechash_slock);
1935 return (count);
1936}
1937
1938/*
1939 * Same as above, but using the dev_t as argument
1940 */
1941
1942int
1943count_dev(dev)
1944 dev_t dev;
1945{
1946 struct vnode *vp;
1947
1948 vp = SLIST_FIRST(&dev->si_hlist);
1949 if (vp == NULL)
1950 return (0);
1951 return(vcount(vp));
1952}
1953
1954/*
1955 * Print out a description of a vnode.
1956 */
1957static char *typename[] =
1958{"VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD"};
1959
1960void
1961vprint(label, vp)
1962 char *label;
1963 struct vnode *vp;
1964{
1965 char buf[96];
1966
1967 if (label != NULL)
1968 printf("%s: %p: ", label, (void *)vp);
1969 else
1970 printf("%p: ", (void *)vp);
1971 printf("type %s, usecount %d, writecount %d, refcount %d,",
1972 typename[vp->v_type], vp->v_usecount, vp->v_writecount,
1973 vp->v_holdcnt);
1974 buf[0] = '\0';
1975 if (vp->v_flag & VROOT)
1976 strcat(buf, "|VROOT");
1977 if (vp->v_flag & VTEXT)
1978 strcat(buf, "|VTEXT");
1979 if (vp->v_flag & VSYSTEM)
1980 strcat(buf, "|VSYSTEM");
1981 if (vp->v_flag & VXLOCK)
1982 strcat(buf, "|VXLOCK");
1983 if (vp->v_flag & VXWANT)
1984 strcat(buf, "|VXWANT");
1985 if (vp->v_flag & VBWAIT)
1986 strcat(buf, "|VBWAIT");
1987 if (vp->v_flag & VDOOMED)
1988 strcat(buf, "|VDOOMED");
1989 if (vp->v_flag & VFREE)
1990 strcat(buf, "|VFREE");
1991 if (vp->v_flag & VOBJBUF)
1992 strcat(buf, "|VOBJBUF");
1993 if (buf[0] != '\0')
1994 printf(" flags (%s)", &buf[1]);
1995 if (vp->v_data == NULL) {
1996 printf("\n");
1997 } else {
1998 printf("\n\t");
1999 VOP_PRINT(vp);
2000 }
2001}
2002
2003#ifdef DDB
2004#include <ddb/ddb.h>
2005/*
2006 * List all of the locked vnodes in the system.
2007 * Called when debugging the kernel.
2008 */
2009DB_SHOW_COMMAND(lockedvnodes, lockedvnodes)
2010{
2011 struct proc *p = curproc; /* XXX */
2012 struct mount *mp, *nmp;
2013 struct vnode *vp;
2014
2015 printf("Locked vnodes\n");
2016 simple_lock(&mountlist_slock);
2017 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
2018 if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
2019 nmp = TAILQ_NEXT(mp, mnt_list);
2020 continue;
2021 }
2022 LIST_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
2023 if (VOP_ISLOCKED(vp, NULL))
2024 vprint((char *)0, vp);
2025 }
2026 simple_lock(&mountlist_slock);
2027 nmp = TAILQ_NEXT(mp, mnt_list);
2028 vfs_unbusy(mp, p);
2029 }
2030 simple_unlock(&mountlist_slock);
2031}
2032#endif
2033
2034/*
2035 * Top level filesystem related information gathering.
2036 */
2037static int sysctl_ovfs_conf __P((SYSCTL_HANDLER_ARGS));
2038
2039static int
2040vfs_sysctl(SYSCTL_HANDLER_ARGS)
2041{
2042 int *name = (int *)arg1 - 1; /* XXX */
2043 u_int namelen = arg2 + 1; /* XXX */
2044 struct vfsconf *vfsp;
2045
2046#if 1 || defined(COMPAT_PRELITE2)
2047 /* Resolve ambiguity between VFS_VFSCONF and VFS_GENERIC. */
2048 if (namelen == 1)
2049 return (sysctl_ovfs_conf(oidp, arg1, arg2, req));
2050#endif
2051
2052#ifdef notyet
2053 /* all sysctl names at this level are at least name and field */
2054 if (namelen < 2)
2055 return (ENOTDIR); /* overloaded */
2056 if (name[0] != VFS_GENERIC) {
2057 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
2058 if (vfsp->vfc_typenum == name[0])
2059 break;
2060 if (vfsp == NULL)
2061 return (EOPNOTSUPP);
2062 return ((*vfsp->vfc_vfsops->vfs_sysctl)(&name[1], namelen - 1,
2063 oldp, oldlenp, newp, newlen, p));
2064 }
2065#endif
2066 switch (name[1]) {
2067 case VFS_MAXTYPENUM:
2068 if (namelen != 2)
2069 return (ENOTDIR);
2070 return (SYSCTL_OUT(req, &maxvfsconf, sizeof(int)));
2071 case VFS_CONF:
2072 if (namelen != 3)
2073 return (ENOTDIR); /* overloaded */
2074 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
2075 if (vfsp->vfc_typenum == name[2])
2076 break;
2077 if (vfsp == NULL)
2078 return (EOPNOTSUPP);
2079 return (SYSCTL_OUT(req, vfsp, sizeof *vfsp));
2080 }
2081 return (EOPNOTSUPP);
2082}
2083
2084SYSCTL_NODE(_vfs, VFS_GENERIC, generic, CTLFLAG_RD, vfs_sysctl,
2085 "Generic filesystem");
2086
2087#if 1 || defined(COMPAT_PRELITE2)
2088
2089static int
2090sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS)
2091{
2092 int error;
2093 struct vfsconf *vfsp;
2094 struct ovfsconf ovfs;
2095
2096 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
2097 ovfs.vfc_vfsops = vfsp->vfc_vfsops; /* XXX used as flag */
2098 strcpy(ovfs.vfc_name, vfsp->vfc_name);
2099 ovfs.vfc_index = vfsp->vfc_typenum;
2100 ovfs.vfc_refcount = vfsp->vfc_refcount;
2101 ovfs.vfc_flags = vfsp->vfc_flags;
2102 error = SYSCTL_OUT(req, &ovfs, sizeof ovfs);
2103 if (error)
2104 return error;
2105 }
2106 return 0;
2107}
2108
2109#endif /* 1 || COMPAT_PRELITE2 */
2110
2111#if 0
2112#define KINFO_VNODESLOP 10
2113/*
2114 * Dump vnode list (via sysctl).
2115 * Copyout address of vnode followed by vnode.
2116 */
2117/* ARGSUSED */
2118static int
2119sysctl_vnode(SYSCTL_HANDLER_ARGS)
2120{
2121 struct proc *p = curproc; /* XXX */
2122 struct mount *mp, *nmp;
2123 struct vnode *nvp, *vp;
2124 int error;
2125
2126#define VPTRSZ sizeof (struct vnode *)
2127#define VNODESZ sizeof (struct vnode)
2128
2129 req->lock = 0;
2130 if (!req->oldptr) /* Make an estimate */
2131 return (SYSCTL_OUT(req, 0,
2132 (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ)));
2133
2134 simple_lock(&mountlist_slock);
2135 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
2136 if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
2137 nmp = TAILQ_NEXT(mp, mnt_list);
2138 continue;
2139 }
2140again:
2141 simple_lock(&mntvnode_slock);
2142 for (vp = LIST_FIRST(&mp->mnt_vnodelist);
2143 vp != NULL;
2144 vp = nvp) {
2145 /*
2146 * Check that the vp is still associated with
2147 * this filesystem. RACE: could have been
2148 * recycled onto the same filesystem.
2149 */
2150 if (vp->v_mount != mp) {
2151 simple_unlock(&mntvnode_slock);
2152 goto again;
2153 }
2154 nvp = LIST_NEXT(vp, v_mntvnodes);
2155 simple_unlock(&mntvnode_slock);
2156 if ((error = SYSCTL_OUT(req, &vp, VPTRSZ)) ||
2157 (error = SYSCTL_OUT(req, vp, VNODESZ)))
2158 return (error);
2159 simple_lock(&mntvnode_slock);
2160 }
2161 simple_unlock(&mntvnode_slock);
2162 simple_lock(&mountlist_slock);
2163 nmp = TAILQ_NEXT(mp, mnt_list);
2164 vfs_unbusy(mp, p);
2165 }
2166 simple_unlock(&mountlist_slock);
2167
2168 return (0);
2169}
2170#endif
2171
2172/*
2173 * XXX
2174 * Exporting the vnode list on large systems causes them to crash.
2175 * Exporting the vnode list on medium systems causes sysctl to coredump.
2176 */
2177#if 0
2178SYSCTL_PROC(_kern, KERN_VNODE, vnode, CTLTYPE_OPAQUE|CTLFLAG_RD,
2179 0, 0, sysctl_vnode, "S,vnode", "");
2180#endif
2181
2182/*
2183 * Check to see if a filesystem is mounted on a block device.
2184 */
2185int
2186vfs_mountedon(vp)
2187 struct vnode *vp;
2188{
2189
2190 if (vp->v_specmountpoint != NULL)
2191 return (EBUSY);
2192 return (0);
2193}
2194
2195/*
2196 * Unmount all filesystems. The list is traversed in reverse order
2197 * of mounting to avoid dependencies.
2198 */
2199void
2200vfs_unmountall()
2201{
2202 struct mount *mp;
2203 struct proc *p;
2204 int error;
2205
2206 if (curproc != NULL)
2207 p = curproc;
2208 else
2209 p = initproc; /* XXX XXX should this be proc0? */
2210 /*
2211 * Since this only runs when rebooting, it is not interlocked.
2212 */
2213 while(!TAILQ_EMPTY(&mountlist)) {
2214 mp = TAILQ_LAST(&mountlist, mntlist);
2215 error = dounmount(mp, MNT_FORCE, p);
2216 if (error) {
2217 TAILQ_REMOVE(&mountlist, mp, mnt_list);
2218 printf("unmount of %s failed (",
2219 mp->mnt_stat.f_mntonname);
2220 if (error == EBUSY)
2221 printf("BUSY)\n");
2222 else
2223 printf("%d)\n", error);
2224 } else {
2225 /* The unmount has removed mp from the mountlist */
2226 }
2227 }
2228}
2229
2230/*
2231 * Build hash lists of net addresses and hang them off the mount point.
2232 * Called by ufs_mount() to set up the lists of export addresses.
2233 */
2234static int
2235vfs_hang_addrlist(mp, nep, argp)
2236 struct mount *mp;
2237 struct netexport *nep;
2238 struct export_args *argp;
2239{
2240 register struct netcred *np;
2241 register struct radix_node_head *rnh;
2242 register int i;
2243 struct radix_node *rn;
2244 struct sockaddr *saddr, *smask = 0;
2245 struct domain *dom;
2246 int error;
2247
2248 if (argp->ex_addrlen == 0) {
2249 if (mp->mnt_flag & MNT_DEFEXPORTED)
2250 return (EPERM);
2251 np = &nep->ne_defexported;
2252 np->netc_exflags = argp->ex_flags;
2253 np->netc_anon = argp->ex_anon;
2254 np->netc_anon.cr_ref = 1;
2255 mp->mnt_flag |= MNT_DEFEXPORTED;
2256 return (0);
2257 }
2258 i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen;
2259 np = (struct netcred *) malloc(i, M_NETADDR, M_WAITOK);
2260 bzero((caddr_t) np, i);
2261 saddr = (struct sockaddr *) (np + 1);
2262 if ((error = copyin(argp->ex_addr, (caddr_t) saddr, argp->ex_addrlen)))
2263 goto out;
2264 if (saddr->sa_len > argp->ex_addrlen)
2265 saddr->sa_len = argp->ex_addrlen;
2266 if (argp->ex_masklen) {
2267 smask = (struct sockaddr *) ((caddr_t) saddr + argp->ex_addrlen);
2268 error = copyin(argp->ex_mask, (caddr_t) smask, argp->ex_masklen);
2269 if (error)
2270 goto out;
2271 if (smask->sa_len > argp->ex_masklen)
2272 smask->sa_len = argp->ex_masklen;
2273 }
2274 i = saddr->sa_family;
2275 if ((rnh = nep->ne_rtable[i]) == 0) {
2276 /*
2277 * Seems silly to initialize every AF when most are not used,
2278 * do so on demand here
2279 */
2280 for (dom = domains; dom; dom = dom->dom_next)
2281 if (dom->dom_family == i && dom->dom_rtattach) {
2282 dom->dom_rtattach((void **) &nep->ne_rtable[i],
2283 dom->dom_rtoffset);
2284 break;
2285 }
2286 if ((rnh = nep->ne_rtable[i]) == 0) {
2287 error = ENOBUFS;
2288 goto out;
2289 }
2290 }
2291 rn = (*rnh->rnh_addaddr) ((caddr_t) saddr, (caddr_t) smask, rnh,
2292 np->netc_rnodes);
2293 if (rn == 0 || np != (struct netcred *) rn) { /* already exists */
2294 error = EPERM;
2295 goto out;
2296 }
2297 np->netc_exflags = argp->ex_flags;
2298 np->netc_anon = argp->ex_anon;
2299 np->netc_anon.cr_ref = 1;
2300 return (0);
2301out:
2302 free(np, M_NETADDR);
2303 return (error);
2304}
2305
2306/* ARGSUSED */
2307static int
2308vfs_free_netcred(rn, w)
2309 struct radix_node *rn;
2310 void *w;
2311{
2312 register struct radix_node_head *rnh = (struct radix_node_head *) w;
2313
2314 (*rnh->rnh_deladdr) (rn->rn_key, rn->rn_mask, rnh);
2315 free((caddr_t) rn, M_NETADDR);
2316 return (0);
2317}
2318
2319/*
2320 * Free the net address hash lists that are hanging off the mount points.
2321 */
2322static void
2323vfs_free_addrlist(nep)
2324 struct netexport *nep;
2325{
2326 register int i;
2327 register struct radix_node_head *rnh;
2328
2329 for (i = 0; i <= AF_MAX; i++)
2330 if ((rnh = nep->ne_rtable[i])) {
2331 (*rnh->rnh_walktree) (rnh, vfs_free_netcred,
2332 (caddr_t) rnh);
2333 free((caddr_t) rnh, M_RTABLE);
2334 nep->ne_rtable[i] = 0;
2335 }
2336}
2337
2338int
2339vfs_export(mp, nep, argp)
2340 struct mount *mp;
2341 struct netexport *nep;
2342 struct export_args *argp;
2343{
2344 int error;
2345
2346 if (argp->ex_flags & MNT_DELEXPORT) {
2347 if (mp->mnt_flag & MNT_EXPUBLIC) {
2348 vfs_setpublicfs(NULL, NULL, NULL);
2349 mp->mnt_flag &= ~MNT_EXPUBLIC;
2350 }
2351 vfs_free_addrlist(nep);
2352 mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED);
2353 }
2354 if (argp->ex_flags & MNT_EXPORTED) {
2355 if (argp->ex_flags & MNT_EXPUBLIC) {
2356 if ((error = vfs_setpublicfs(mp, nep, argp)) != 0)
2357 return (error);
2358 mp->mnt_flag |= MNT_EXPUBLIC;
2359 }
2360 if ((error = vfs_hang_addrlist(mp, nep, argp)))
2361 return (error);
2362 mp->mnt_flag |= MNT_EXPORTED;
2363 }
2364 return (0);
2365}
2366
2367
2368/*
2369 * Set the publicly exported filesystem (WebNFS). Currently, only
2370 * one public filesystem is possible in the spec (RFC 2054 and 2055)
2371 */
2372int
2373vfs_setpublicfs(mp, nep, argp)
2374 struct mount *mp;
2375 struct netexport *nep;
2376 struct export_args *argp;
2377{
2378 int error;
2379 struct vnode *rvp;
2380 char *cp;
2381
2382 /*
2383 * mp == NULL -> invalidate the current info, the FS is
2384 * no longer exported. May be called from either vfs_export
2385 * or unmount, so check if it hasn't already been done.
2386 */
2387 if (mp == NULL) {
2388 if (nfs_pub.np_valid) {
2389 nfs_pub.np_valid = 0;
2390 if (nfs_pub.np_index != NULL) {
2391 FREE(nfs_pub.np_index, M_TEMP);
2392 nfs_pub.np_index = NULL;
2393 }
2394 }
2395 return (0);
2396 }
2397
2398 /*
2399 * Only one allowed at a time.
2400 */
2401 if (nfs_pub.np_valid != 0 && mp != nfs_pub.np_mount)
2402 return (EBUSY);
2403
2404 /*
2405 * Get real filehandle for root of exported FS.
2406 */
2407 bzero((caddr_t)&nfs_pub.np_handle, sizeof(nfs_pub.np_handle));
2408 nfs_pub.np_handle.fh_fsid = mp->mnt_stat.f_fsid;
2409
2410 if ((error = VFS_ROOT(mp, &rvp)))
2411 return (error);
2412
2413 if ((error = VFS_VPTOFH(rvp, &nfs_pub.np_handle.fh_fid)))
2414 return (error);
2415
2416 vput(rvp);
2417
2418 /*
2419 * If an indexfile was specified, pull it in.
2420 */
2421 if (argp->ex_indexfile != NULL) {
2422 MALLOC(nfs_pub.np_index, char *, MAXNAMLEN + 1, M_TEMP,
2423 M_WAITOK);
2424 error = copyinstr(argp->ex_indexfile, nfs_pub.np_index,
2425 MAXNAMLEN, (size_t *)0);
2426 if (!error) {
2427 /*
2428 * Check for illegal filenames.
2429 */
2430 for (cp = nfs_pub.np_index; *cp; cp++) {
2431 if (*cp == '/') {
2432 error = EINVAL;
2433 break;
2434 }
2435 }
2436 }
2437 if (error) {
2438 FREE(nfs_pub.np_index, M_TEMP);
2439 return (error);
2440 }
2441 }
2442
2443 nfs_pub.np_mount = mp;
2444 nfs_pub.np_valid = 1;
2445 return (0);
2446}
2447
2448struct netcred *
2449vfs_export_lookup(mp, nep, nam)
2450 register struct mount *mp;
2451 struct netexport *nep;
2452 struct sockaddr *nam;
2453{
2454 register struct netcred *np;
2455 register struct radix_node_head *rnh;
2456 struct sockaddr *saddr;
2457
2458 np = NULL;
2459 if (mp->mnt_flag & MNT_EXPORTED) {
2460 /*
2461 * Lookup in the export list first.
2462 */
2463 if (nam != NULL) {
2464 saddr = nam;
2465 rnh = nep->ne_rtable[saddr->sa_family];
2466 if (rnh != NULL) {
2467 np = (struct netcred *)
2468 (*rnh->rnh_matchaddr)((caddr_t)saddr,
2469 rnh);
2470 if (np && np->netc_rnodes->rn_flags & RNF_ROOT)
2471 np = NULL;
2472 }
2473 }
2474 /*
2475 * If no address match, use the default if it exists.
2476 */
2477 if (np == NULL && mp->mnt_flag & MNT_DEFEXPORTED)
2478 np = &nep->ne_defexported;
2479 }
2480 return (np);
2481}
2482
2483/*
2484 * perform msync on all vnodes under a mount point
2485 * the mount point must be locked.
2486 */
2487void
2488vfs_msync(struct mount *mp, int flags) {
2489 struct vnode *vp, *nvp;
2490 struct vm_object *obj;
2491 int anyio, tries;
2492
2493 tries = 5;
2494loop:
2495 anyio = 0;
2496 for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp != NULL; vp = nvp) {
2497
2498 nvp = LIST_NEXT(vp, v_mntvnodes);
2499
2500 if (vp->v_mount != mp) {
2501 goto loop;
2502 }
2503
2504 if (vp->v_flag & VXLOCK) /* XXX: what if MNT_WAIT? */
2505 continue;
2506
2507 if (flags != MNT_WAIT) {
2508 if (VOP_GETVOBJECT(vp, &obj) != 0 ||
2509 (obj->flags & OBJ_MIGHTBEDIRTY) == 0)
2510 continue;
2511 if (VOP_ISLOCKED(vp, NULL))
2512 continue;
2513 }
2514
2515 simple_lock(&vp->v_interlock);
2516 if (VOP_GETVOBJECT(vp, &obj) == 0 &&
2517 (obj->flags & OBJ_MIGHTBEDIRTY)) {
2518 if (!vget(vp,
2519 LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY | LK_NOOBJ, curproc)) {
2520 if (VOP_GETVOBJECT(vp, &obj) == 0) {
2521 vm_object_page_clean(obj, 0, 0, flags == MNT_WAIT ? OBJPC_SYNC : OBJPC_NOSYNC);
2522 anyio = 1;
2523 }
2524 vput(vp);
2525 }
2526 } else {
2527 simple_unlock(&vp->v_interlock);
2528 }
2529 }
2530 if (anyio && (--tries > 0))
2531 goto loop;
2532}
2533
2534/*
2535 * Create the VM object needed for VMIO and mmap support. This
2536 * is done for all VREG files in the system. Some filesystems might
2537 * afford the additional metadata buffering capability of the
2538 * VMIO code by making the device node be VMIO mode also.
2539 *
2540 * vp must be locked when vfs_object_create is called.
2541 */
2542int
2543vfs_object_create(vp, p, cred)
2544 struct vnode *vp;
2545 struct proc *p;
2546 struct ucred *cred;
2547{
2548 return (VOP_CREATEVOBJECT(vp, cred, p));
2549}
2550
2551void
2552vfree(vp)
2553 struct vnode *vp;
2554{
2555 int s;
2556
2557 s = splbio();
2558 simple_lock(&vnode_free_list_slock);
2559 KASSERT((vp->v_flag & VFREE) == 0, ("vnode already free"));
2560 if (vp->v_flag & VAGE) {
2561 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
2562 } else {
2563 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
2564 }
2565 freevnodes++;
2566 simple_unlock(&vnode_free_list_slock);
2567 vp->v_flag &= ~VAGE;
2568 vp->v_flag |= VFREE;
2569 splx(s);
2570}
2571
2572void
2573vbusy(vp)
2574 struct vnode *vp;
2575{
2576 int s;
2577
2578 s = splbio();
2579 simple_lock(&vnode_free_list_slock);
2580 KASSERT((vp->v_flag & VFREE) != 0, ("vnode not free"));
2581 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
2582 freevnodes--;
2583 simple_unlock(&vnode_free_list_slock);
2584 vp->v_flag &= ~(VFREE|VAGE);
2585 splx(s);
2586}
2587
2588/*
2589 * Record a process's interest in events which might happen to
2590 * a vnode. Because poll uses the historic select-style interface
2591 * internally, this routine serves as both the ``check for any
2592 * pending events'' and the ``record my interest in future events''
2593 * functions. (These are done together, while the lock is held,
2594 * to avoid race conditions.)
2595 */
2596int
2597vn_pollrecord(vp, p, events)
2598 struct vnode *vp;
2599 struct proc *p;
2600 short events;
2601{
2602 simple_lock(&vp->v_pollinfo.vpi_lock);
2603 if (vp->v_pollinfo.vpi_revents & events) {
2604 /*
2605 * This leaves events we are not interested
2606 * in available for the other process which
2607 * which presumably had requested them
2608 * (otherwise they would never have been
2609 * recorded).
2610 */
2611 events &= vp->v_pollinfo.vpi_revents;
2612 vp->v_pollinfo.vpi_revents &= ~events;
2613
2614 simple_unlock(&vp->v_pollinfo.vpi_lock);
2615 return events;
2616 }
2617 vp->v_pollinfo.vpi_events |= events;
2618 selrecord(p, &vp->v_pollinfo.vpi_selinfo);
2619 simple_unlock(&vp->v_pollinfo.vpi_lock);
2620 return 0;
2621}
2622
2623/*
2624 * Note the occurrence of an event. If the VN_POLLEVENT macro is used,
2625 * it is possible for us to miss an event due to race conditions, but
2626 * that condition is expected to be rare, so for the moment it is the
2627 * preferred interface.
2628 */
2629void
2630vn_pollevent(vp, events)
2631 struct vnode *vp;
2632 short events;
2633{
2634 simple_lock(&vp->v_pollinfo.vpi_lock);
2635 if (vp->v_pollinfo.vpi_events & events) {
2636 /*
2637 * We clear vpi_events so that we don't
2638 * call selwakeup() twice if two events are
2639 * posted before the polling process(es) is
2640 * awakened. This also ensures that we take at
2641 * most one selwakeup() if the polling process
2642 * is no longer interested. However, it does
2643 * mean that only one event can be noticed at
2644 * a time. (Perhaps we should only clear those
2645 * event bits which we note?) XXX
2646 */
2647 vp->v_pollinfo.vpi_events = 0; /* &= ~events ??? */
2648 vp->v_pollinfo.vpi_revents |= events;
2649 selwakeup(&vp->v_pollinfo.vpi_selinfo);
2650 }
2651 simple_unlock(&vp->v_pollinfo.vpi_lock);
2652}
2653
2654/*
2655 * Wake up anyone polling on vp because it is being revoked.
2656 * This depends on dead_poll() returning POLLHUP for correct
2657 * behavior.
2658 */
2659void
2660vn_pollgone(vp)
2661 struct vnode *vp;
2662{
2663 simple_lock(&vp->v_pollinfo.vpi_lock);
2664 if (vp->v_pollinfo.vpi_events) {
2665 vp->v_pollinfo.vpi_events = 0;
2666 selwakeup(&vp->v_pollinfo.vpi_selinfo);
2667 }
2668 simple_unlock(&vp->v_pollinfo.vpi_lock);
2669}
2670
2671
2672
2673/*
2674 * Routine to create and manage a filesystem syncer vnode.
2675 */
2676#define sync_close ((int (*) __P((struct vop_close_args *)))nullop)
2677static int sync_fsync __P((struct vop_fsync_args *));
2678static int sync_inactive __P((struct vop_inactive_args *));
2679static int sync_reclaim __P((struct vop_reclaim_args *));
2680#define sync_lock ((int (*) __P((struct vop_lock_args *)))vop_nolock)
2681#define sync_unlock ((int (*) __P((struct vop_unlock_args *)))vop_nounlock)
2682static int sync_print __P((struct vop_print_args *));
2683#define sync_islocked ((int(*) __P((struct vop_islocked_args *)))vop_noislocked)
2684
2685static vop_t **sync_vnodeop_p;
2686static struct vnodeopv_entry_desc sync_vnodeop_entries[] = {
2687 { &vop_default_desc, (vop_t *) vop_eopnotsupp },
2688 { &vop_close_desc, (vop_t *) sync_close }, /* close */
2689 { &vop_fsync_desc, (vop_t *) sync_fsync }, /* fsync */
2690 { &vop_inactive_desc, (vop_t *) sync_inactive }, /* inactive */
2691 { &vop_reclaim_desc, (vop_t *) sync_reclaim }, /* reclaim */
2692 { &vop_lock_desc, (vop_t *) sync_lock }, /* lock */
2693 { &vop_unlock_desc, (vop_t *) sync_unlock }, /* unlock */
2694 { &vop_print_desc, (vop_t *) sync_print }, /* print */
2695 { &vop_islocked_desc, (vop_t *) sync_islocked }, /* islocked */
2696 { NULL, NULL }
2697};
2698static struct vnodeopv_desc sync_vnodeop_opv_desc =
2699 { &sync_vnodeop_p, sync_vnodeop_entries };
2700
2701VNODEOP_SET(sync_vnodeop_opv_desc);
2702
2703/*
2704 * Create a new filesystem syncer vnode for the specified mount point.
2705 */
2706int
2707vfs_allocate_syncvnode(mp)
2708 struct mount *mp;
2709{
2710 struct vnode *vp;
2711 static long start, incr, next;
2712 int error;
2713
2714 /* Allocate a new vnode */
2715 if ((error = getnewvnode(VT_VFS, mp, sync_vnodeop_p, &vp)) != 0) {
2716 mp->mnt_syncer = NULL;
2717 return (error);
2718 }
2719 vp->v_type = VNON;
2720 /*
2721 * Place the vnode onto the syncer worklist. We attempt to
2722 * scatter them about on the list so that they will go off
2723 * at evenly distributed times even if all the filesystems
2724 * are mounted at once.
2725 */
2726 next += incr;
2727 if (next == 0 || next > syncer_maxdelay) {
2728 start /= 2;
2729 incr /= 2;
2730 if (start == 0) {
2731 start = syncer_maxdelay / 2;
2732 incr = syncer_maxdelay;
2733 }
2734 next = start;
2735 }
2736 vn_syncer_add_to_worklist(vp, syncdelay > 0 ? next % syncdelay : 0);
2737 mp->mnt_syncer = vp;
2738 return (0);
2739}
2740
2741/*
2742 * Do a lazy sync of the filesystem.
2743 */
2744static int
2745sync_fsync(ap)
2746 struct vop_fsync_args /* {
2747 struct vnode *a_vp;
2748 struct ucred *a_cred;
2749 int a_waitfor;
2750 struct proc *a_p;
2751 } */ *ap;
2752{
2753 struct vnode *syncvp = ap->a_vp;
2754 struct mount *mp = syncvp->v_mount;
2755 struct proc *p = ap->a_p;
2756 int asyncflag;
2757
2758 /*
2759 * We only need to do something if this is a lazy evaluation.
2760 */
2761 if (ap->a_waitfor != MNT_LAZY)
2762 return (0);
2763
2764 /*
2765 * Move ourselves to the back of the sync list.
2766 */
2767 vn_syncer_add_to_worklist(syncvp, syncdelay);
2768
2769 /*
2770 * Walk the list of vnodes pushing all that are dirty and
2771 * not already on the sync list.
2772 */
2773 simple_lock(&mountlist_slock);
2774 if (vfs_busy(mp, LK_EXCLUSIVE | LK_NOWAIT, &mountlist_slock, p) != 0) {
2775 simple_unlock(&mountlist_slock);
2776 return (0);
2777 }
2778 if (vn_start_write(NULL, &mp, V_NOWAIT) != 0) {
2779 vfs_unbusy(mp, p);
2780 simple_unlock(&mountlist_slock);
2781 return (0);
2782 }
2783 asyncflag = mp->mnt_flag & MNT_ASYNC;
2784 mp->mnt_flag &= ~MNT_ASYNC;
2785 vfs_msync(mp, MNT_NOWAIT);
2786 VFS_SYNC(mp, MNT_LAZY, ap->a_cred, p);
2787 if (asyncflag)
2788 mp->mnt_flag |= MNT_ASYNC;
2789 vn_finished_write(mp);
2790 vfs_unbusy(mp, p);
2791 return (0);
2792}
2793
2794/*
2795 * The syncer vnode is no referenced.
2796 */
2797static int
2798sync_inactive(ap)
2799 struct vop_inactive_args /* {
2800 struct vnode *a_vp;
2801 struct proc *a_p;
2802 } */ *ap;
2803{
2804
2805 vgone(ap->a_vp);
2806 return (0);
2807}
2808
2809/*
2810 * The syncer vnode is no longer needed and is being decommissioned.
2811 *
2812 * Modifications to the worklist must be protected at splbio().
2813 */
2814static int
2815sync_reclaim(ap)
2816 struct vop_reclaim_args /* {
2817 struct vnode *a_vp;
2818 } */ *ap;
2819{
2820 struct vnode *vp = ap->a_vp;
2821 int s;
2822
2823 s = splbio();
2824 vp->v_mount->mnt_syncer = NULL;
2825 if (vp->v_flag & VONWORKLST) {
2826 LIST_REMOVE(vp, v_synclist);
2827 vp->v_flag &= ~VONWORKLST;
2828 }
2829 splx(s);
2830
2831 return (0);
2832}
2833
2834/*
2835 * Print out a syncer vnode.
2836 */
2837static int
2838sync_print(ap)
2839 struct vop_print_args /* {
2840 struct vnode *a_vp;
2841 } */ *ap;
2842{
2843 struct vnode *vp = ap->a_vp;
2844
2845 printf("syncer vnode");
2846 if (vp->v_vnlock != NULL)
2847 lockmgr_printinfo(vp->v_vnlock);
2848 printf("\n");
2849 return (0);
2850}
2851
2852/*
2853 * extract the dev_t from a VBLK or VCHR
2854 */
2855dev_t
2856vn_todev(vp)
2857 struct vnode *vp;
2858{
2859 if (vp->v_type != VBLK && vp->v_type != VCHR)
2860 return (NODEV);
2861 return (vp->v_rdev);
2862}
2863
2864/*
2865 * Check if vnode represents a disk device
2866 */
2867int
2868vn_isdisk(vp, errp)
2869 struct vnode *vp;
2870 int *errp;
2871{
2872 struct cdevsw *cdevsw;
2873
2874 if (vp->v_type != VBLK && vp->v_type != VCHR) {
2875 if (errp != NULL)
2876 *errp = ENOTBLK;
2877 return (0);
2878 }
2879 if (vp->v_rdev == NULL) {
2880 if (errp != NULL)
2881 *errp = ENXIO;
2882 return (0);
2883 }
2884 cdevsw = devsw(vp->v_rdev);
2885 if (cdevsw == NULL) {
2886 if (errp != NULL)
2887 *errp = ENXIO;
2888 return (0);
2889 }
2890 if (!(cdevsw->d_flags & D_DISK)) {
2891 if (errp != NULL)
2892 *errp = ENOTBLK;
2893 return (0);
2894 }
2895 if (errp != NULL)
2896 *errp = 0;
2897 return (1);
2898}
2899
2900void
2901NDFREE(ndp, flags)
2902 struct nameidata *ndp;
2903 const uint flags;
2904{
2905 if (!(flags & NDF_NO_FREE_PNBUF) &&
2906 (ndp->ni_cnd.cn_flags & HASBUF)) {
2907 zfree(namei_zone, ndp->ni_cnd.cn_pnbuf);
2908 ndp->ni_cnd.cn_flags &= ~HASBUF;
2909 }
2910 if (!(flags & NDF_NO_DVP_UNLOCK) &&
2911 (ndp->ni_cnd.cn_flags & LOCKPARENT) &&
2912 ndp->ni_dvp != ndp->ni_vp)
2913 VOP_UNLOCK(ndp->ni_dvp, 0, ndp->ni_cnd.cn_proc);
2914 if (!(flags & NDF_NO_DVP_RELE) &&
2915 (ndp->ni_cnd.cn_flags & (LOCKPARENT|WANTPARENT))) {
2916 vrele(ndp->ni_dvp);
2917 ndp->ni_dvp = NULL;
2918 }
2919 if (!(flags & NDF_NO_VP_UNLOCK) &&
2920 (ndp->ni_cnd.cn_flags & LOCKLEAF) && ndp->ni_vp)
2921 VOP_UNLOCK(ndp->ni_vp, 0, ndp->ni_cnd.cn_proc);
2922 if (!(flags & NDF_NO_VP_RELE) &&
2923 ndp->ni_vp) {
2924 vrele(ndp->ni_vp);
2925 ndp->ni_vp = NULL;
2926 }
2927 if (!(flags & NDF_NO_STARTDIR_RELE) &&
2928 (ndp->ni_cnd.cn_flags & SAVESTART)) {
2929 vrele(ndp->ni_startdir);
2930 ndp->ni_startdir = NULL;
2931 }
2932}
2933
2934int
2935vaccess(type, file_mode, file_uid, file_gid, acc_mode, cred, privused)
2936 enum vtype type;
2937 mode_t file_mode;
2938 uid_t file_uid;
2939 gid_t file_gid;
2940 mode_t acc_mode;
2941 struct ucred *cred;
2942 int *privused;
2943{
2944 mode_t dac_granted;
2945#ifdef CAPABILITIES
2946 mode_t cap_granted;
2947#endif
2948
2949 /*
2950 * Look for a normal, non-privileged way to access the file/directory
2951 * as requested. If it exists, go with that.
2952 */
2953
2954 if (privused != NULL)
2955 *privused = 0;
2956
2957 dac_granted = 0;
2958
2959 /* Check the owner. */
2960 if (cred->cr_uid == file_uid) {
2961 if (file_mode & S_IXUSR)
2962 dac_granted |= VEXEC;
2963 if (file_mode & S_IRUSR)
2964 dac_granted |= VREAD;
2965 if (file_mode & S_IWUSR)
2966 dac_granted |= VWRITE;
2967
2968 if ((acc_mode & dac_granted) == acc_mode)
2969 return (0);
2970
2971 goto privcheck;
2972 }
2973
2974 /* Otherwise, check the groups (first match) */
2975 if (groupmember(file_gid, cred)) {
2976 if (file_mode & S_IXGRP)
2977 dac_granted |= VEXEC;
2978 if (file_mode & S_IRGRP)
2979 dac_granted |= VREAD;
2980 if (file_mode & S_IWGRP)
2981 dac_granted |= VWRITE;
2982
2983 if ((acc_mode & dac_granted) == acc_mode)
2984 return (0);
2985
2986 goto privcheck;
2987 }
2988
2989 /* Otherwise, check everyone else. */
2990 if (file_mode & S_IXOTH)
2991 dac_granted |= VEXEC;
2992 if (file_mode & S_IROTH)
2993 dac_granted |= VREAD;
2994 if (file_mode & S_IWOTH)
2995 dac_granted |= VWRITE;
2996 if ((acc_mode & dac_granted) == acc_mode)
2997 return (0);
2998
2999privcheck:
3000 if (!suser_xxx(cred, NULL, PRISON_ROOT)) {
3001 /* XXX audit: privilege used */
3002 if (privused != NULL)
3003 *privused = 1;
3004 return (0);
3005 }
3006
3007#ifdef CAPABILITIES
3008 /*
3009 * Build a capability mask to determine if the set of capabilities
3010 * satisfies the requirements when combined with the granted mask
3011 * from above.
3012 * For each capability, if the capability is required, bitwise
3013 * or the request type onto the cap_granted mask.
3014 */
3015 cap_granted = 0;
3016 if ((acc_mode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
3017 !cap_check_xxx(cred, NULL, CAP_DAC_EXECUTE, PRISON_ROOT))
3018 cap_granted |= VEXEC;
3019
3020 if ((acc_mode & VREAD) && ((dac_granted & VREAD) == 0) &&
3021 !cap_check_xxx(cred, NULL, CAP_DAC_READ_SEARCH, PRISON_ROOT))
3022 cap_granted |= VREAD;
3023
3024 if ((acc_mode & VWRITE) && ((dac_granted & VWRITE) == 0) &&
3025 !cap_check_xxx(cred, NULL, CAP_DAC_WRITE, PRISON_ROOT))
3026 cap_granted |= VWRITE;
3027
3028 if ((acc_mode & (cap_granted | dac_granted)) == acc_mode) {
3029 /* XXX audit: privilege used */
3030 if (privused != NULL)
3031 *privused = 1;
3032 return (0);
3033 }
3034#endif
3035
3036 return (EACCES);
3037}
|