kernel - Add trigger_syncer(), VFS_MODIFYING()
[dragonfly.git] / sys / kern / vfs_default.c
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  * The statvfs->statfs conversion code was contributed to the DragonFly
9  * Project by Joerg Sonnenberger <joerg@bec.de>.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. Neither the name of the University nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  *
35  * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
36  * $FreeBSD: src/sys/kern/vfs_default.c,v 1.28.2.7 2003/01/10 18:23:26 bde Exp $
37  */
38
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/buf.h>
42 #include <sys/conf.h>
43 #include <sys/fcntl.h>
44 #include <sys/file.h>
45 #include <sys/kernel.h>
46 #include <sys/lock.h>
47 #include <sys/malloc.h>
48 #include <sys/mount.h>
49 #include <sys/unistd.h>
50 #include <sys/vnode.h>
51 #include <sys/namei.h>
52 #include <sys/nlookup.h>
53 #include <sys/mountctl.h>
54 #include <sys/vfs_quota.h>
55
56 #include <machine/limits.h>
57
58 #include <vm/vm.h>
59 #include <vm/vm_object.h>
60 #include <vm/vm_page.h>
61 #include <vm/vm_pager.h>
62 #include <vm/vnode_pager.h>
63
64 static int      vop_nolookup (struct vop_old_lookup_args *);
65 static int      vop_nostrategy (struct vop_strategy_args *);
66
67 /*
68  * This vnode table stores what we want to do if the filesystem doesn't
69  * implement a particular VOP.
70  *
71  * If there is no specific entry here, we will return EOPNOTSUPP.
72  */
73 struct vop_ops default_vnode_vops = {
74         .vop_default            = vop_eopnotsupp,
75         .vop_advlock            = (void *)vop_einval,
76         .vop_fsync              = (void *)vop_null,
77         .vop_ioctl              = (void *)vop_enotty,
78         .vop_mmap               = (void *)vop_einval,
79         .vop_old_lookup         = vop_nolookup,
80         .vop_open               = vop_stdopen,
81         .vop_close              = vop_stdclose,
82         .vop_pathconf           = vop_stdpathconf,
83         .vop_readlink           = (void *)vop_einval,
84         .vop_reallocblks        = (void *)vop_eopnotsupp,
85         .vop_strategy           = vop_nostrategy,
86         .vop_getacl             = (void *)vop_eopnotsupp,
87         .vop_setacl             = (void *)vop_eopnotsupp,
88         .vop_aclcheck           = (void *)vop_eopnotsupp,
89         .vop_getextattr         = (void *)vop_eopnotsupp,
90         .vop_setextattr         = (void *)vop_eopnotsupp,
91         .vop_markatime          = vop_stdmarkatime,
92         .vop_nresolve           = vop_compat_nresolve,
93         .vop_nlookupdotdot      = vop_compat_nlookupdotdot,
94         .vop_ncreate            = vop_compat_ncreate,
95         .vop_nmkdir             = vop_compat_nmkdir,
96         .vop_nmknod             = vop_compat_nmknod,
97         .vop_nlink              = vop_compat_nlink,
98         .vop_nsymlink           = vop_compat_nsymlink,
99         .vop_nwhiteout          = vop_compat_nwhiteout,
100         .vop_nremove            = vop_compat_nremove,
101         .vop_nrmdir             = vop_compat_nrmdir,
102         .vop_nrename            = vop_compat_nrename,
103         .vop_mountctl           = vop_stdmountctl
104 };
105
106 VNODEOP_SET(default_vnode_vops);
107
108 int
109 vop_eopnotsupp(struct vop_generic_args *ap)
110 {
111         return (EOPNOTSUPP);
112 }
113
114 int
115 vop_ebadf(struct vop_generic_args *ap)
116 {
117         return (EBADF);
118 }
119
120 int
121 vop_enotty(struct vop_generic_args *ap)
122 {
123         return (ENOTTY);
124 }
125
126 int
127 vop_einval(struct vop_generic_args *ap)
128 {
129         return (EINVAL);
130 }
131
132 int
133 vop_stdmarkatime(struct vop_markatime_args *ap)
134 {
135         return (EOPNOTSUPP);
136 }
137
138 int
139 vop_null(struct vop_generic_args *ap)
140 {
141         return (0);
142 }
143
144 int
145 vop_defaultop(struct vop_generic_args *ap)
146 {
147         return (VOCALL(&default_vnode_vops, ap));
148 }
149
150 /*
151  * vop_compat_resolve { struct nchandle *a_nch, struct vnode *dvp }
152  * XXX STOPGAP FUNCTION
153  *
154  * XXX OLD API ROUTINE!  WHEN ALL VFSs HAVE BEEN CLEANED UP THIS PROCEDURE
155  * WILL BE REMOVED.  This procedure exists for all VFSs which have not
156  * yet implemented VOP_NRESOLVE().  It converts VOP_NRESOLVE() into a 
157  * vop_old_lookup() and does appropriate translations.
158  *
159  * Resolve a ncp for VFSs which do not support the VOP.  Eventually all
160  * VFSs will support this VOP and this routine can be removed, since
161  * VOP_NRESOLVE() is far less complex then the older LOOKUP/CACHEDLOOKUP
162  * API.
163  *
164  * A locked ncp is passed in to be resolved.  The NCP is resolved by
165  * figuring out the vnode (if any) and calling cache_setvp() to attach the
166  * vnode to the entry.  If the entry represents a non-existant node then
167  * cache_setvp() is called with a NULL vnode to resolve the entry into a
168  * negative cache entry.  No vnode locks are retained and the
169  * ncp is left locked on return.
170  *
171  * The ncp will NEVER represent "", "." or "..", or contain any slashes.
172  *
173  * There is a potential directory and vnode interlock.   The lock order
174  * requirement is: namecache, governing directory, resolved vnode.
175  */
176 int
177 vop_compat_nresolve(struct vop_nresolve_args *ap)
178 {
179         int error;
180         struct vnode *dvp;
181         struct vnode *vp;
182         struct nchandle *nch;
183         struct namecache *ncp;
184         struct componentname cnp;
185
186         nch = ap->a_nch;        /* locked namecache node */
187         ncp = nch->ncp;
188         dvp = ap->a_dvp;
189
190         /*
191          * UFS currently stores all sorts of side effects, including a loop
192          * variable, in the directory inode.  That needs to be fixed and the
193          * other VFS's audited before we can switch to LK_SHARED.
194          */
195         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
196                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
197                         ncp, ncp->nc_name);
198                 return(EAGAIN);
199         }
200
201         bzero(&cnp, sizeof(cnp));
202         cnp.cn_nameiop = NAMEI_LOOKUP;
203         cnp.cn_flags = 0;
204         cnp.cn_nameptr = ncp->nc_name;
205         cnp.cn_namelen = ncp->nc_nlen;
206         cnp.cn_cred = ap->a_cred;
207         cnp.cn_td = curthread; /* XXX */
208
209         /*
210          * vop_old_lookup() always returns vp locked.  dvp may or may not be
211          * left locked depending on CNP_PDIRUNLOCK.
212          */
213         error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
214         if (error == 0)
215                 vn_unlock(vp);
216         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
217                 vn_unlock(dvp);
218         if ((ncp->nc_flag & NCF_UNRESOLVED) == 0) {
219                 /* was resolved by another process while we were unlocked */
220                 if (error == 0)
221                         vrele(vp);
222         } else if (error == 0) {
223                 KKASSERT(vp != NULL);
224                 cache_setvp(nch, vp);
225                 vrele(vp);
226         } else if (error == ENOENT) {
227                 KKASSERT(vp == NULL);
228                 if (cnp.cn_flags & CNP_ISWHITEOUT)
229                         ncp->nc_flag |= NCF_WHITEOUT;
230                 cache_setvp(nch, NULL);
231         }
232         vrele(dvp);
233         return (error);
234 }
235
236 /*
237  * vop_compat_nlookupdotdot { struct vnode *a_dvp,
238  *                      struct vnode **a_vpp,
239  *                      struct ucred *a_cred }
240  *
241  * Lookup the vnode representing the parent directory of the specified
242  * directory vnode.  a_dvp should not be locked.  If no error occurs *a_vpp
243  * will contained the parent vnode, locked and refd, else *a_vpp will be NULL.
244  *
245  * This function is designed to aid NFS server-side operations and is
246  * used by cache_fromdvp() to create a consistent, connected namecache
247  * topology.
248  *
249  * As part of the NEW API work, VFSs will first split their CNP_ISDOTDOT
250  * code out from their *_lookup() and create *_nlookupdotdot().  Then as time
251  * permits VFSs will implement the remaining *_n*() calls and finally get
252  * rid of their *_lookup() call.
253  */
254 int
255 vop_compat_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
256 {
257         struct componentname cnp;
258         int error;
259
260         /*
261          * UFS currently stores all sorts of side effects, including a loop
262          * variable, in the directory inode.  That needs to be fixed and the
263          * other VFS's audited before we can switch to LK_SHARED.
264          */
265         *ap->a_vpp = NULL;
266         if ((error = vget(ap->a_dvp, LK_EXCLUSIVE)) != 0)
267                 return (error);
268         if (ap->a_dvp->v_type != VDIR) {
269                 vput(ap->a_dvp);
270                 return (ENOTDIR);
271         }
272
273         bzero(&cnp, sizeof(cnp));
274         cnp.cn_nameiop = NAMEI_LOOKUP;
275         cnp.cn_flags = CNP_ISDOTDOT;
276         cnp.cn_nameptr = "..";
277         cnp.cn_namelen = 2;
278         cnp.cn_cred = ap->a_cred;
279         cnp.cn_td = curthread; /* XXX */
280
281         /*
282          * vop_old_lookup() always returns vp locked.  dvp may or may not be
283          * left locked depending on CNP_PDIRUNLOCK.
284          *
285          * (*vpp) will be returned locked if no error occured, which is the
286          * state we want.
287          */
288         error = vop_old_lookup(ap->a_head.a_ops, ap->a_dvp, ap->a_vpp, &cnp);
289         if (cnp.cn_flags & CNP_PDIRUNLOCK)
290                 vrele(ap->a_dvp);
291         else
292                 vput(ap->a_dvp);
293         return (error);
294 }
295
296 /*
297  * vop_compat_ncreate { struct nchandle *a_nch,         XXX STOPGAP FUNCTION
298  *                      struct vnode *a_dvp,
299  *                      struct vnode **a_vpp,
300  *                      struct ucred *a_cred,
301  *                      struct vattr *a_vap }
302  *
303  * Create a file as specified by a_vap.  Compatibility requires us to issue
304  * the appropriate VOP_OLD_LOOKUP before we issue VOP_OLD_CREATE in order
305  * to setup the directory inode's i_offset and i_count (e.g. in UFS).
306  */
307 int
308 vop_compat_ncreate(struct vop_ncreate_args *ap)
309 {
310         struct thread *td = curthread;
311         struct componentname cnp;
312         struct nchandle *nch;
313         struct namecache *ncp;
314         struct vnode *dvp;
315         int error;
316
317         /*
318          * Sanity checks, get a locked directory vnode.
319          */
320         nch = ap->a_nch;                /* locked namecache node */
321         dvp = ap->a_dvp;
322         ncp = nch->ncp;
323
324         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
325                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
326                         ncp, ncp->nc_name);
327                 return(EAGAIN);
328         }
329
330         /*
331          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
332          * caches all information required to create the entry in the
333          * directory inode.  We expect a return code of EJUSTRETURN for
334          * the CREATE case.  The cnp must simulated a saved-name situation.
335          */
336         bzero(&cnp, sizeof(cnp));
337         cnp.cn_nameiop = NAMEI_CREATE;
338         cnp.cn_flags = CNP_LOCKPARENT;
339         cnp.cn_nameptr = ncp->nc_name;
340         cnp.cn_namelen = ncp->nc_nlen;
341         cnp.cn_cred = ap->a_cred;
342         cnp.cn_td = td;
343         *ap->a_vpp = NULL;
344
345         error = vop_old_lookup(ap->a_head.a_ops, dvp, ap->a_vpp, &cnp);
346
347         /*
348          * EJUSTRETURN should be returned for this case, which means that
349          * the VFS has setup the directory inode for the create.  The dvp we
350          * passed in is expected to remain in a locked state.
351          *
352          * If the VOP_OLD_CREATE is successful we are responsible for updating
353          * the cache state of the locked ncp that was passed to us.
354          */
355         if (error == EJUSTRETURN) {
356                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
357                 error = VOP_OLD_CREATE(dvp, ap->a_vpp, &cnp, ap->a_vap);
358                 if (error == 0) {
359                         cache_setunresolved(nch);
360                         cache_setvp(nch, *ap->a_vpp);
361                 }
362         } else {
363                 if (error == 0) {
364                         vput(*ap->a_vpp);
365                         *ap->a_vpp = NULL;
366                         error = EEXIST;
367                 }
368                 KKASSERT(*ap->a_vpp == NULL);
369         }
370         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
371                 vn_unlock(dvp);
372         vrele(dvp);
373         return (error);
374 }
375
376 /*
377  * vop_compat_nmkdir { struct nchandle *a_nch,  XXX STOPGAP FUNCTION
378  *                      struct vnode *a_dvp,
379  *                      struct vnode **a_vpp,
380  *                      struct ucred *a_cred,
381  *                      struct vattr *a_vap }
382  *
383  * Create a directory as specified by a_vap.  Compatibility requires us to
384  * issue the appropriate VOP_OLD_LOOKUP before we issue VOP_OLD_MKDIR in
385  * order to setup the directory inode's i_offset and i_count (e.g. in UFS).
386  */
387 int
388 vop_compat_nmkdir(struct vop_nmkdir_args *ap)
389 {
390         struct thread *td = curthread;
391         struct componentname cnp;
392         struct nchandle *nch;
393         struct namecache *ncp;
394         struct vnode *dvp;
395         int error;
396
397         /*
398          * Sanity checks, get a locked directory vnode.
399          */
400         nch = ap->a_nch;                /* locked namecache node */
401         ncp = nch->ncp;
402         dvp = ap->a_dvp;
403         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
404                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
405                         ncp, ncp->nc_name);
406                 return(EAGAIN);
407         }
408
409         /*
410          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
411          * caches all information required to create the entry in the
412          * directory inode.  We expect a return code of EJUSTRETURN for
413          * the CREATE case.  The cnp must simulated a saved-name situation.
414          */
415         bzero(&cnp, sizeof(cnp));
416         cnp.cn_nameiop = NAMEI_CREATE;
417         cnp.cn_flags = CNP_LOCKPARENT;
418         cnp.cn_nameptr = ncp->nc_name;
419         cnp.cn_namelen = ncp->nc_nlen;
420         cnp.cn_cred = ap->a_cred;
421         cnp.cn_td = td;
422         *ap->a_vpp = NULL;
423
424         error = vop_old_lookup(ap->a_head.a_ops, dvp, ap->a_vpp, &cnp);
425
426         /*
427          * EJUSTRETURN should be returned for this case, which means that
428          * the VFS has setup the directory inode for the create.  The dvp we
429          * passed in is expected to remain in a locked state.
430          *
431          * If the VOP_OLD_MKDIR is successful we are responsible for updating
432          * the cache state of the locked ncp that was passed to us.
433          */
434         if (error == EJUSTRETURN) {
435                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
436                 error = VOP_OLD_MKDIR(dvp, ap->a_vpp, &cnp, ap->a_vap);
437                 if (error == 0) {
438                         cache_setunresolved(nch);
439                         cache_setvp(nch, *ap->a_vpp);
440                 }
441         } else {
442                 if (error == 0) {
443                         vput(*ap->a_vpp);
444                         *ap->a_vpp = NULL;
445                         error = EEXIST;
446                 }
447                 KKASSERT(*ap->a_vpp == NULL);
448         }
449         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
450                 vn_unlock(dvp);
451         vrele(dvp);
452         return (error);
453 }
454
455 /*
456  * vop_compat_nmknod { struct nchandle *a_nch,  XXX STOPGAP FUNCTION
457  *                      struct vnode *a_dvp,
458  *                      struct vnode **a_vpp,
459  *                      struct ucred *a_cred,
460  *                      struct vattr *a_vap }
461  *
462  * Create a device or fifo node as specified by a_vap.  Compatibility requires
463  * us to issue the appropriate VOP_OLD_LOOKUP before we issue VOP_OLD_MKNOD
464  * in order to setup the directory inode's i_offset and i_count (e.g. in UFS).
465  */
466 int
467 vop_compat_nmknod(struct vop_nmknod_args *ap)
468 {
469         struct thread *td = curthread;
470         struct componentname cnp;
471         struct nchandle *nch;
472         struct namecache *ncp;
473         struct vnode *dvp;
474         int error;
475
476         /*
477          * Sanity checks, get a locked directory vnode.
478          */
479         nch = ap->a_nch;                /* locked namecache node */
480         ncp = nch->ncp;
481         dvp = ap->a_dvp;
482
483         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
484                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
485                         ncp, ncp->nc_name);
486                 return(EAGAIN);
487         }
488
489         /*
490          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
491          * caches all information required to create the entry in the
492          * directory inode.  We expect a return code of EJUSTRETURN for
493          * the CREATE case.  The cnp must simulated a saved-name situation.
494          */
495         bzero(&cnp, sizeof(cnp));
496         cnp.cn_nameiop = NAMEI_CREATE;
497         cnp.cn_flags = CNP_LOCKPARENT;
498         cnp.cn_nameptr = ncp->nc_name;
499         cnp.cn_namelen = ncp->nc_nlen;
500         cnp.cn_cred = ap->a_cred;
501         cnp.cn_td = td;
502         *ap->a_vpp = NULL;
503
504         error = vop_old_lookup(ap->a_head.a_ops, dvp, ap->a_vpp, &cnp);
505
506         /*
507          * EJUSTRETURN should be returned for this case, which means that
508          * the VFS has setup the directory inode for the create.  The dvp we
509          * passed in is expected to remain in a locked state.
510          *
511          * If the VOP_OLD_MKNOD is successful we are responsible for updating
512          * the cache state of the locked ncp that was passed to us.
513          */
514         if (error == EJUSTRETURN) {
515                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
516                 error = VOP_OLD_MKNOD(dvp, ap->a_vpp, &cnp, ap->a_vap);
517                 if (error == 0) {
518                         cache_setunresolved(nch);
519                         cache_setvp(nch, *ap->a_vpp);
520                 }
521         } else {
522                 if (error == 0) {
523                         vput(*ap->a_vpp);
524                         *ap->a_vpp = NULL;
525                         error = EEXIST;
526                 }
527                 KKASSERT(*ap->a_vpp == NULL);
528         }
529         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
530                 vn_unlock(dvp);
531         vrele(dvp);
532         return (error);
533 }
534
535 /*
536  * vop_compat_nlink { struct nchandle *a_nch,   XXX STOPGAP FUNCTION
537  *                      struct vnode *a_dvp,
538  *                      struct vnode *a_vp,
539  *                      struct ucred *a_cred }
540  *
541  * The passed vp is locked and represents the source.  The passed ncp is
542  * locked and represents the target to create.
543  */
544 int
545 vop_compat_nlink(struct vop_nlink_args *ap)
546 {
547         struct thread *td = curthread;
548         struct componentname cnp;
549         struct nchandle *nch;
550         struct namecache *ncp;
551         struct vnode *dvp;
552         struct vnode *tvp;
553         int error;
554
555         /*
556          * Sanity checks, get a locked directory vnode.
557          */
558         nch = ap->a_nch;                /* locked namecache node */
559         ncp = nch->ncp;
560         dvp = ap->a_dvp;
561
562         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
563                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
564                         ncp, ncp->nc_name);
565                 return(EAGAIN);
566         }
567
568         /*
569          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
570          * caches all information required to create the entry in the
571          * directory inode.  We expect a return code of EJUSTRETURN for
572          * the CREATE case.  The cnp must simulated a saved-name situation.
573          *
574          * It should not be possible for there to be a vnode collision
575          * between the source vp and target (name lookup).  However NFS
576          * clients racing each other can cause NFS to alias the same vnode
577          * across several names without the rest of the system knowing it.
578          * Use CNP_NOTVP to avoid a panic in this situation.
579          */
580         bzero(&cnp, sizeof(cnp));
581         cnp.cn_nameiop = NAMEI_CREATE;
582         cnp.cn_flags = CNP_LOCKPARENT | CNP_NOTVP;
583         cnp.cn_nameptr = ncp->nc_name;
584         cnp.cn_namelen = ncp->nc_nlen;
585         cnp.cn_cred = ap->a_cred;
586         cnp.cn_td = td;
587         cnp.cn_notvp = ap->a_vp;
588
589         tvp = NULL;
590         error = vop_old_lookup(ap->a_head.a_ops, dvp, &tvp, &cnp);
591
592         /*
593          * EJUSTRETURN should be returned for this case, which means that
594          * the VFS has setup the directory inode for the create.  The dvp we
595          * passed in is expected to remain in a locked state.
596          *
597          * If the VOP_OLD_LINK is successful we are responsible for updating
598          * the cache state of the locked ncp that was passed to us.
599          */
600         if (error == EJUSTRETURN) {
601                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
602                 error = VOP_OLD_LINK(dvp, ap->a_vp, &cnp);
603                 if (error == 0) {
604                         cache_setunresolved(nch);
605                         cache_setvp(nch, ap->a_vp);
606                 }
607         } else {
608                 if (error == 0) {
609                         vput(tvp);
610                         error = EEXIST;
611                 }
612         }
613         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
614                 vn_unlock(dvp);
615         vrele(dvp);
616         return (error);
617 }
618
619 int
620 vop_compat_nsymlink(struct vop_nsymlink_args *ap)
621 {
622         struct thread *td = curthread;
623         struct componentname cnp;
624         struct nchandle *nch;
625         struct namecache *ncp;
626         struct vnode *dvp;
627         struct vnode *vp;
628         int error;
629
630         /*
631          * Sanity checks, get a locked directory vnode.
632          */
633         *ap->a_vpp = NULL;
634         nch = ap->a_nch;                /* locked namecache node */
635         ncp = nch->ncp;
636         dvp = ap->a_dvp;
637
638         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
639                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
640                         ncp, ncp->nc_name);
641                 return(EAGAIN);
642         }
643
644         /*
645          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
646          * caches all information required to create the entry in the
647          * directory inode.  We expect a return code of EJUSTRETURN for
648          * the CREATE case.  The cnp must simulated a saved-name situation.
649          */
650         bzero(&cnp, sizeof(cnp));
651         cnp.cn_nameiop = NAMEI_CREATE;
652         cnp.cn_flags = CNP_LOCKPARENT;
653         cnp.cn_nameptr = ncp->nc_name;
654         cnp.cn_namelen = ncp->nc_nlen;
655         cnp.cn_cred = ap->a_cred;
656         cnp.cn_td = td;
657
658         vp = NULL;
659         error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
660
661         /*
662          * EJUSTRETURN should be returned for this case, which means that
663          * the VFS has setup the directory inode for the create.  The dvp we
664          * passed in is expected to remain in a locked state.
665          *
666          * If the VOP_OLD_SYMLINK is successful we are responsible for updating
667          * the cache state of the locked ncp that was passed to us.
668          */
669         if (error == EJUSTRETURN) {
670                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
671                 error = VOP_OLD_SYMLINK(dvp, &vp, &cnp, ap->a_vap, ap->a_target);
672                 if (error == 0) {
673                         cache_setunresolved(nch);
674                         cache_setvp(nch, vp);
675                         *ap->a_vpp = vp;
676                 }
677         } else {
678                 if (error == 0) {
679                         vput(vp);
680                         vp = NULL;
681                         error = EEXIST;
682                 }
683                 KKASSERT(vp == NULL);
684         }
685         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
686                 vn_unlock(dvp);
687         vrele(dvp);
688         return (error);
689 }
690
691 /*
692  * vop_compat_nwhiteout { struct nchandle *a_nch,       XXX STOPGAP FUNCTION
693  *                        struct vnode *a_dvp,
694  *                        struct ucred *a_cred,
695  *                        int a_flags }
696  *
697  * Issie a whiteout operation (create, lookup, or delete).  Compatibility 
698  * requires us to issue the appropriate VOP_OLD_LOOKUP before we issue 
699  * VOP_OLD_WHITEOUT in order to setup the directory inode's i_offset and i_count
700  * (e.g. in UFS) for the NAMEI_CREATE and NAMEI_DELETE ops.  For NAMEI_LOOKUP
701  * no lookup is necessary.
702  */
703 int
704 vop_compat_nwhiteout(struct vop_nwhiteout_args *ap)
705 {
706         struct thread *td = curthread;
707         struct componentname cnp;
708         struct nchandle *nch;
709         struct namecache *ncp;
710         struct vnode *dvp;
711         struct vnode *vp;
712         int error;
713
714         /*
715          * Sanity checks, get a locked directory vnode.
716          */
717         nch = ap->a_nch;                /* locked namecache node */
718         ncp = nch->ncp;
719         dvp = ap->a_dvp;
720
721         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
722                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
723                         ncp, ncp->nc_name);
724                 return(EAGAIN);
725         }
726
727         /*
728          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
729          * caches all information required to create the entry in the
730          * directory inode.  We expect a return code of EJUSTRETURN for
731          * the CREATE case.  The cnp must simulated a saved-name situation.
732          */
733         bzero(&cnp, sizeof(cnp));
734         cnp.cn_nameiop = ap->a_flags;
735         cnp.cn_flags = CNP_LOCKPARENT;
736         cnp.cn_nameptr = ncp->nc_name;
737         cnp.cn_namelen = ncp->nc_nlen;
738         cnp.cn_cred = ap->a_cred;
739         cnp.cn_td = td;
740
741         vp = NULL;
742
743         /*
744          * EJUSTRETURN should be returned for the CREATE or DELETE cases.
745          * The VFS has setup the directory inode for the create.  The dvp we
746          * passed in is expected to remain in a locked state.
747          *
748          * If the VOP_OLD_WHITEOUT is successful we are responsible for updating
749          * the cache state of the locked ncp that was passed to us.
750          */
751         switch(ap->a_flags) {
752         case NAMEI_DELETE:
753                 cnp.cn_flags |= CNP_DOWHITEOUT;
754                 /* fall through */
755         case NAMEI_CREATE:
756                 error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
757                 if (error == EJUSTRETURN) {
758                         KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
759                         error = VOP_OLD_WHITEOUT(dvp, &cnp, ap->a_flags);
760                         if (error == 0)
761                                 cache_setunresolved(nch);
762                 } else {
763                         if (error == 0) {
764                                 vput(vp);
765                                 vp = NULL;
766                                 error = EEXIST;
767                         }
768                         KKASSERT(vp == NULL);
769                 }
770                 break;
771         case NAMEI_LOOKUP:
772                 error = VOP_OLD_WHITEOUT(dvp, NULL, ap->a_flags);
773                 break;
774         default:
775                 error = EINVAL;
776                 break;
777         }
778         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
779                 vn_unlock(dvp);
780         vrele(dvp);
781         return (error);
782 }
783
784
785 /*
786  * vop_compat_nremove { struct nchandle *a_nch,         XXX STOPGAP FUNCTION
787  *                      struct vnode *a_dvp,
788  *                      struct ucred *a_cred }
789  */
790 int
791 vop_compat_nremove(struct vop_nremove_args *ap)
792 {
793         struct thread *td = curthread;
794         struct componentname cnp;
795         struct nchandle *nch;
796         struct namecache *ncp;
797         struct vnode *dvp;
798         struct vnode *vp;
799         int error;
800
801         /*
802          * Sanity checks, get a locked directory vnode.
803          */
804         nch = ap->a_nch;                /* locked namecache node */
805         ncp = nch->ncp;
806         dvp = ap->a_dvp;
807
808         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
809                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
810                         ncp, ncp->nc_name);
811                 return(EAGAIN);
812         }
813
814         /*
815          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
816          * caches all information required to delete the entry in the
817          * directory inode.  We expect a return code of 0 for the DELETE
818          * case (meaning that a vp has been found).  The cnp must simulated
819          * a saved-name situation.
820          */
821         bzero(&cnp, sizeof(cnp));
822         cnp.cn_nameiop = NAMEI_DELETE;
823         cnp.cn_flags = CNP_LOCKPARENT;
824         cnp.cn_nameptr = ncp->nc_name;
825         cnp.cn_namelen = ncp->nc_nlen;
826         cnp.cn_cred = ap->a_cred;
827         cnp.cn_td = td;
828
829         /*
830          * The vnode must be a directory and must not represent the
831          * current directory.
832          */
833         vp = NULL;
834         error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
835         if (error == 0 && vp->v_type == VDIR)
836                 error = EPERM;
837         if (error == 0) {
838                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
839                 error = VOP_OLD_REMOVE(dvp, vp, &cnp);
840                 if (error == 0)
841                         cache_unlink(nch);
842         }
843         if (vp) {
844                 if (dvp == vp)
845                         vrele(vp);
846                 else    
847                         vput(vp);
848         }
849         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
850                 vn_unlock(dvp);
851         vrele(dvp);
852         return (error);
853 }
854
855 /*
856  * vop_compat_nrmdir { struct nchandle *a_nch,  XXX STOPGAP FUNCTION
857  *                     struct vnode *dvp,
858  *                     struct ucred *a_cred }
859  */
860 int
861 vop_compat_nrmdir(struct vop_nrmdir_args *ap)
862 {
863         struct thread *td = curthread;
864         struct componentname cnp;
865         struct nchandle *nch;
866         struct namecache *ncp;
867         struct vnode *dvp;
868         struct vnode *vp;
869         int error;
870
871         /*
872          * Sanity checks, get a locked directory vnode.
873          */
874         nch = ap->a_nch;                /* locked namecache node */
875         ncp = nch->ncp;
876         dvp = ap->a_dvp;
877
878         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
879                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
880                         ncp, ncp->nc_name);
881                 return(EAGAIN);
882         }
883
884         /*
885          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
886          * caches all information required to delete the entry in the
887          * directory inode.  We expect a return code of 0 for the DELETE
888          * case (meaning that a vp has been found).  The cnp must simulated
889          * a saved-name situation.
890          */
891         bzero(&cnp, sizeof(cnp));
892         cnp.cn_nameiop = NAMEI_DELETE;
893         cnp.cn_flags = CNP_LOCKPARENT;
894         cnp.cn_nameptr = ncp->nc_name;
895         cnp.cn_namelen = ncp->nc_nlen;
896         cnp.cn_cred = ap->a_cred;
897         cnp.cn_td = td;
898
899         /*
900          * The vnode must be a directory and must not represent the
901          * current directory.
902          */
903         vp = NULL;
904         error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
905         if (error == 0 && vp->v_type != VDIR)
906                 error = ENOTDIR;
907         if (error == 0 && vp == dvp)
908                 error = EINVAL;
909         if (error == 0 && (vp->v_flag & VROOT))
910                 error = EBUSY;
911         if (error == 0) {
912                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
913                 error = VOP_OLD_RMDIR(dvp, vp, &cnp);
914
915                 /*
916                  * Note that this invalidation will cause any process
917                  * currently CD'd into the directory being removed to be
918                  * disconnected from the topology and not be able to ".."
919                  * back out.
920                  */
921                 if (error == 0) {
922                         cache_inval(nch, CINV_DESTROY);
923                         cache_inval_vp(vp, CINV_DESTROY);
924                 }
925         }
926         if (vp) {
927                 if (dvp == vp)
928                         vrele(vp);
929                 else    
930                         vput(vp);
931         }
932         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
933                 vn_unlock(dvp);
934         vrele(dvp);
935         return (error);
936 }
937
938 /*
939  * vop_compat_nrename { struct nchandle *a_fnch,        XXX STOPGAP FUNCTION
940  *                      struct nchandle *a_tnch,
941  *                      struct ucred *a_cred }
942  *
943  * This is a fairly difficult procedure.  The old VOP_OLD_RENAME requires that
944  * the source directory and vnode be unlocked and the target directory and
945  * vnode (if it exists) be locked.  All arguments will be vrele'd and 
946  * the targets will also be unlocked regardless of the return code.
947  */
948 int
949 vop_compat_nrename(struct vop_nrename_args *ap)
950 {
951         struct thread *td = curthread;
952         struct componentname fcnp;
953         struct componentname tcnp;
954         struct nchandle *fnch;
955         struct nchandle *tnch;
956         struct namecache *fncp;
957         struct namecache *tncp;
958         struct vnode *fdvp, *fvp;
959         struct vnode *tdvp, *tvp;
960         int error;
961
962         /*
963          * Sanity checks, get referenced vnodes representing the source.
964          */
965         fnch = ap->a_fnch;              /* locked namecache node */
966         fncp = fnch->ncp;
967         fdvp = ap->a_fdvp;
968
969         /*
970          * Temporarily lock the source directory and lookup in DELETE mode to
971          * check permissions.  XXX delete permissions should have been
972          * checked by nlookup(), we need to add NLC_DELETE for delete
973          * checking.  It is unclear whether VFS's require the directory setup
974          * info NAMEI_DELETE causes to be stored in the fdvp's inode, but
975          * since it isn't locked and since UFS always does a relookup of
976          * the source, it is believed that the only side effect that matters
977          * is the permissions check.
978          */
979         if ((error = vget(fdvp, LK_EXCLUSIVE)) != 0) {
980                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
981                         fncp, fncp->nc_name);
982                 return(EAGAIN);
983         }
984
985         bzero(&fcnp, sizeof(fcnp));
986         fcnp.cn_nameiop = NAMEI_DELETE;
987         fcnp.cn_flags = CNP_LOCKPARENT;
988         fcnp.cn_nameptr = fncp->nc_name;
989         fcnp.cn_namelen = fncp->nc_nlen;
990         fcnp.cn_cred = ap->a_cred;
991         fcnp.cn_td = td;
992
993         /*
994          * note: vop_old_lookup (i.e. VOP_OLD_LOOKUP) always returns a locked
995          * fvp.
996          */
997         fvp = NULL;
998         error = vop_old_lookup(ap->a_head.a_ops, fdvp, &fvp, &fcnp);
999         if (error == 0 && (fvp->v_flag & VROOT)) {
1000                 vput(fvp);      /* as if vop_old_lookup had failed */
1001                 error = EBUSY;
1002         }
1003         if ((fcnp.cn_flags & CNP_PDIRUNLOCK) == 0) {
1004                 fcnp.cn_flags |= CNP_PDIRUNLOCK;
1005                 vn_unlock(fdvp);
1006         }
1007         if (error) {
1008                 vrele(fdvp);
1009                 return (error);
1010         }
1011         vn_unlock(fvp);
1012
1013         /*
1014          * fdvp and fvp are now referenced and unlocked.
1015          *
1016          * Get a locked directory vnode for the target and lookup the target
1017          * in CREATE mode so it places the required information in the
1018          * directory inode.
1019          */
1020         tnch = ap->a_tnch;              /* locked namecache node */
1021         tncp = tnch->ncp;
1022         tdvp = ap->a_tdvp;
1023         if (error) {
1024                 vrele(fdvp);
1025                 vrele(fvp);
1026                 return (error);
1027         }
1028         if ((error = vget(tdvp, LK_EXCLUSIVE)) != 0) {
1029                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
1030                         tncp, tncp->nc_name);
1031                 vrele(fdvp);
1032                 vrele(fvp);
1033                 return(EAGAIN);
1034         }
1035
1036         /*
1037          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
1038          * caches all information required to create the entry in the
1039          * target directory inode.
1040          */
1041         bzero(&tcnp, sizeof(tcnp));
1042         tcnp.cn_nameiop = NAMEI_RENAME;
1043         tcnp.cn_flags = CNP_LOCKPARENT;
1044         tcnp.cn_nameptr = tncp->nc_name;
1045         tcnp.cn_namelen = tncp->nc_nlen;
1046         tcnp.cn_cred = ap->a_cred;
1047         tcnp.cn_td = td;
1048
1049         tvp = NULL;
1050         error = vop_old_lookup(ap->a_head.a_ops, tdvp, &tvp, &tcnp);
1051
1052         if (error == EJUSTRETURN) {
1053                 /*
1054                  * Target does not exist.  tvp should be NULL.
1055                  */
1056                 KKASSERT(tvp == NULL);
1057                 KKASSERT((tcnp.cn_flags & CNP_PDIRUNLOCK) == 0);
1058                 error = VOP_OLD_RENAME(fdvp, fvp, &fcnp, tdvp, tvp, &tcnp);
1059                 if (error == 0)
1060                         cache_rename(fnch, tnch);
1061         } else if (error == 0) {
1062                 /*
1063                  * Target exists.  VOP_OLD_RENAME should correctly delete the
1064                  * target.
1065                  */
1066                 KKASSERT((tcnp.cn_flags & CNP_PDIRUNLOCK) == 0);
1067                 error = VOP_OLD_RENAME(fdvp, fvp, &fcnp, tdvp, tvp, &tcnp);
1068                 if (error == 0)
1069                         cache_rename(fnch, tnch);
1070         } else {
1071                 vrele(fdvp);
1072                 vrele(fvp);
1073                 if (tcnp.cn_flags & CNP_PDIRUNLOCK)
1074                         vrele(tdvp);
1075                 else
1076                         vput(tdvp);
1077         }
1078         return (error);
1079 }
1080
1081 static int
1082 vop_nolookup(struct vop_old_lookup_args *ap)
1083 {
1084
1085         *ap->a_vpp = NULL;
1086         return (ENOTDIR);
1087 }
1088
1089 /*
1090  *      vop_nostrategy:
1091  *
1092  *      Strategy routine for VFS devices that have none.
1093  *
1094  *      B_ERROR and B_INVAL must be cleared prior to calling any strategy
1095  *      routine.  Typically this is done for a BUF_CMD_READ strategy call.
1096  *      Typically B_INVAL is assumed to already be clear prior to a write
1097  *      and should not be cleared manually unless you just made the buffer
1098  *      invalid.  B_ERROR should be cleared either way.
1099  */
1100
1101 static int
1102 vop_nostrategy (struct vop_strategy_args *ap)
1103 {
1104         kprintf("No strategy for buffer at %p\n", ap->a_bio->bio_buf);
1105         vprint("", ap->a_vp);
1106         ap->a_bio->bio_buf->b_flags |= B_ERROR;
1107         ap->a_bio->bio_buf->b_error = EOPNOTSUPP;
1108         biodone(ap->a_bio);
1109         return (EOPNOTSUPP);
1110 }
1111
1112 int
1113 vop_stdpathconf(struct vop_pathconf_args *ap)
1114 {
1115         int error = 0;
1116
1117         switch (ap->a_name) {
1118         case _PC_CHOWN_RESTRICTED:
1119                 *ap->a_retval = _POSIX_CHOWN_RESTRICTED;
1120                 break;
1121         case _PC_LINK_MAX:
1122                 *ap->a_retval = LINK_MAX;
1123                 break;
1124         case _PC_MAX_CANON:
1125                 *ap->a_retval = MAX_CANON;
1126                 break;
1127         case _PC_MAX_INPUT:
1128                 *ap->a_retval = MAX_INPUT;
1129                 break;
1130         case _PC_NAME_MAX:
1131                 *ap->a_retval = NAME_MAX;
1132                 break;
1133         case _PC_NO_TRUNC:
1134                 *ap->a_retval = _POSIX_NO_TRUNC;
1135                 break;
1136         case _PC_PATH_MAX:
1137                 *ap->a_retval = PATH_MAX;
1138                 break;
1139         case _PC_PIPE_BUF:
1140                 *ap->a_retval = PIPE_BUF;
1141                 break;
1142         case _PC_VDISABLE:
1143                 *ap->a_retval = _POSIX_VDISABLE;
1144                 break;
1145         default:
1146                 error = EINVAL;
1147                 break;
1148         }
1149         return (error);
1150 }
1151
1152 /*
1153  * Standard open.
1154  *
1155  * (struct vnode *a_vp, int a_mode, struct ucred *a_ucred, struct file *a_fp)
1156  *
1157  * a_mode: note, 'F' modes, e.g. FREAD, FWRITE
1158  */
1159 int
1160 vop_stdopen(struct vop_open_args *ap)
1161 {
1162         struct vnode *vp = ap->a_vp;
1163         struct file *fp;
1164
1165         if ((fp = ap->a_fp) != NULL) {
1166                 switch(vp->v_type) {
1167                 case VFIFO:
1168                         fp->f_type = DTYPE_FIFO;
1169                         break;
1170                 default:
1171                         fp->f_type = DTYPE_VNODE;
1172                         break;
1173                 }
1174                 /* retain flags not to be copied */
1175                 fp->f_flag = (fp->f_flag & ~FMASK) | (ap->a_mode & FMASK);
1176                 fp->f_ops = &vnode_fileops;
1177                 fp->f_data = vp;
1178                 vref(vp);
1179         }
1180         if (ap->a_mode & FWRITE)
1181                 atomic_add_int(&vp->v_writecount, 1);
1182         KKASSERT(vp->v_opencount >= 0 && vp->v_opencount != INT_MAX);
1183         atomic_add_int(&vp->v_opencount, 1);
1184         return (0);
1185 }
1186
1187 /*
1188  * Standard close.
1189  *
1190  * (struct vnode *a_vp, int a_fflag)
1191  *
1192  * a_fflag: note, 'F' modes, e.g. FREAD, FWRITE.  same as a_mode in stdopen?
1193  *
1194  * v_lastwrite_ts is used to record the timestamp that should be used to
1195  * set the file mtime for any asynchronously flushed pages modified via
1196  * mmap(), which can occur after the last close().
1197  */
1198 int
1199 vop_stdclose(struct vop_close_args *ap)
1200 {
1201         struct vnode *vp = ap->a_vp;
1202
1203         KASSERT(vp->v_opencount > 0,
1204                 ("VOP_STDCLOSE: BAD OPENCOUNT %p %d type=%d ops=%p flgs=%08x",
1205                 vp, vp->v_opencount, vp->v_type, *vp->v_ops, vp->v_flag));
1206         if (ap->a_fflag & FWRITE) {
1207                 KASSERT(vp->v_writecount > 0,
1208                         ("VOP_STDCLOSE: BAD WRITECOUNT %p %d",
1209                         vp, vp->v_writecount));
1210                 atomic_add_int(&vp->v_writecount, -1);
1211         }
1212         atomic_add_int(&vp->v_opencount, -1);
1213         return (0);
1214 }
1215
1216 /*
1217  * Implement standard getpages and putpages.  All filesystems must use
1218  * the buffer cache to back regular files.
1219  */
1220 int
1221 vop_stdgetpages(struct vop_getpages_args *ap)
1222 {
1223         struct mount *mp;
1224         int error;
1225
1226         if ((mp = ap->a_vp->v_mount) != NULL) {
1227                 error = vnode_pager_generic_getpages(
1228                                 ap->a_vp, ap->a_m, ap->a_count,
1229                                 ap->a_reqpage, ap->a_seqaccess);
1230         } else {
1231                 error = VM_PAGER_BAD;
1232         }
1233         return (error);
1234 }
1235
1236 int
1237 vop_stdputpages(struct vop_putpages_args *ap)
1238 {
1239         struct mount *mp;
1240         int error;
1241
1242         if ((mp = ap->a_vp->v_mount) != NULL) {
1243                 error = vnode_pager_generic_putpages(
1244                                 ap->a_vp, ap->a_m, ap->a_count,
1245                                 ap->a_sync, ap->a_rtvals);
1246         } else {
1247                 error = VM_PAGER_BAD;
1248         }
1249         return (error);
1250 }
1251
1252 int
1253 vop_stdnoread(struct vop_read_args *ap)
1254 {
1255         return (EINVAL);
1256 }
1257
1258 int
1259 vop_stdnowrite(struct vop_write_args *ap)
1260 {
1261         return (EINVAL);
1262 }
1263
1264 /* 
1265  * vfs default ops
1266  * used to fill the vfs fucntion table to get reasonable default return values.
1267  */
1268 int
1269 vop_stdmountctl(struct vop_mountctl_args *ap)
1270 {
1271
1272         struct mount *mp;
1273         int error = 0;
1274
1275         mp = ap->a_head.a_ops->head.vv_mount;
1276
1277         switch(ap->a_op) {
1278         case MOUNTCTL_MOUNTFLAGS:
1279                 /*
1280                  * Get a string buffer with all the mount flags
1281                  * names comman separated.
1282                  * mount(2) will use this information.
1283                  */
1284                 *ap->a_res = vfs_flagstostr(mp->mnt_flag & MNT_VISFLAGMASK, NULL,
1285                                             ap->a_buf, ap->a_buflen, &error);
1286                 break;
1287         case MOUNTCTL_INSTALL_VFS_JOURNAL:
1288         case MOUNTCTL_RESTART_VFS_JOURNAL:
1289         case MOUNTCTL_REMOVE_VFS_JOURNAL:
1290         case MOUNTCTL_RESYNC_VFS_JOURNAL:
1291         case MOUNTCTL_STATUS_VFS_JOURNAL:
1292                 error = journal_mountctl(ap);
1293                 break;
1294         default:
1295                 error = EOPNOTSUPP;
1296                 break;
1297         }
1298         return (error);
1299 }
1300
1301 int     
1302 vfs_stdroot(struct mount *mp, struct vnode **vpp)
1303 {
1304         return (EOPNOTSUPP);
1305 }
1306
1307 int     
1308 vfs_stdstatfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
1309 {
1310         return (EOPNOTSUPP);
1311 }
1312
1313 /*
1314  * If the VFS does not implement statvfs, then call statfs and convert
1315  * the values.  This code was taken from libc's __cvtstatvfs() function,
1316  * contributed by Joerg Sonnenberger.
1317  */
1318 int     
1319 vfs_stdstatvfs(struct mount *mp, struct statvfs *sbp, struct ucred *cred)
1320 {
1321         struct statfs *in;
1322         int error;
1323
1324         in = &mp->mnt_stat;
1325         error = VFS_STATFS(mp, in, cred);
1326         if (error == 0) {
1327                 bzero(sbp, sizeof(*sbp));
1328
1329                 sbp->f_bsize = in->f_bsize;
1330                 sbp->f_frsize = in->f_bsize;
1331                 sbp->f_blocks = in->f_blocks;
1332                 sbp->f_bfree = in->f_bfree;
1333                 sbp->f_bavail = in->f_bavail;
1334                 sbp->f_files = in->f_files;
1335                 sbp->f_ffree = in->f_ffree;
1336
1337                 /*
1338                  * XXX
1339                  * This field counts the number of available inodes to non-root
1340                  * users, but this information is not available via statfs.
1341                  * Just ignore this issue by returning the total number 
1342                  * instead.
1343                  */
1344                 sbp->f_favail = in->f_ffree;
1345
1346                 /*
1347                  * XXX
1348                  * This field has a different meaning for statfs and statvfs.
1349                  * For the former it is the cookie exported for NFS and not
1350                  * intended for normal userland use.
1351                  */
1352                 sbp->f_fsid = 0;
1353
1354                 sbp->f_flag = 0;
1355                 if (in->f_flags & MNT_RDONLY)
1356                         sbp->f_flag |= ST_RDONLY;
1357                 if (in->f_flags & MNT_NOSUID)
1358                         sbp->f_flag |= ST_NOSUID;
1359                 sbp->f_namemax = 0;
1360                 sbp->f_owner = in->f_owner;
1361                 /*
1362                  * XXX
1363                  * statfs contains the type as string, statvfs expects it as
1364                  * enumeration.
1365                  */
1366                 sbp->f_type = 0;
1367
1368                 sbp->f_syncreads = in->f_syncreads;
1369                 sbp->f_syncwrites = in->f_syncwrites;
1370                 sbp->f_asyncreads = in->f_asyncreads;
1371                 sbp->f_asyncwrites = in->f_asyncwrites;
1372         }
1373         return (error);
1374 }
1375
1376 int
1377 vfs_stdvptofh(struct vnode *vp, struct fid *fhp)
1378 {
1379         return (EOPNOTSUPP);
1380 }
1381
1382 int     
1383 vfs_stdstart(struct mount *mp, int flags)
1384 {
1385         return (0);
1386 }
1387
1388 int     
1389 vfs_stdquotactl(struct mount *mp, int cmds, uid_t uid,
1390         caddr_t arg, struct ucred *cred)
1391 {
1392         return (EOPNOTSUPP);
1393 }
1394
1395 int     
1396 vfs_stdsync(struct mount *mp, int waitfor)
1397 {
1398         return (0);
1399 }
1400
1401 int
1402 vfs_stdnosync(struct mount *mp, int waitfor)
1403 {
1404         return (EOPNOTSUPP);
1405 }
1406
1407 int     
1408 vfs_stdvget(struct mount *mp, struct vnode *dvp, ino_t ino, struct vnode **vpp)
1409 {
1410         return (EOPNOTSUPP);
1411 }
1412
1413 int     
1414 vfs_stdfhtovp(struct mount *mp, struct vnode *rootvp,
1415               struct fid *fhp, struct vnode **vpp)
1416 {
1417         return (EOPNOTSUPP);
1418 }
1419
1420 int 
1421 vfs_stdcheckexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
1422         struct ucred **credanonp)
1423 {
1424         return (EOPNOTSUPP);
1425 }
1426
1427 int
1428 vfs_stdinit(struct vfsconf *vfsp)
1429 {
1430         return (0);
1431 }
1432
1433 int
1434 vfs_stduninit(struct vfsconf *vfsp)
1435 {
1436         return(0);
1437 }
1438
1439 int
1440 vfs_stdextattrctl(struct mount *mp, int cmd, struct vnode *vp,
1441                  int attrnamespace, const char *attrname,
1442                  struct ucred *cred)
1443 {
1444         return(EOPNOTSUPP);
1445 }
1446
1447 #define ACCOUNTING_NB_FSTYPES 7
1448
1449 static const char *accounting_fstypes[ACCOUNTING_NB_FSTYPES] = {
1450         "ext2fs", "hammer", "mfs", "ntfs", "null", "tmpfs", "ufs" };
1451
1452 int
1453 vfs_stdac_init(struct mount *mp)
1454 {
1455         const char* fs_type;
1456         int i, fstype_ok = 0;
1457
1458         /* is mounted fs type one we want to do some accounting for ? */
1459         for (i=0; i<ACCOUNTING_NB_FSTYPES; i++) {
1460                 fs_type = accounting_fstypes[i];
1461                 if (strncmp(mp->mnt_stat.f_fstypename, fs_type,
1462                                         sizeof(mp->mnt_stat)) == 0) {
1463                         fstype_ok = 1;
1464                         break;
1465                 }
1466         }
1467         if (fstype_ok == 0)
1468                 return (0);
1469
1470         vq_init(mp);
1471         return (0);
1472 }
1473
1474 void
1475 vfs_stdac_done(struct mount *mp)
1476 {
1477         vq_done(mp);
1478 }
1479
1480 void
1481 vfs_stdncpgen_set(struct mount *mp, struct namecache *ncp)
1482 {
1483 }
1484
1485 int
1486 vfs_stdncpgen_test(struct mount *mp, struct namecache *ncp)
1487 {
1488         return 0;
1489 }
1490
1491 void
1492 vfs_stdmodifying(struct mount *mp)
1493 {
1494         /* do nothing */
1495 }
1496 /* end of vfs default ops */