vfs_default.c revision 193092 
1/*-
2 * Copyright (c) 1989, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * This code is derived from software contributed
6 * to Berkeley by John Heidemann of the UCLA Ficus project.
7 *
8 * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 * 4. Neither the name of the University nor the names of its contributors
19 *    may be used to endorse or promote products derived from this software
20 *    without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35#include <sys/cdefs.h>
36__FBSDID("$FreeBSD: head/sys/kern/vfs_default.c 193092 2009-05-30 13:59:05Z trasz $");
37
38#include <sys/param.h>
39#include <sys/systm.h>
40#include <sys/bio.h>
41#include <sys/buf.h>
42#include <sys/conf.h>
43#include <sys/event.h>
44#include <sys/kernel.h>
45#include <sys/limits.h>
46#include <sys/lock.h>
47#include <sys/lockf.h>
48#include <sys/malloc.h>
49#include <sys/mount.h>
50#include <sys/mutex.h>
51#include <sys/namei.h>
52#include <sys/fcntl.h>
53#include <sys/unistd.h>
54#include <sys/vnode.h>
55#include <sys/dirent.h>
56#include <sys/poll.h>
57
58#include <vm/vm.h>
59#include <vm/vm_object.h>
60#include <vm/vm_extern.h>
61#include <vm/pmap.h>
62#include <vm/vm_map.h>
63#include <vm/vm_page.h>
64#include <vm/vm_pager.h>
65#include <vm/vnode_pager.h>
66
67static int	vop_nolookup(struct vop_lookup_args *);
68static int	vop_nostrategy(struct vop_strategy_args *);
69static int	get_next_dirent(struct vnode *vp, struct dirent **dpp,
70				char *dirbuf, int dirbuflen, off_t *off,
71				char **cpos, int *len, int *eofflag,
72				struct thread *td);
73static int	dirent_exists(struct vnode *vp, const char *dirname,
74			      struct thread *td);
75
76#define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4)
77
78/*
79 * This vnode table stores what we want to do if the filesystem doesn't
80 * implement a particular VOP.
81 *
82 * If there is no specific entry here, we will return EOPNOTSUPP.
83 *
84 */
85
86struct vop_vector default_vnodeops = {
87	.vop_default =		NULL,
88	.vop_bypass =		VOP_EOPNOTSUPP,
89
90	.vop_accessx =		vop_stdaccessx,
91	.vop_advlock =		vop_stdadvlock,
92	.vop_advlockasync =	vop_stdadvlockasync,
93	.vop_bmap =		vop_stdbmap,
94	.vop_close =		VOP_NULL,
95	.vop_fsync =		VOP_NULL,
96	.vop_getpages =		vop_stdgetpages,
97	.vop_getwritemount = 	vop_stdgetwritemount,
98	.vop_inactive =		VOP_NULL,
99	.vop_ioctl =		VOP_ENOTTY,
100	.vop_kqfilter =		vop_stdkqfilter,
101	.vop_islocked =		vop_stdislocked,
102	.vop_lock1 =		vop_stdlock,
103	.vop_lookup =		vop_nolookup,
104	.vop_open =		VOP_NULL,
105	.vop_pathconf =		VOP_EINVAL,
106	.vop_poll =		vop_nopoll,
107	.vop_putpages =		vop_stdputpages,
108	.vop_readlink =		VOP_EINVAL,
109	.vop_revoke =		VOP_PANIC,
110	.vop_strategy =		vop_nostrategy,
111	.vop_unlock =		vop_stdunlock,
112	.vop_vptocnp =		vop_stdvptocnp,
113	.vop_vptofh =		vop_stdvptofh,
114};
115
116/*
117 * Series of placeholder functions for various error returns for
118 * VOPs.
119 */
120
121int
122vop_eopnotsupp(struct vop_generic_args *ap)
123{
124	/*
125	printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name);
126	*/
127
128	return (EOPNOTSUPP);
129}
130
131int
132vop_ebadf(struct vop_generic_args *ap)
133{
134
135	return (EBADF);
136}
137
138int
139vop_enotty(struct vop_generic_args *ap)
140{
141
142	return (ENOTTY);
143}
144
145int
146vop_einval(struct vop_generic_args *ap)
147{
148
149	return (EINVAL);
150}
151
152int
153vop_enoent(struct vop_generic_args *ap)
154{
155
156	return (ENOENT);
157}
158
159int
160vop_null(struct vop_generic_args *ap)
161{
162
163	return (0);
164}
165
166/*
167 * Helper function to panic on some bad VOPs in some filesystems.
168 */
169int
170vop_panic(struct vop_generic_args *ap)
171{
172
173	panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
174}
175
176/*
177 * vop_std<something> and vop_no<something> are default functions for use by
178 * filesystems that need the "default reasonable" implementation for a
179 * particular operation.
180 *
181 * The documentation for the operations they implement exists (if it exists)
182 * in the VOP_<SOMETHING>(9) manpage (all uppercase).
183 */
184
185/*
186 * Default vop for filesystems that do not support name lookup
187 */
188static int
189vop_nolookup(ap)
190	struct vop_lookup_args /* {
191		struct vnode *a_dvp;
192		struct vnode **a_vpp;
193		struct componentname *a_cnp;
194	} */ *ap;
195{
196
197	*ap->a_vpp = NULL;
198	return (ENOTDIR);
199}
200
201/*
202 *	vop_nostrategy:
203 *
204 *	Strategy routine for VFS devices that have none.
205 *
206 *	BIO_ERROR and B_INVAL must be cleared prior to calling any strategy
207 *	routine.  Typically this is done for a BIO_READ strategy call.
208 *	Typically B_INVAL is assumed to already be clear prior to a write
209 *	and should not be cleared manually unless you just made the buffer
210 *	invalid.  BIO_ERROR should be cleared either way.
211 */
212
213static int
214vop_nostrategy (struct vop_strategy_args *ap)
215{
216	printf("No strategy for buffer at %p\n", ap->a_bp);
217	vprint("vnode", ap->a_vp);
218	ap->a_bp->b_ioflags |= BIO_ERROR;
219	ap->a_bp->b_error = EOPNOTSUPP;
220	bufdone(ap->a_bp);
221	return (EOPNOTSUPP);
222}
223
224static int
225get_next_dirent(struct vnode *vp, struct dirent **dpp, char *dirbuf,
226		int dirbuflen, off_t *off, char **cpos, int *len,
227		int *eofflag, struct thread *td)
228{
229	int error, reclen;
230	struct uio uio;
231	struct iovec iov;
232	struct dirent *dp;
233
234	KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
235	KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
236
237	if (*len == 0) {
238		iov.iov_base = dirbuf;
239		iov.iov_len = dirbuflen;
240
241		uio.uio_iov = &iov;
242		uio.uio_iovcnt = 1;
243		uio.uio_offset = *off;
244		uio.uio_resid = dirbuflen;
245		uio.uio_segflg = UIO_SYSSPACE;
246		uio.uio_rw = UIO_READ;
247		uio.uio_td = td;
248
249		*eofflag = 0;
250
251#ifdef MAC
252		error = mac_vnode_check_readdir(td->td_ucred, vp);
253		if (error == 0)
254#endif
255			error = VOP_READDIR(vp, &uio, td->td_ucred, eofflag,
256		    		NULL, NULL);
257		if (error)
258			return (error);
259
260		*off = uio.uio_offset;
261
262		*cpos = dirbuf;
263		*len = (dirbuflen - uio.uio_resid);
264	}
265
266	dp = (struct dirent *)(*cpos);
267	reclen = dp->d_reclen;
268	*dpp = dp;
269
270	/* check for malformed directory.. */
271	if (reclen < DIRENT_MINSIZE)
272		return (EINVAL);
273
274	*cpos += reclen;
275	*len -= reclen;
276
277	return (0);
278}
279
280/*
281 * Check if a named file exists in a given directory vnode.
282 */
283static int
284dirent_exists(struct vnode *vp, const char *dirname, struct thread *td)
285{
286	char *dirbuf, *cpos;
287	int error, eofflag, dirbuflen, len, found;
288	off_t off;
289	struct dirent *dp;
290	struct vattr va;
291
292	KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
293	KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
294
295	found = 0;
296
297	error = VOP_GETATTR(vp, &va, td->td_ucred);
298	if (error)
299		return (found);
300
301	dirbuflen = DEV_BSIZE;
302	if (dirbuflen < va.va_blocksize)
303		dirbuflen = va.va_blocksize;
304	dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
305
306	off = 0;
307	len = 0;
308	do {
309		error = get_next_dirent(vp, &dp, dirbuf, dirbuflen, &off,
310					&cpos, &len, &eofflag, td);
311		if (error)
312			goto out;
313
314		if ((dp->d_type != DT_WHT) &&
315		    !strcmp(dp->d_name, dirname)) {
316			found = 1;
317			goto out;
318		}
319	} while (len > 0 || !eofflag);
320
321out:
322	free(dirbuf, M_TEMP);
323	return (found);
324}
325
326int
327vop_stdaccessx(struct vop_accessx_args *ap)
328{
329	int error;
330	accmode_t accmode = ap->a_accmode;
331
332	error = vfs_unixify_accmode(&accmode);
333	if (error != 0)
334		return (error);
335
336	if (accmode == 0)
337		return (0);
338
339	return (VOP_ACCESS(ap->a_vp, accmode, ap->a_cred, ap->a_td));
340}
341
342/*
343 * Advisory record locking support
344 */
345int
346vop_stdadvlock(struct vop_advlock_args *ap)
347{
348	struct vnode *vp;
349	struct ucred *cred;
350	struct vattr vattr;
351	int error;
352
353	vp = ap->a_vp;
354	cred = curthread->td_ucred;
355	vn_lock(vp, LK_SHARED | LK_RETRY);
356	error = VOP_GETATTR(vp, &vattr, cred);
357	VOP_UNLOCK(vp, 0);
358	if (error)
359		return (error);
360
361	return (lf_advlock(ap, &(vp->v_lockf), vattr.va_size));
362}
363
364int
365vop_stdadvlockasync(struct vop_advlockasync_args *ap)
366{
367	struct vnode *vp;
368	struct ucred *cred;
369	struct vattr vattr;
370	int error;
371
372	vp = ap->a_vp;
373	cred = curthread->td_ucred;
374	vn_lock(vp, LK_SHARED | LK_RETRY);
375	error = VOP_GETATTR(vp, &vattr, cred);
376	VOP_UNLOCK(vp, 0);
377	if (error)
378		return (error);
379
380	return (lf_advlockasync(ap, &(vp->v_lockf), vattr.va_size));
381}
382
383/*
384 * vop_stdpathconf:
385 *
386 * Standard implementation of POSIX pathconf, to get information about limits
387 * for a filesystem.
388 * Override per filesystem for the case where the filesystem has smaller
389 * limits.
390 */
391int
392vop_stdpathconf(ap)
393	struct vop_pathconf_args /* {
394	struct vnode *a_vp;
395	int a_name;
396	int *a_retval;
397	} */ *ap;
398{
399
400	switch (ap->a_name) {
401		case _PC_NAME_MAX:
402			*ap->a_retval = NAME_MAX;
403			return (0);
404		case _PC_PATH_MAX:
405			*ap->a_retval = PATH_MAX;
406			return (0);
407		case _PC_LINK_MAX:
408			*ap->a_retval = LINK_MAX;
409			return (0);
410		case _PC_MAX_CANON:
411			*ap->a_retval = MAX_CANON;
412			return (0);
413		case _PC_MAX_INPUT:
414			*ap->a_retval = MAX_INPUT;
415			return (0);
416		case _PC_PIPE_BUF:
417			*ap->a_retval = PIPE_BUF;
418			return (0);
419		case _PC_CHOWN_RESTRICTED:
420			*ap->a_retval = 1;
421			return (0);
422		case _PC_VDISABLE:
423			*ap->a_retval = _POSIX_VDISABLE;
424			return (0);
425		default:
426			return (EINVAL);
427	}
428	/* NOTREACHED */
429}
430
431/*
432 * Standard lock, unlock and islocked functions.
433 */
434int
435vop_stdlock(ap)
436	struct vop_lock1_args /* {
437		struct vnode *a_vp;
438		int a_flags;
439		char *file;
440		int line;
441	} */ *ap;
442{
443	struct vnode *vp = ap->a_vp;
444
445	return (_lockmgr_args(vp->v_vnlock, ap->a_flags, VI_MTX(vp),
446	    LK_WMESG_DEFAULT, LK_PRIO_DEFAULT, LK_TIMO_DEFAULT, ap->a_file,
447	    ap->a_line));
448}
449
450/* See above. */
451int
452vop_stdunlock(ap)
453	struct vop_unlock_args /* {
454		struct vnode *a_vp;
455		int a_flags;
456	} */ *ap;
457{
458	struct vnode *vp = ap->a_vp;
459
460	return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE, VI_MTX(vp)));
461}
462
463/* See above. */
464int
465vop_stdislocked(ap)
466	struct vop_islocked_args /* {
467		struct vnode *a_vp;
468	} */ *ap;
469{
470
471	return (lockstatus(ap->a_vp->v_vnlock));
472}
473
474/*
475 * Return true for select/poll.
476 */
477int
478vop_nopoll(ap)
479	struct vop_poll_args /* {
480		struct vnode *a_vp;
481		int  a_events;
482		struct ucred *a_cred;
483		struct thread *a_td;
484	} */ *ap;
485{
486
487	return (poll_no_poll(ap->a_events));
488}
489
490/*
491 * Implement poll for local filesystems that support it.
492 */
493int
494vop_stdpoll(ap)
495	struct vop_poll_args /* {
496		struct vnode *a_vp;
497		int  a_events;
498		struct ucred *a_cred;
499		struct thread *a_td;
500	} */ *ap;
501{
502	if (ap->a_events & ~POLLSTANDARD)
503		return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
504	return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
505}
506
507/*
508 * Return our mount point, as we will take charge of the writes.
509 */
510int
511vop_stdgetwritemount(ap)
512	struct vop_getwritemount_args /* {
513		struct vnode *a_vp;
514		struct mount **a_mpp;
515	} */ *ap;
516{
517	struct mount *mp;
518
519	/*
520	 * XXX Since this is called unlocked we may be recycled while
521	 * attempting to ref the mount.  If this is the case or mountpoint
522	 * will be set to NULL.  We only have to prevent this call from
523	 * returning with a ref to an incorrect mountpoint.  It is not
524	 * harmful to return with a ref to our previous mountpoint.
525	 */
526	mp = ap->a_vp->v_mount;
527	if (mp != NULL) {
528		vfs_ref(mp);
529		if (mp != ap->a_vp->v_mount) {
530			vfs_rel(mp);
531			mp = NULL;
532		}
533	}
534	*(ap->a_mpp) = mp;
535	return (0);
536}
537
538/* XXX Needs good comment and VOP_BMAP(9) manpage */
539int
540vop_stdbmap(ap)
541	struct vop_bmap_args /* {
542		struct vnode *a_vp;
543		daddr_t  a_bn;
544		struct bufobj **a_bop;
545		daddr_t *a_bnp;
546		int *a_runp;
547		int *a_runb;
548	} */ *ap;
549{
550
551	if (ap->a_bop != NULL)
552		*ap->a_bop = &ap->a_vp->v_bufobj;
553	if (ap->a_bnp != NULL)
554		*ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize);
555	if (ap->a_runp != NULL)
556		*ap->a_runp = 0;
557	if (ap->a_runb != NULL)
558		*ap->a_runb = 0;
559	return (0);
560}
561
562int
563vop_stdfsync(ap)
564	struct vop_fsync_args /* {
565		struct vnode *a_vp;
566		struct ucred *a_cred;
567		int a_waitfor;
568		struct thread *a_td;
569	} */ *ap;
570{
571	struct vnode *vp = ap->a_vp;
572	struct buf *bp;
573	struct bufobj *bo;
574	struct buf *nbp;
575	int error = 0;
576	int maxretry = 1000;     /* large, arbitrarily chosen */
577
578	bo = &vp->v_bufobj;
579	BO_LOCK(bo);
580loop1:
581	/*
582	 * MARK/SCAN initialization to avoid infinite loops.
583	 */
584        TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs) {
585                bp->b_vflags &= ~BV_SCANNED;
586		bp->b_error = 0;
587	}
588
589	/*
590	 * Flush all dirty buffers associated with a vnode.
591	 */
592loop2:
593	TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
594		if ((bp->b_vflags & BV_SCANNED) != 0)
595			continue;
596		bp->b_vflags |= BV_SCANNED;
597		if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL))
598			continue;
599		BO_UNLOCK(bo);
600		KASSERT(bp->b_bufobj == bo,
601		    ("bp %p wrong b_bufobj %p should be %p",
602		    bp, bp->b_bufobj, bo));
603		if ((bp->b_flags & B_DELWRI) == 0)
604			panic("fsync: not dirty");
605		if ((vp->v_object != NULL) && (bp->b_flags & B_CLUSTEROK)) {
606			vfs_bio_awrite(bp);
607		} else {
608			bremfree(bp);
609			bawrite(bp);
610		}
611		BO_LOCK(bo);
612		goto loop2;
613	}
614
615	/*
616	 * If synchronous the caller expects us to completely resolve all
617	 * dirty buffers in the system.  Wait for in-progress I/O to
618	 * complete (which could include background bitmap writes), then
619	 * retry if dirty blocks still exist.
620	 */
621	if (ap->a_waitfor == MNT_WAIT) {
622		bufobj_wwait(bo, 0, 0);
623		if (bo->bo_dirty.bv_cnt > 0) {
624			/*
625			 * If we are unable to write any of these buffers
626			 * then we fail now rather than trying endlessly
627			 * to write them out.
628			 */
629			TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
630				if ((error = bp->b_error) == 0)
631					continue;
632			if (error == 0 && --maxretry >= 0)
633				goto loop1;
634			error = EAGAIN;
635		}
636	}
637	BO_UNLOCK(bo);
638	if (error == EAGAIN)
639		vprint("fsync: giving up on dirty", vp);
640
641	return (error);
642}
643
644/* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */
645int
646vop_stdgetpages(ap)
647	struct vop_getpages_args /* {
648		struct vnode *a_vp;
649		vm_page_t *a_m;
650		int a_count;
651		int a_reqpage;
652		vm_ooffset_t a_offset;
653	} */ *ap;
654{
655
656	return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
657	    ap->a_count, ap->a_reqpage);
658}
659
660int
661vop_stdkqfilter(struct vop_kqfilter_args *ap)
662{
663	return vfs_kqfilter(ap);
664}
665
666/* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */
667int
668vop_stdputpages(ap)
669	struct vop_putpages_args /* {
670		struct vnode *a_vp;
671		vm_page_t *a_m;
672		int a_count;
673		int a_sync;
674		int *a_rtvals;
675		vm_ooffset_t a_offset;
676	} */ *ap;
677{
678
679	return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
680	     ap->a_sync, ap->a_rtvals);
681}
682
683int
684vop_stdvptofh(struct vop_vptofh_args *ap)
685{
686	return (EOPNOTSUPP);
687}
688
689int
690vop_stdvptocnp(struct vop_vptocnp_args *ap)
691{
692	struct vnode *vp = ap->a_vp;
693	struct vnode **dvp = ap->a_vpp;
694	char *buf = ap->a_buf;
695	int *buflen = ap->a_buflen;
696	char *dirbuf, *cpos;
697	int i, error, eofflag, dirbuflen, flags, locked, len, covered;
698	off_t off;
699	ino_t fileno;
700	struct vattr va;
701	struct nameidata nd;
702	struct thread *td;
703	struct dirent *dp;
704	struct vnode *mvp;
705
706	i = *buflen;
707	error = 0;
708	covered = 0;
709	td = curthread;
710
711	if (vp->v_type != VDIR)
712		return (ENOENT);
713
714	error = VOP_GETATTR(vp, &va, td->td_ucred);
715	if (error)
716		return (error);
717
718	VREF(vp);
719	locked = VOP_ISLOCKED(vp);
720	VOP_UNLOCK(vp, 0);
721	NDINIT_ATVP(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
722	    "..", vp, td);
723	flags = FREAD;
724	error = vn_open(&nd, &flags, 0, NULL);
725	if (error) {
726		vn_lock(vp, locked | LK_RETRY);
727		return (error);
728	}
729	NDFREE(&nd, NDF_ONLY_PNBUF);
730
731	mvp = *dvp = nd.ni_vp;
732
733	if (vp->v_mount != (*dvp)->v_mount &&
734	    ((*dvp)->v_vflag & VV_ROOT) &&
735	    ((*dvp)->v_mount->mnt_flag & MNT_UNION)) {
736		*dvp = (*dvp)->v_mount->mnt_vnodecovered;
737		VREF(mvp);
738		VOP_UNLOCK(mvp, 0);
739		vn_close(mvp, FREAD, td->td_ucred, td);
740		VREF(*dvp);
741		vn_lock(*dvp, LK_EXCLUSIVE | LK_RETRY);
742		covered = 1;
743	}
744
745	fileno = va.va_fileid;
746
747	dirbuflen = DEV_BSIZE;
748	if (dirbuflen < va.va_blocksize)
749		dirbuflen = va.va_blocksize;
750	dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
751
752	if ((*dvp)->v_type != VDIR) {
753		error = ENOENT;
754		goto out;
755	}
756
757	off = 0;
758	len = 0;
759	do {
760		/* call VOP_READDIR of parent */
761		error = get_next_dirent(*dvp, &dp, dirbuf, dirbuflen, &off,
762					&cpos, &len, &eofflag, td);
763		if (error)
764			goto out;
765
766		if ((dp->d_type != DT_WHT) &&
767		    (dp->d_fileno == fileno)) {
768			if (covered) {
769				VOP_UNLOCK(*dvp, 0);
770				vn_lock(mvp, LK_EXCLUSIVE | LK_RETRY);
771				if (dirent_exists(mvp, dp->d_name, td)) {
772					error = ENOENT;
773					VOP_UNLOCK(mvp, 0);
774					vn_lock(*dvp, LK_EXCLUSIVE | LK_RETRY);
775					goto out;
776				}
777				VOP_UNLOCK(mvp, 0);
778				vn_lock(*dvp, LK_EXCLUSIVE | LK_RETRY);
779			}
780			i -= dp->d_namlen;
781
782			if (i < 0) {
783				error = ENOMEM;
784				goto out;
785			}
786			bcopy(dp->d_name, buf + i, dp->d_namlen);
787			error = 0;
788			goto out;
789		}
790	} while (len > 0 || !eofflag);
791	error = ENOENT;
792
793out:
794	free(dirbuf, M_TEMP);
795	if (!error) {
796		*buflen = i;
797		vhold(*dvp);
798	}
799	if (covered) {
800		vput(*dvp);
801		vrele(mvp);
802	} else {
803		VOP_UNLOCK(mvp, 0);
804		vn_close(mvp, FREAD, td->td_ucred, td);
805	}
806	vn_lock(vp, locked | LK_RETRY);
807	return (error);
808}
809
810/*
811 * vfs default ops
812 * used to fill the vfs function table to get reasonable default return values.
813 */
814int
815vfs_stdroot (mp, flags, vpp)
816	struct mount *mp;
817	int flags;
818	struct vnode **vpp;
819{
820
821	return (EOPNOTSUPP);
822}
823
824int
825vfs_stdstatfs (mp, sbp)
826	struct mount *mp;
827	struct statfs *sbp;
828{
829
830	return (EOPNOTSUPP);
831}
832
833int
834vfs_stdquotactl (mp, cmds, uid, arg)
835	struct mount *mp;
836	int cmds;
837	uid_t uid;
838	void *arg;
839{
840
841	return (EOPNOTSUPP);
842}
843
844int
845vfs_stdsync(mp, waitfor)
846	struct mount *mp;
847	int waitfor;
848{
849	struct vnode *vp, *mvp;
850	struct thread *td;
851	int error, lockreq, allerror = 0;
852
853	td = curthread;
854	lockreq = LK_EXCLUSIVE | LK_INTERLOCK;
855	if (waitfor != MNT_WAIT)
856		lockreq |= LK_NOWAIT;
857	/*
858	 * Force stale buffer cache information to be flushed.
859	 */
860	MNT_ILOCK(mp);
861loop:
862	MNT_VNODE_FOREACH(vp, mp, mvp) {
863		/* bv_cnt is an acceptable race here. */
864		if (vp->v_bufobj.bo_dirty.bv_cnt == 0)
865			continue;
866		VI_LOCK(vp);
867		MNT_IUNLOCK(mp);
868		if ((error = vget(vp, lockreq, td)) != 0) {
869			MNT_ILOCK(mp);
870			if (error == ENOENT) {
871				MNT_VNODE_FOREACH_ABORT_ILOCKED(mp, mvp);
872				goto loop;
873			}
874			continue;
875		}
876		error = VOP_FSYNC(vp, waitfor, td);
877		if (error)
878			allerror = error;
879
880		/* Do not turn this into vput.  td is not always curthread. */
881		VOP_UNLOCK(vp, 0);
882		vrele(vp);
883		MNT_ILOCK(mp);
884	}
885	MNT_IUNLOCK(mp);
886	return (allerror);
887}
888
889int
890vfs_stdnosync (mp, waitfor)
891	struct mount *mp;
892	int waitfor;
893{
894
895	return (0);
896}
897
898int
899vfs_stdvget (mp, ino, flags, vpp)
900	struct mount *mp;
901	ino_t ino;
902	int flags;
903	struct vnode **vpp;
904{
905
906	return (EOPNOTSUPP);
907}
908
909int
910vfs_stdfhtovp (mp, fhp, vpp)
911	struct mount *mp;
912	struct fid *fhp;
913	struct vnode **vpp;
914{
915
916	return (EOPNOTSUPP);
917}
918
919int
920vfs_stdinit (vfsp)
921	struct vfsconf *vfsp;
922{
923
924	return (0);
925}
926
927int
928vfs_stduninit (vfsp)
929	struct vfsconf *vfsp;
930{
931
932	return(0);
933}
934
935int
936vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname)
937	struct mount *mp;
938	int cmd;
939	struct vnode *filename_vp;
940	int attrnamespace;
941	const char *attrname;
942{
943
944	if (filename_vp != NULL)
945		VOP_UNLOCK(filename_vp, 0);
946	return (EOPNOTSUPP);
947}
948
949int
950vfs_stdsysctl(mp, op, req)
951	struct mount *mp;
952	fsctlop_t op;
953	struct sysctl_req *req;
954{
955
956	return (EOPNOTSUPP);
957}
958
959/* end of vfs default ops */
960