1d49359c369403f0053334d7d219ba162c8f6d36
[dragonfly.git] / sys / kern / vfs_vopops.c
1 /*
2  * 
3  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
4  * 
5  * This code is derived from software contributed to The DragonFly Project
6  * by Matthew Dillon <dillon@backplane.com>
7  * 
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  * 3. Neither the name of The DragonFly Project nor the names of its
19  *    contributors may be used to endorse or promote products derived
20  *    from this software without specific, prior written permission.
21  * 
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  * 
35  * $DragonFly: src/sys/kern/vfs_vopops.c,v 1.4 2004/08/28 19:02:05 dillon Exp $
36  */
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/buf.h>
41 #include <sys/conf.h>
42 #include <sys/dirent.h>
43 #include <sys/domain.h>
44 #include <sys/eventhandler.h>
45 #include <sys/fcntl.h>
46 #include <sys/kernel.h>
47 #include <sys/kthread.h>
48 #include <sys/malloc.h>
49 #include <sys/mbuf.h>
50 #include <sys/mount.h>
51 #include <sys/proc.h>
52 #include <sys/namei.h>
53 #include <sys/reboot.h>
54 #include <sys/socket.h>
55 #include <sys/stat.h>
56 #include <sys/sysctl.h>
57 #include <sys/syslog.h>
58 #include <sys/vmmeter.h>
59 #include <sys/vnode.h>
60 #include <sys/vfsops.h>
61
62 #include <machine/limits.h>
63
64 #include <vm/vm.h>
65 #include <vm/vm_object.h>
66 #include <vm/vm_extern.h>
67 #include <vm/vm_kern.h>
68 #include <vm/pmap.h>
69 #include <vm/vm_map.h>
70 #include <vm/vm_page.h>
71 #include <vm/vm_pager.h>
72 #include <vm/vnode_pager.h>
73 #include <vm/vm_zone.h>
74
75 #include <sys/buf2.h>
76 #include <sys/thread2.h>
77
78 #define VOFFNAME(name)  __CONCAT(__CONCAT(vop_,name),_vp_offsets)
79 #define VDESCNAME(name) __CONCAT(__CONCAT(vop_,name),_desc)
80 #define VARGSSTRUCT(name) struct __CONCAT(__CONCAT(vop_,name),_args)
81
82 #define VNODEOP_DESC_INIT(name, flags, vpoffs, vpp, cred, proc, comp)   \
83         struct vnodeop_desc VDESCNAME(name) = {                         \
84                 __offsetof(struct vop_ops, __CONCAT(vop_, name)),       \
85                 #name, flags, vpoffs, vpp, cred, proc, comp }
86
87 #define VNODEOP_DESC_INIT_SIMPLE(name)                                  \
88         VNODEOP_DESC_INIT(name, 0, NULL,                                \
89                 VDESC_NO_OFFSET,                                        \
90                 VDESC_NO_OFFSET,                                        \
91                 VDESC_NO_OFFSET,                                        \
92                 VDESC_NO_OFFSET)
93
94 #define VNODEOP_DESC_INIT_VP(name)                                      \
95         static int VOFFNAME(name)[] = {                                 \
96                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
97                 VDESC_NO_OFFSET };                                      \
98         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
99                 VDESC_NO_OFFSET,                                        \
100                 VDESC_NO_OFFSET,                                        \
101                 VDESC_NO_OFFSET,                                        \
102                 VDESC_NO_OFFSET)
103
104 #define VNODEOP_DESC_INIT_VP_VPP(name)                                  \
105         static int VOFFNAME(name)[] = {                                 \
106                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
107                 VDESC_NO_OFFSET };                                      \
108         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
109                 __offsetof(VARGSSTRUCT(name), a_vpp),                   \
110                 VDESC_NO_OFFSET,                                        \
111                 VDESC_NO_OFFSET,                                        \
112                 VDESC_NO_OFFSET)
113
114 #define VNODEOP_DESC_INIT_VP_CRED(name)                                 \
115         static int VOFFNAME(name)[] = {                                 \
116                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
117                 VDESC_NO_OFFSET };                                      \
118         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
119                 VDESC_NO_OFFSET,                                        \
120                 __offsetof(VARGSSTRUCT(name), a_cred),                  \
121                 VDESC_NO_OFFSET,                                        \
122                 VDESC_NO_OFFSET)
123
124 #define VNODEOP_DESC_INIT_DVP_VPP_CNP(name)                             \
125         static int VOFFNAME(name)[] = {                                 \
126                 __offsetof(VARGSSTRUCT(name), a_dvp),                   \
127                 VDESC_NO_OFFSET };                                      \
128         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
129                 __offsetof(VARGSSTRUCT(name), a_vpp),                   \
130                 VDESC_NO_OFFSET,                                        \
131                 VDESC_NO_OFFSET,                                        \
132                 __offsetof(VARGSSTRUCT(name), a_cnp))
133
134 #define VNODEOP_DESC_INIT_DVP_CNP(name)                                 \
135         static int VOFFNAME(name)[] = {                                 \
136                 __offsetof(VARGSSTRUCT(name), a_dvp),                   \
137                 VDESC_NO_OFFSET };                                      \
138         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
139                 VDESC_NO_OFFSET,                                        \
140                 VDESC_NO_OFFSET,                                        \
141                 VDESC_NO_OFFSET,                                        \
142                 __offsetof(VARGSSTRUCT(name), a_cnp))
143
144 #define VNODEOP_DESC_INIT_DVP_VP_CNP(name)                              \
145         static int VOFFNAME(name)[] = {                                 \
146                 __offsetof(VARGSSTRUCT(name), a_dvp),                   \
147                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
148                 VDESC_NO_OFFSET };                                      \
149         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
150                 VDESC_NO_OFFSET,                                        \
151                 VDESC_NO_OFFSET,                                        \
152                 VDESC_NO_OFFSET,                                        \
153                 __offsetof(VARGSSTRUCT(name), a_cnp))
154
155 #define VNODEOP_DESC_INIT_TDVP_VP_CNP(name)                             \
156         static int VOFFNAME(name)[] = {                                 \
157                 __offsetof(VARGSSTRUCT(name), a_tdvp),                  \
158                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
159                 VDESC_NO_OFFSET };                                      \
160         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
161                 VDESC_NO_OFFSET,                                        \
162                 VDESC_NO_OFFSET,                                        \
163                 VDESC_NO_OFFSET,                                        \
164                 __offsetof(VARGSSTRUCT(name), a_cnp))
165
166 VNODEOP_DESC_INIT_SIMPLE(default);
167 VNODEOP_DESC_INIT_VP(islocked);
168 VNODEOP_DESC_INIT_DVP_VPP_CNP(lookup);
169 VNODEOP_DESC_INIT_DVP_VPP_CNP(cachedlookup);
170 VNODEOP_DESC_INIT_DVP_VPP_CNP(create);
171 VNODEOP_DESC_INIT_DVP_CNP(whiteout);
172 VNODEOP_DESC_INIT_DVP_VPP_CNP(mknod);
173 VNODEOP_DESC_INIT_VP_CRED(open);
174 VNODEOP_DESC_INIT_VP(close);
175 VNODEOP_DESC_INIT_VP_CRED(access);
176 VNODEOP_DESC_INIT_VP(getattr);
177 VNODEOP_DESC_INIT_VP_CRED(setattr);
178 VNODEOP_DESC_INIT_VP_CRED(read);
179 VNODEOP_DESC_INIT_VP_CRED(write);
180 VNODEOP_DESC_INIT_VP_CRED(lease);
181 VNODEOP_DESC_INIT_VP_CRED(ioctl);
182 VNODEOP_DESC_INIT_VP_CRED(poll);
183 VNODEOP_DESC_INIT_VP(kqfilter);
184 VNODEOP_DESC_INIT_VP(revoke);
185 VNODEOP_DESC_INIT_VP_CRED(mmap);
186 VNODEOP_DESC_INIT_VP(fsync);
187 VNODEOP_DESC_INIT_DVP_VP_CNP(remove);
188 VNODEOP_DESC_INIT_TDVP_VP_CNP(link);
189
190 static int VOFFNAME(rename)[] = { 
191         __offsetof(VARGSSTRUCT(rename), a_fdvp),
192         __offsetof(VARGSSTRUCT(rename), a_fvp),
193         __offsetof(VARGSSTRUCT(rename), a_tdvp),
194         __offsetof(VARGSSTRUCT(rename), a_tvp),
195         VDESC_NO_OFFSET
196 };
197 VNODEOP_DESC_INIT(rename, 
198         VDESC_VP0_WILLRELE|VDESC_VP1_WILLRELE|
199          VDESC_VP2_WILLRELE|VDESC_VP3_WILLRELE|
200          VDESC_VP2_WILLUNLOCK|VDESC_VP3_WILLUNLOCK, /* tdvp and tvp */
201         VOFFNAME(rename),
202         VDESC_NO_OFFSET,
203         VDESC_NO_OFFSET,
204         VDESC_NO_OFFSET,
205         __offsetof(VARGSSTRUCT(rename), a_fcnp));
206 VNODEOP_DESC_INIT_DVP_VPP_CNP(mkdir);
207 VNODEOP_DESC_INIT_DVP_VP_CNP(rmdir);
208 VNODEOP_DESC_INIT_DVP_VPP_CNP(symlink);
209 VNODEOP_DESC_INIT_VP_CRED(readdir);
210 VNODEOP_DESC_INIT_VP_CRED(readlink);
211 VNODEOP_DESC_INIT_VP(inactive);
212 VNODEOP_DESC_INIT_VP(reclaim);
213 VNODEOP_DESC_INIT_VP(lock);
214 VNODEOP_DESC_INIT_VP(unlock);
215 VNODEOP_DESC_INIT_VP_VPP(bmap);
216 VNODEOP_DESC_INIT_VP(strategy);
217 VNODEOP_DESC_INIT_VP(print);
218 VNODEOP_DESC_INIT_VP(pathconf);
219 VNODEOP_DESC_INIT_VP(advlock);
220 VNODEOP_DESC_INIT_VP_CRED(balloc);
221 VNODEOP_DESC_INIT_VP(reallocblks);
222 VNODEOP_DESC_INIT_VP(getpages);
223 VNODEOP_DESC_INIT_VP(putpages);
224 VNODEOP_DESC_INIT_VP(freeblks);
225 VNODEOP_DESC_INIT_VP(bwrite);
226 VNODEOP_DESC_INIT_VP_CRED(getacl);
227 VNODEOP_DESC_INIT_VP_CRED(setacl);
228 VNODEOP_DESC_INIT_VP_CRED(aclcheck);
229 VNODEOP_DESC_INIT_VP_CRED(getextattr);
230 VNODEOP_DESC_INIT_VP_CRED(setextattr);
231 VNODEOP_DESC_INIT_VP(createvobject);
232 VNODEOP_DESC_INIT_VP(destroyvobject);
233 VNODEOP_DESC_INIT_VP(getvobject);
234 VNODEOP_DESC_INIT_SIMPLE(vfsset);
235
236 /*
237  * The DO_OPS macro basicallys calls ops->blah(&ap) but is also responsible
238  * for checking vv_flags and executing additional hook functions.
239  *
240  * NOTE: vop_vnoperate_ap() rolls its own DO_OPS equivalent.
241  */
242 #define DO_OPS(ops, error, ap, vop_field)                               \
243         if (ops->vv_flags & VVF_HOOK_MASK) {                            \
244                 if (ops->vv_flags & VVF_JOURNAL_HOOK)                   \
245                         error = ops->vv_jops->vop_field(ap);            \
246                 else                                                    \
247                         error = 0;                                      \
248                 if (error == 0)                                         \
249                         error = ops->vop_field(ap);                     \
250         } else {                                                        \
251                 error = ops->vop_field(ap);                             \
252         }                                                               \
253
254
255 /************************************************************************
256  *              PRIMARY HIGH LEVEL VNODE OPERATIONS CALLS               *
257  ************************************************************************
258  *
259  * These procedures are called directly from the kernel and/or fileops 
260  * code to perform file/device operations on the system.
261  */
262
263 int
264 vop_islocked(struct vop_ops *ops, struct vnode *vp, struct thread *td)
265 {
266         struct vop_islocked_args ap;
267         int error;
268
269         ap.a_head.a_desc = &vop_islocked_desc;
270         ap.a_head.a_ops = ops;
271         ap.a_vp = vp;
272         ap.a_td = td;
273
274         DO_OPS(ops, error, &ap, vop_islocked);
275         return(error);
276 }
277
278 int
279 vop_lookup(struct vop_ops *ops, struct vnode *dvp,
280         struct namecache *par, struct vnode **vpp,
281         struct namecache **ncpp, struct componentname *cnp)
282 {
283         struct vop_lookup_args ap;
284         int error;
285
286         ap.a_head.a_desc = &vop_lookup_desc;
287         ap.a_head.a_ops = ops;
288         ap.a_dvp = dvp;
289         ap.a_par = par;
290         ap.a_vpp = vpp;
291         ap.a_ncpp = ncpp;
292         ap.a_cnp = cnp;
293
294         DO_OPS(ops, error, &ap, vop_lookup);
295         return(error);
296 }
297
298 int
299 vop_cachedlookup(struct vop_ops *ops, struct vnode *dvp,
300         struct namecache *par, struct vnode **vpp,
301         struct namecache **ncpp, struct componentname *cnp)
302 {
303         struct vop_cachedlookup_args ap;
304         int error;
305
306         ap.a_head.a_desc = &vop_cachedlookup_desc;
307         ap.a_head.a_ops = ops;
308         ap.a_dvp = dvp;
309         ap.a_par = par;
310         ap.a_vpp = vpp;
311         ap.a_ncpp = ncpp;
312         ap.a_cnp = cnp;
313
314         DO_OPS(ops, error, &ap, vop_cachedlookup);
315         return(error);
316 }
317
318 int
319 vop_create(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
320         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
321 {
322         struct vop_create_args ap;
323         int error;
324
325         ap.a_head.a_desc = &vop_create_desc;
326         ap.a_head.a_ops = ops;
327         ap.a_dvp = dvp;
328         ap.a_par = par;
329         ap.a_vpp = vpp;
330         ap.a_cnp = cnp;
331         ap.a_vap = vap;
332
333         DO_OPS(ops, error, &ap, vop_create);
334         return(error);
335 }
336
337 int
338 vop_whiteout(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
339         struct componentname *cnp, int flags)
340 {
341         struct vop_whiteout_args ap;
342         int error;
343
344         ap.a_head.a_desc = &vop_whiteout_desc;
345         ap.a_head.a_ops = ops;
346         ap.a_dvp = dvp;
347         ap.a_par = par;
348         ap.a_cnp = cnp;
349         ap.a_flags = flags;
350
351         DO_OPS(ops, error, &ap, vop_whiteout);
352         return(error);
353 }
354
355 int
356 vop_mknod(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
357         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
358 {
359         struct vop_mknod_args ap;
360         int error;
361
362         ap.a_head.a_desc = &vop_mknod_desc;
363         ap.a_head.a_ops = ops;
364         ap.a_dvp = dvp;
365         ap.a_par = par;
366         ap.a_vpp = vpp;
367         ap.a_cnp = cnp;
368         ap.a_vap = vap;
369
370         DO_OPS(ops, error, &ap, vop_mknod);
371         return(error);
372 }
373
374 int
375 vop_open(struct vop_ops *ops, struct vnode *vp, int mode, struct ucred *cred,
376         struct thread *td)
377 {
378         struct vop_open_args ap;
379         int error;
380
381         ap.a_head.a_desc = &vop_open_desc;
382         ap.a_head.a_ops = ops;
383         ap.a_vp = vp;
384         ap.a_mode = mode;
385         ap.a_cred = cred;
386         ap.a_td = td;
387
388         DO_OPS(ops, error, &ap, vop_open);
389         return(error);
390 }
391
392 int
393 vop_close(struct vop_ops *ops, struct vnode *vp, int fflag, struct thread *td)
394 {
395         struct vop_close_args ap;
396         int error;
397
398         ap.a_head.a_desc = &vop_close_desc;
399         ap.a_head.a_ops = ops;
400         ap.a_vp = vp;
401         ap.a_fflag = fflag;
402         ap.a_td = td;
403
404         DO_OPS(ops, error, &ap, vop_close);
405         return(error);
406 }
407
408 int
409 vop_access(struct vop_ops *ops, struct vnode *vp, int mode, struct ucred *cred,
410         struct thread *td)
411 {
412         struct vop_access_args ap;
413         int error;
414
415         ap.a_head.a_desc = &vop_access_desc;
416         ap.a_head.a_ops = ops;
417         ap.a_vp = vp;
418         ap.a_mode = mode;
419         ap.a_cred = cred;
420         ap.a_td = td;
421
422         DO_OPS(ops, error, &ap, vop_access);
423         return(error);
424 }
425
426 int
427 vop_getattr(struct vop_ops *ops, struct vnode *vp, struct vattr *vap,
428         struct thread *td)
429 {
430         struct vop_getattr_args ap;
431         int error;
432
433         ap.a_head.a_desc = &vop_getattr_desc;
434         ap.a_head.a_ops = ops;
435         ap.a_vp = vp;
436         ap.a_vap = vap;
437         ap.a_td = td;
438
439         DO_OPS(ops, error, &ap, vop_getattr);
440         return(error);
441 }
442
443 int
444 vop_setattr(struct vop_ops *ops, struct vnode *vp, struct vattr *vap,
445         struct ucred *cred, struct thread *td)
446 {
447         struct vop_setattr_args ap;
448         int error;
449
450         ap.a_head.a_desc = &vop_setattr_desc;
451         ap.a_head.a_ops = ops;
452         ap.a_vp = vp;
453         ap.a_vap = vap;
454         ap.a_cred = cred;
455         ap.a_td = td;
456
457         DO_OPS(ops, error, &ap, vop_setattr);
458         return(error);
459 }
460
461 int
462 vop_read(struct vop_ops *ops, struct vnode *vp, struct uio *uio, int ioflag,
463         struct ucred *cred)
464 {
465         struct vop_read_args ap;
466         int error;
467
468         ap.a_head.a_desc = &vop_read_desc;
469         ap.a_head.a_ops = ops;
470         ap.a_vp = vp;
471         ap.a_uio = uio;
472         ap.a_ioflag = ioflag;
473         ap.a_cred = cred;
474
475         DO_OPS(ops, error, &ap, vop_read);
476         return(error);
477 }
478
479 int
480 vop_write(struct vop_ops *ops, struct vnode *vp, struct uio *uio, int ioflag,
481         struct ucred *cred)
482 {
483         struct vop_write_args ap;
484         int error;
485
486         ap.a_head.a_desc = &vop_write_desc;
487         ap.a_head.a_ops = ops;
488         ap.a_vp = vp;
489         ap.a_uio = uio;
490         ap.a_ioflag = ioflag;
491         ap.a_cred = cred;
492
493         DO_OPS(ops, error, &ap, vop_write);
494         return(error);
495 }
496
497 int
498 vop_lease(struct vop_ops *ops, struct vnode *vp, struct thread *td,
499         struct ucred *cred, int flag)
500 {
501         struct vop_lease_args ap;
502         int error;
503
504         ap.a_head.a_desc = &vop_lease_desc;
505         ap.a_head.a_ops = ops;
506         ap.a_vp = vp;
507         ap.a_td = td;
508         ap.a_cred = cred;
509         ap.a_flag = flag;
510
511         DO_OPS(ops, error, &ap, vop_lease);
512         return(error);
513 }
514
515 int
516 vop_ioctl(struct vop_ops *ops, struct vnode *vp, u_long command, caddr_t data,
517         int fflag, struct ucred *cred,
518         struct thread *td)
519 {
520         struct vop_ioctl_args ap;
521         int error;
522
523         ap.a_head.a_desc = &vop_ioctl_desc;
524         ap.a_head.a_ops = ops;
525         ap.a_vp = vp;
526         ap.a_command = command;
527         ap.a_data = data;
528         ap.a_fflag = fflag;
529         ap.a_cred = cred;
530         ap.a_td = td;
531
532         DO_OPS(ops, error, &ap, vop_ioctl);
533         return(error);
534 }
535
536 int
537 vop_poll(struct vop_ops *ops, struct vnode *vp, int events, struct ucred *cred,
538         struct thread *td)
539 {
540         struct vop_poll_args ap;
541         int error;
542
543         ap.a_head.a_desc = &vop_poll_desc;
544         ap.a_head.a_ops = ops;
545         ap.a_vp = vp;
546         ap.a_events = events;
547         ap.a_cred = cred;
548         ap.a_td = td;
549
550         DO_OPS(ops, error, &ap, vop_poll);
551         return(error);
552 }
553
554 int
555 vop_kqfilter(struct vop_ops *ops, struct vnode *vp, struct knote *kn)
556 {
557         struct vop_kqfilter_args ap;
558         int error;
559
560         ap.a_head.a_desc = &vop_kqfilter_desc;
561         ap.a_head.a_ops = ops;
562         ap.a_vp = vp;
563         ap.a_kn = kn;
564
565         DO_OPS(ops, error, &ap, vop_kqfilter);
566         return(error);
567 }
568
569 int
570 vop_revoke(struct vop_ops *ops, struct vnode *vp, int flags)
571 {
572         struct vop_revoke_args ap;
573         int error;
574
575         ap.a_head.a_desc = &vop_revoke_desc;
576         ap.a_head.a_ops = ops;
577         ap.a_vp = vp;
578         ap.a_flags = flags;
579
580         DO_OPS(ops, error, &ap, vop_revoke);
581         return(error);
582 }
583
584 int
585 vop_mmap(struct vop_ops *ops, struct vnode *vp, int fflags, struct ucred *cred,
586         struct thread *td)
587 {
588         struct vop_mmap_args ap;
589         int error;
590
591         ap.a_head.a_desc = &vop_mmap_desc;
592         ap.a_head.a_ops = ops;
593         ap.a_vp = vp;
594         ap.a_fflags = fflags;
595         ap.a_cred = cred;
596         ap.a_td = td;
597
598         DO_OPS(ops, error, &ap, vop_mmap);
599         return(error);
600 }
601
602 int
603 vop_fsync(struct vop_ops *ops, struct vnode *vp, int waitfor, struct thread *td)
604 {
605         struct vop_fsync_args ap;
606         int error;
607
608         ap.a_head.a_desc = &vop_fsync_desc;
609         ap.a_head.a_ops = ops;
610         ap.a_vp = vp;
611         ap.a_waitfor = waitfor;
612         ap.a_td = td;
613
614         DO_OPS(ops, error, &ap, vop_fsync);
615         return(error);
616 }
617
618 int
619 vop_remove(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
620         struct vnode *vp, struct componentname *cnp)
621 {
622         struct vop_remove_args ap;
623         int error;
624
625         ap.a_head.a_desc = &vop_remove_desc;
626         ap.a_head.a_ops = ops;
627         ap.a_dvp = dvp;
628         ap.a_par = par;
629         ap.a_vp = vp;
630         ap.a_cnp = cnp;
631
632         DO_OPS(ops, error, &ap, vop_remove);
633         return(error);
634 }
635
636 int
637 vop_link(struct vop_ops *ops, struct vnode *tdvp, struct namecache *par,
638         struct vnode *vp, struct componentname *cnp)
639 {
640         struct vop_link_args ap;
641         int error;
642
643         ap.a_head.a_desc = &vop_link_desc;
644         ap.a_head.a_ops = ops;
645         ap.a_tdvp = tdvp;
646         ap.a_par = par;
647         ap.a_vp = vp;
648         ap.a_cnp = cnp;
649
650         DO_OPS(ops, error, &ap, vop_link);
651         return(error);
652 }
653
654 int
655 vop_rename(struct vop_ops *ops, struct vnode *fdvp, struct namecache *fpar,
656         struct vnode *fvp, struct componentname *fcnp,
657         struct vnode *tdvp, struct namecache *tpar,
658         struct vnode *tvp, struct componentname *tcnp)
659 {
660         struct vop_rename_args ap;
661         int error;
662
663         ap.a_head.a_desc = &vop_rename_desc;
664         ap.a_head.a_ops = ops;
665         ap.a_fdvp = fdvp;
666         ap.a_fpar = fpar;
667         ap.a_fvp = fvp;
668         ap.a_fcnp = fcnp;
669         ap.a_tdvp = tdvp;
670         ap.a_tpar = tpar;
671         ap.a_tvp = tvp;
672         ap.a_tcnp = tcnp;
673
674         DO_OPS(ops, error, &ap, vop_rename);
675         return(error);
676 }
677
678 int
679 vop_mkdir(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
680         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
681 {
682         struct vop_mkdir_args ap;
683         int error;
684
685         ap.a_head.a_desc = &vop_mkdir_desc;
686         ap.a_head.a_ops = ops;
687         ap.a_dvp = dvp;
688         ap.a_par = par;
689         ap.a_vpp = vpp;
690         ap.a_cnp = cnp;
691         ap.a_vap = vap;
692
693         DO_OPS(ops, error, &ap, vop_mkdir);
694         return(error);
695 }
696
697 int
698 vop_rmdir(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
699         struct vnode *vp, struct componentname *cnp)
700 {
701         struct vop_rmdir_args ap;
702         int error;
703
704         ap.a_head.a_desc = &vop_rmdir_desc;
705         ap.a_head.a_ops = ops;
706         ap.a_dvp = dvp;
707         ap.a_par = par;
708         ap.a_vp = vp;
709         ap.a_cnp = cnp;
710
711         DO_OPS(ops, error, &ap, vop_rmdir);
712         return(error);
713 }
714
715 int
716 vop_symlink(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
717         struct vnode **vpp, struct componentname *cnp,
718         struct vattr *vap, char *target)
719 {
720         struct vop_symlink_args ap;
721         int error;
722
723         ap.a_head.a_desc = &vop_symlink_desc;
724         ap.a_head.a_ops = ops;
725         ap.a_dvp = dvp;
726         ap.a_par = par;
727         ap.a_vpp = vpp;
728         ap.a_cnp = cnp;
729         ap.a_vap = vap;
730         ap.a_target = target;
731
732         DO_OPS(ops, error, &ap, vop_symlink);
733         return(error);
734 }
735
736 int
737 vop_readdir(struct vop_ops *ops, struct vnode *vp, struct uio *uio,
738         struct ucred *cred, int *eofflag, int *ncookies, u_long **cookies)
739 {
740         struct vop_readdir_args ap;
741         int error;
742
743         ap.a_head.a_desc = &vop_readdir_desc;
744         ap.a_head.a_ops = ops;
745         ap.a_vp = vp;
746         ap.a_uio = uio;
747         ap.a_cred = cred;
748         ap.a_eofflag = eofflag;
749         ap.a_ncookies = ncookies;
750         ap.a_cookies = cookies;
751
752         DO_OPS(ops, error, &ap, vop_readdir);
753         return(error);
754 }
755
756 int
757 vop_readlink(struct vop_ops *ops, struct vnode *vp, struct uio *uio,
758         struct ucred *cred)
759 {
760         struct vop_readlink_args ap;
761         int error;
762
763         ap.a_head.a_desc = &vop_readlink_desc;
764         ap.a_head.a_ops = ops;
765         ap.a_vp = vp;
766         ap.a_uio = uio;
767         ap.a_cred = cred;
768
769         DO_OPS(ops, error, &ap, vop_readlink);
770         return(error);
771 }
772
773 int
774 vop_inactive(struct vop_ops *ops, struct vnode *vp, struct thread *td)
775 {
776         struct vop_inactive_args ap;
777         int error;
778
779         ap.a_head.a_desc = &vop_inactive_desc;
780         ap.a_head.a_ops = ops;
781         ap.a_vp = vp;
782         ap.a_td = td;
783
784         DO_OPS(ops, error, &ap, vop_inactive);
785         return(error);
786 }
787
788 int
789 vop_reclaim(struct vop_ops *ops, struct vnode *vp, struct thread *td)
790 {
791         struct vop_reclaim_args ap;
792         int error;
793
794         ap.a_head.a_desc = &vop_reclaim_desc;
795         ap.a_head.a_ops = ops;
796         ap.a_vp = vp;
797         ap.a_td = td;
798
799         DO_OPS(ops, error, &ap, vop_reclaim);
800         return(error);
801 }
802
803 int
804 vop_lock(struct vop_ops *ops, struct vnode *vp, struct lwkt_tokref *vlock,
805         int flags, struct thread *td)
806 {
807         struct vop_lock_args ap;
808         int error;
809
810         ap.a_head.a_desc = &vop_lock_desc;
811         ap.a_head.a_ops = ops;
812         ap.a_vp = vp;
813         ap.a_vlock = vlock;
814         ap.a_flags = flags;
815         ap.a_td = td;
816
817         DO_OPS(ops, error, &ap, vop_lock);
818         return(error);
819 }
820
821 int
822 vop_unlock(struct vop_ops *ops, struct vnode *vp, struct lwkt_tokref *vlock,
823         int flags, struct thread *td)
824 {
825         struct vop_unlock_args ap;
826         int error;
827
828         ap.a_head.a_desc = &vop_unlock_desc;
829         ap.a_head.a_ops = ops;
830         ap.a_vp = vp;
831         ap.a_vlock = vlock;
832         ap.a_flags = flags;
833         ap.a_td = td;
834
835         DO_OPS(ops, error, &ap, vop_unlock);
836         return(error);
837 }
838
839 int
840 vop_bmap(struct vop_ops *ops, struct vnode *vp, daddr_t bn, struct vnode **vpp,
841         daddr_t *bnp, int *runp, int *runb)
842 {
843         struct vop_bmap_args ap;
844         int error;
845
846         ap.a_head.a_desc = &vop_bmap_desc;
847         ap.a_head.a_ops = ops;
848         ap.a_vp = vp;
849         ap.a_bn = bn;
850         ap.a_vpp = vpp;
851         ap.a_bnp = bnp;
852         ap.a_runp = runp;
853         ap.a_runb = runb;
854
855         DO_OPS(ops, error, &ap, vop_bmap);
856         return(error);
857 }
858
859 int
860 vop_strategy(struct vop_ops *ops, struct vnode *vp, struct buf *bp)
861 {
862         struct vop_strategy_args ap;
863         int error;
864
865         ap.a_head.a_desc = &vop_strategy_desc;
866         ap.a_head.a_ops = ops;
867         ap.a_vp = vp;
868         ap.a_bp = bp;
869
870         DO_OPS(ops, error, &ap, vop_strategy);
871         return(error);
872 }
873
874 int
875 vop_print(struct vop_ops *ops, struct vnode *vp)
876 {
877         struct vop_print_args ap;
878         int error;
879
880         ap.a_head.a_desc = &vop_print_desc;
881         ap.a_head.a_ops = ops;
882         ap.a_vp = vp;
883
884         DO_OPS(ops, error, &ap, vop_print);
885         return(error);
886 }
887
888 int
889 vop_pathconf(struct vop_ops *ops, struct vnode *vp, int name,
890         register_t *retval)
891 {
892         struct vop_pathconf_args ap;
893         int error;
894
895         ap.a_head.a_desc = &vop_pathconf_desc;
896         ap.a_head.a_ops = ops;
897         ap.a_vp = vp;
898         ap.a_name = name;
899         ap.a_retval = retval;
900
901         DO_OPS(ops, error, &ap, vop_pathconf);
902         return(error);
903 }
904
905 int
906 vop_advlock(struct vop_ops *ops, struct vnode *vp, caddr_t id, int op,
907         struct flock *fl, int flags)
908 {
909         struct vop_advlock_args ap;
910         int error;
911
912         ap.a_head.a_desc = &vop_advlock_desc;
913         ap.a_head.a_ops = ops;
914         ap.a_vp = vp;
915         ap.a_id = id;
916         ap.a_op = op;
917         ap.a_fl = fl;
918         ap.a_flags = flags;
919
920         DO_OPS(ops, error, &ap, vop_advlock);
921         return(error);
922 }
923
924 int
925 vop_balloc(struct vop_ops *ops, struct vnode *vp, off_t startoffset,
926         int size, struct ucred *cred, int flags,
927         struct buf **bpp)
928 {
929         struct vop_balloc_args ap;
930         int error;
931
932         ap.a_head.a_desc = &vop_balloc_desc;
933         ap.a_head.a_ops = ops;
934         ap.a_vp = vp;
935         ap.a_startoffset = startoffset;
936         ap.a_size = size;
937         ap.a_cred = cred;
938         ap.a_flags = flags;
939         ap.a_bpp = bpp;
940
941         DO_OPS(ops, error, &ap, vop_balloc);
942         return(error);
943 }
944
945 int
946 vop_reallocblks(struct vop_ops *ops, struct vnode *vp,
947         struct cluster_save *buflist)
948 {
949         struct vop_reallocblks_args ap;
950         int error;
951
952         ap.a_head.a_desc = &vop_reallocblks_desc;
953         ap.a_head.a_ops = ops;
954         ap.a_vp = vp;
955         ap.a_buflist = buflist;
956
957         DO_OPS(ops, error, &ap, vop_reallocblks);
958         return(error);
959 }
960
961 int
962 vop_getpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count,
963         int reqpage, vm_ooffset_t offset)
964 {
965         struct vop_getpages_args ap;
966         int error;
967
968         ap.a_head.a_desc = &vop_getpages_desc;
969         ap.a_head.a_ops = ops;
970         ap.a_vp = vp;
971         ap.a_m = m;
972         ap.a_count = count;
973         ap.a_reqpage = reqpage;
974         ap.a_offset = offset;
975
976         DO_OPS(ops, error, &ap, vop_getpages);
977         return(error);
978 }
979
980 int
981 vop_putpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count,
982         int sync, int *rtvals, vm_ooffset_t offset)
983 {
984         struct vop_putpages_args ap;
985         int error;
986
987         ap.a_head.a_desc = &vop_putpages_desc;
988         ap.a_head.a_ops = ops;
989         ap.a_vp = vp;
990         ap.a_m = m;
991         ap.a_count = count;
992         ap.a_sync = sync;
993         ap.a_rtvals = rtvals;
994         ap.a_offset = offset;
995
996         DO_OPS(ops, error, &ap, vop_putpages);
997         return(error);
998 }
999
1000 int
1001 vop_freeblks(struct vop_ops *ops, struct vnode *vp,
1002         daddr_t addr, daddr_t length)
1003 {
1004         struct vop_freeblks_args ap;
1005         int error;
1006
1007         ap.a_head.a_desc = &vop_freeblks_desc;
1008         ap.a_head.a_ops = ops;
1009         ap.a_vp = vp;
1010         ap.a_addr = addr;
1011         ap.a_length = length;
1012
1013         DO_OPS(ops, error, &ap, vop_freeblks);
1014         return(error);
1015 }
1016
1017 int
1018 vop_bwrite(struct vop_ops *ops, struct vnode *vp, struct buf *bp)
1019 {
1020         struct vop_bwrite_args ap;
1021         int error;
1022
1023         ap.a_head.a_desc = &vop_bwrite_desc;
1024         ap.a_head.a_ops = ops;
1025         ap.a_vp = vp;
1026         ap.a_bp = bp;
1027
1028         DO_OPS(ops, error, &ap, vop_bwrite);
1029         return(error);
1030 }
1031
1032 int
1033 vop_getacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
1034         struct acl *aclp, struct ucred *cred, struct thread *td)
1035 {
1036         struct vop_getacl_args ap;
1037         int error;
1038
1039         ap.a_head.a_desc = &vop_getacl_desc;
1040         ap.a_head.a_ops = ops;
1041         ap.a_vp = vp;
1042         ap.a_type = type;
1043         ap.a_aclp = aclp;
1044         ap.a_cred = cred;
1045         ap.a_td = td;
1046
1047         DO_OPS(ops, error, &ap, vop_getacl);
1048         return(error);
1049 }
1050
1051 int
1052 vop_setacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
1053         struct acl *aclp, struct ucred *cred, struct thread *td)
1054 {
1055         struct vop_setacl_args ap;
1056         int error;
1057
1058         ap.a_head.a_desc = &vop_setacl_desc;
1059         ap.a_head.a_ops = ops;
1060         ap.a_vp = vp;
1061         ap.a_type = type;
1062         ap.a_aclp = aclp;
1063         ap.a_cred = cred;
1064         ap.a_td = td;
1065
1066         DO_OPS(ops, error, &ap, vop_setacl);
1067         return(error);
1068 }
1069
1070 int
1071 vop_aclcheck(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
1072         struct acl *aclp, struct ucred *cred, struct thread *td)
1073 {
1074         struct vop_aclcheck_args ap;
1075         int error;
1076
1077         ap.a_head.a_desc = &vop_aclcheck_desc;
1078         ap.a_head.a_ops = ops;
1079         ap.a_vp = vp;
1080         ap.a_type = type;
1081         ap.a_aclp = aclp;
1082         ap.a_cred = cred;
1083         ap.a_td = td;
1084
1085         DO_OPS(ops, error, &ap, vop_aclcheck);
1086         return(error);
1087 }
1088
1089 int
1090 vop_getextattr(struct vop_ops *ops, struct vnode *vp, char *name, 
1091         struct uio *uio, struct ucred *cred, struct thread *td)
1092 {
1093         struct vop_getextattr_args ap;
1094         int error;
1095
1096         ap.a_head.a_desc = &vop_getextattr_desc;
1097         ap.a_head.a_ops = ops;
1098         ap.a_vp = vp;
1099         ap.a_name = name;
1100         ap.a_uio = uio;
1101         ap.a_cred = cred;
1102         ap.a_td = td;
1103
1104         DO_OPS(ops, error, &ap, vop_getextattr);
1105         return(error);
1106 }
1107
1108 int
1109 vop_setextattr(struct vop_ops *ops, struct vnode *vp, char *name, 
1110         struct uio *uio, struct ucred *cred, struct thread *td)
1111 {
1112         struct vop_setextattr_args ap;
1113         int error;
1114
1115         ap.a_head.a_desc = &vop_setextattr_desc;
1116         ap.a_head.a_ops = ops;
1117         ap.a_vp = vp;
1118         ap.a_name = name;
1119         ap.a_uio = uio;
1120         ap.a_cred = cred;
1121         ap.a_td = td;
1122
1123         DO_OPS(ops, error, &ap, vop_setextattr);
1124         return(error);
1125 }
1126
1127 int
1128 vop_createvobject(struct vop_ops *ops, struct vnode *vp, struct thread *td)
1129 {
1130         struct vop_createvobject_args ap;
1131         int error;
1132
1133         ap.a_head.a_desc = &vop_createvobject_desc;
1134         ap.a_head.a_ops = ops;
1135         ap.a_vp = vp;
1136         ap.a_td = td;
1137
1138         DO_OPS(ops, error, &ap, vop_createvobject);
1139         return(error);
1140 }
1141
1142 int
1143 vop_destroyvobject(struct vop_ops *ops, struct vnode *vp)
1144 {
1145         struct vop_destroyvobject_args ap;
1146         int error;
1147
1148         ap.a_head.a_desc = &vop_destroyvobject_desc;
1149         ap.a_head.a_ops = ops;
1150         ap.a_vp = vp;
1151
1152         DO_OPS(ops, error, &ap, vop_destroyvobject);
1153         return(error);
1154 }
1155
1156 int
1157 vop_getvobject(struct vop_ops *ops, struct vnode *vp, struct vm_object **objpp)
1158 {
1159         struct vop_getvobject_args ap;
1160         int error;
1161
1162         ap.a_head.a_desc = &vop_getvobject_desc;
1163         ap.a_head.a_ops = ops;
1164         ap.a_vp = vp;
1165         ap.a_objpp = objpp;
1166
1167         DO_OPS(ops, error, &ap, vop_getvobject);
1168         return(error);
1169 }
1170
1171 int
1172 vop_vfsset(struct vop_ops *ops, int op, const char *opstr)
1173 {
1174         struct vop_vfsset_args ap;
1175         int error;
1176
1177         ap.a_head.a_desc = &vop_vfsset_desc;
1178         ap.a_head.a_ops = ops;
1179         ap.a_op = op;
1180         ap.a_opstr = opstr;
1181
1182         DO_OPS(ops, error, &ap, vop_vfsset);
1183         return(error);
1184 }
1185
1186 /************************************************************************
1187  *              PRIMARY VNODE OPERATIONS FORWARDING CALLS               *
1188  ************************************************************************
1189  *
1190  * These procedures are called from VFSs such as unionfs and nullfs
1191  * when they wish to forward an operation on one VFS to another.  The
1192  * argument structure/message is modified and then directly passed to the
1193  * appropriate routine.  This routines may also be called by initiators
1194  * who have an argument structure in hand rather then discreet arguments.
1195  */
1196 int
1197 vop_vnoperate_ap(struct vop_generic_args *ap)
1198 {
1199         struct vop_ops *ops;
1200         int error;
1201
1202         ops = ap->a_ops;
1203         if (ops->vv_flags & VVF_HOOK_MASK) {
1204                 if (ops->vv_flags & VVF_JOURNAL_HOOK)
1205                         error = VOCALL(ops->vv_jops, ap);
1206                 else
1207                         error = 0;
1208                 if (error == 0)
1209                         error = VOCALL(ops, ap);
1210         } else {
1211                 error = VOCALL(ops, ap);
1212         }
1213         return (error);
1214 }
1215
1216 int
1217 vop_islocked_ap(struct vop_islocked_args *ap)
1218 {
1219         int error;
1220
1221         DO_OPS(ap->a_head.a_ops, error, ap, vop_islocked);
1222         return(error);
1223 }
1224
1225 int
1226 vop_lookup_ap(struct vop_lookup_args *ap)
1227 {
1228         int error;
1229
1230         DO_OPS(ap->a_head.a_ops, error, ap, vop_lookup);
1231         return(error);
1232 }
1233
1234 int
1235 vop_cachedlookup_ap(struct vop_cachedlookup_args *ap)
1236 {
1237         int error;
1238
1239         DO_OPS(ap->a_head.a_ops, error, ap, vop_cachedlookup);
1240         return(error);
1241 }
1242
1243 int
1244 vop_create_ap(struct vop_create_args *ap)
1245 {
1246         int error;
1247
1248         DO_OPS(ap->a_head.a_ops, error, ap, vop_create);
1249         return(error);
1250 }
1251
1252 int
1253 vop_whiteout_ap(struct vop_whiteout_args *ap)
1254 {
1255         int error;
1256
1257         DO_OPS(ap->a_head.a_ops, error, ap, vop_whiteout);
1258         return(error);
1259 }
1260
1261 int
1262 vop_mknod_ap(struct vop_mknod_args *ap)
1263 {
1264         int error;
1265
1266         DO_OPS(ap->a_head.a_ops, error, ap, vop_mknod);
1267         return(error);
1268 }
1269
1270 int
1271 vop_open_ap(struct vop_open_args *ap)
1272 {
1273         int error;
1274
1275         DO_OPS(ap->a_head.a_ops, error, ap, vop_open);
1276         return(error);
1277 }
1278
1279 int
1280 vop_close_ap(struct vop_close_args *ap)
1281 {
1282         int error;
1283
1284         DO_OPS(ap->a_head.a_ops, error, ap, vop_close);
1285         return(error);
1286 }
1287
1288 int
1289 vop_access_ap(struct vop_access_args *ap)
1290 {
1291         int error;
1292
1293         DO_OPS(ap->a_head.a_ops, error, ap, vop_access);
1294         return(error);
1295 }
1296
1297 int
1298 vop_getattr_ap(struct vop_getattr_args *ap)
1299 {
1300         int error;
1301
1302         DO_OPS(ap->a_head.a_ops, error, ap, vop_getattr);
1303         return(error);
1304 }
1305
1306 int
1307 vop_setattr_ap(struct vop_setattr_args *ap)
1308 {
1309         int error;
1310
1311         DO_OPS(ap->a_head.a_ops, error, ap, vop_setattr);
1312         return(error);
1313 }
1314
1315 int
1316 vop_read_ap(struct vop_read_args *ap)
1317 {
1318         int error;
1319
1320         DO_OPS(ap->a_head.a_ops, error, ap, vop_read);
1321         return(error);
1322 }
1323
1324 int
1325 vop_write_ap(struct vop_write_args *ap)
1326 {
1327         int error;
1328
1329         DO_OPS(ap->a_head.a_ops, error, ap, vop_write);
1330         return(error);
1331 }
1332
1333 int
1334 vop_lease_ap(struct vop_lease_args *ap)
1335 {
1336         int error;
1337
1338         DO_OPS(ap->a_head.a_ops, error, ap, vop_lease);
1339         return(error);
1340 }
1341
1342 int
1343 vop_ioctl_ap(struct vop_ioctl_args *ap)
1344 {
1345         int error;
1346
1347         DO_OPS(ap->a_head.a_ops, error, ap, vop_ioctl);
1348         return(error);
1349 }
1350
1351 int
1352 vop_poll_ap(struct vop_poll_args *ap)
1353 {
1354         int error;
1355
1356         DO_OPS(ap->a_head.a_ops, error, ap, vop_poll);
1357         return(error);
1358 }
1359
1360 int
1361 vop_kqfilter_ap(struct vop_kqfilter_args *ap)
1362 {
1363         int error;
1364
1365         DO_OPS(ap->a_head.a_ops, error, ap, vop_kqfilter);
1366         return(error);
1367 }
1368
1369 int
1370 vop_revoke_ap(struct vop_revoke_args *ap)
1371 {
1372         int error;
1373
1374         DO_OPS(ap->a_head.a_ops, error, ap, vop_revoke);
1375         return(error);
1376 }
1377
1378 int
1379 vop_mmap_ap(struct vop_mmap_args *ap)
1380 {
1381         int error;
1382
1383         DO_OPS(ap->a_head.a_ops, error, ap, vop_mmap);
1384         return(error);
1385 }
1386
1387 int
1388 vop_fsync_ap(struct vop_fsync_args *ap)
1389 {
1390         int error;
1391
1392         DO_OPS(ap->a_head.a_ops, error, ap, vop_fsync);
1393         return(error);
1394 }
1395
1396 int
1397 vop_remove_ap(struct vop_remove_args *ap)
1398 {
1399         int error;
1400
1401         DO_OPS(ap->a_head.a_ops, error, ap, vop_remove);
1402         return(error);
1403 }
1404
1405 int
1406 vop_link_ap(struct vop_link_args *ap)
1407 {
1408         int error;
1409
1410         DO_OPS(ap->a_head.a_ops, error, ap, vop_link);
1411         return(error);
1412 }
1413
1414 int
1415 vop_rename_ap(struct vop_rename_args *ap)
1416 {
1417         int error;
1418
1419         DO_OPS(ap->a_head.a_ops, error, ap, vop_rename);
1420         return(error);
1421 }
1422
1423 int
1424 vop_mkdir_ap(struct vop_mkdir_args *ap)
1425 {
1426         int error;
1427
1428         DO_OPS(ap->a_head.a_ops, error, ap, vop_mkdir);
1429         return(error);
1430 }
1431
1432 int
1433 vop_rmdir_ap(struct vop_rmdir_args *ap)
1434 {
1435         int error;
1436
1437         DO_OPS(ap->a_head.a_ops, error, ap, vop_rmdir);
1438         return(error);
1439 }
1440
1441 int
1442 vop_symlink_ap(struct vop_symlink_args *ap)
1443 {
1444         int error;
1445
1446         DO_OPS(ap->a_head.a_ops, error, ap, vop_symlink);
1447         return(error);
1448 }
1449
1450 int
1451 vop_readdir_ap(struct vop_readdir_args *ap)
1452 {
1453         int error;
1454
1455         DO_OPS(ap->a_head.a_ops, error, ap, vop_readdir);
1456         return(error);
1457 }
1458
1459 int
1460 vop_readlink_ap(struct vop_readlink_args *ap)
1461 {
1462         int error;
1463
1464         DO_OPS(ap->a_head.a_ops, error, ap, vop_readlink);
1465         return(error);
1466 }
1467
1468 int
1469 vop_inactive_ap(struct vop_inactive_args *ap)
1470 {
1471         int error;
1472
1473         DO_OPS(ap->a_head.a_ops, error, ap, vop_inactive);
1474         return(error);
1475 }
1476
1477 int
1478 vop_reclaim_ap(struct vop_reclaim_args *ap)
1479 {
1480         int error;
1481
1482         DO_OPS(ap->a_head.a_ops, error, ap, vop_reclaim);
1483         return(error);
1484 }
1485
1486 int
1487 vop_lock_ap(struct vop_lock_args *ap)
1488 {
1489         int error;
1490
1491         DO_OPS(ap->a_head.a_ops, error, ap, vop_lock);
1492         return(error);
1493 }
1494
1495 int
1496 vop_unlock_ap(struct vop_unlock_args *ap)
1497 {
1498         int error;
1499
1500         DO_OPS(ap->a_head.a_ops, error, ap, vop_unlock);
1501         return(error);
1502 }
1503
1504 int
1505 vop_bmap_ap(struct vop_bmap_args *ap)
1506 {
1507         int error;
1508
1509         DO_OPS(ap->a_head.a_ops, error, ap, vop_bmap);
1510         return(error);
1511 }
1512
1513 int
1514 vop_strategy_ap(struct vop_strategy_args *ap)
1515 {
1516         int error;
1517
1518         DO_OPS(ap->a_head.a_ops, error, ap, vop_strategy);
1519         return(error);
1520 }
1521
1522 int
1523 vop_print_ap(struct vop_print_args *ap)
1524 {
1525         int error;
1526
1527         DO_OPS(ap->a_head.a_ops, error, ap, vop_print);
1528         return(error);
1529 }
1530
1531 int
1532 vop_pathconf_ap(struct vop_pathconf_args *ap)
1533 {
1534         int error;
1535
1536         DO_OPS(ap->a_head.a_ops, error, ap, vop_pathconf);
1537         return(error);
1538 }
1539
1540 int
1541 vop_advlock_ap(struct vop_advlock_args *ap)
1542 {
1543         int error;
1544
1545         DO_OPS(ap->a_head.a_ops, error, ap, vop_advlock);
1546         return(error);
1547 }
1548
1549 int
1550 vop_balloc_ap(struct vop_balloc_args *ap)
1551 {
1552         int error;
1553
1554         DO_OPS(ap->a_head.a_ops, error, ap, vop_balloc);
1555         return(error);
1556 }
1557
1558 int
1559 vop_reallocblks_ap(struct vop_reallocblks_args *ap)
1560 {
1561         int error;
1562
1563         DO_OPS(ap->a_head.a_ops, error, ap, vop_reallocblks);
1564         return(error);
1565 }
1566
1567 int
1568 vop_getpages_ap(struct vop_getpages_args *ap)
1569 {
1570         int error;
1571
1572         DO_OPS(ap->a_head.a_ops, error, ap, vop_getpages);
1573         return(error);
1574 }
1575
1576 int
1577 vop_putpages_ap(struct vop_putpages_args *ap)
1578 {
1579         int error;
1580
1581         DO_OPS(ap->a_head.a_ops, error, ap, vop_putpages);
1582         return(error);
1583 }
1584
1585 int
1586 vop_freeblks_ap(struct vop_freeblks_args *ap)
1587 {
1588         int error;
1589
1590         DO_OPS(ap->a_head.a_ops, error, ap, vop_freeblks);
1591         return(error);
1592 }
1593
1594 int
1595 vop_bwrite_ap(struct vop_bwrite_args *ap)
1596 {
1597         int error;
1598
1599         DO_OPS(ap->a_head.a_ops, error, ap, vop_bwrite);
1600         return(error);
1601 }
1602
1603 int
1604 vop_getacl_ap(struct vop_getacl_args *ap)
1605 {
1606         int error;
1607
1608         DO_OPS(ap->a_head.a_ops, error, ap, vop_getacl);
1609         return(error);
1610 }
1611
1612 int
1613 vop_setacl_ap(struct vop_setacl_args *ap)
1614 {
1615         int error;
1616
1617         DO_OPS(ap->a_head.a_ops, error, ap, vop_setacl);
1618         return(error);
1619 }
1620
1621 int
1622 vop_aclcheck_ap(struct vop_aclcheck_args *ap)
1623 {
1624         int error;
1625
1626         DO_OPS(ap->a_head.a_ops, error, ap, vop_aclcheck);
1627         return(error);
1628 }
1629
1630 int
1631 vop_getextattr_ap(struct vop_getextattr_args *ap)
1632 {
1633         int error;
1634
1635         DO_OPS(ap->a_head.a_ops, error, ap, vop_getextattr);
1636         return(error);
1637 }
1638
1639 int
1640 vop_setextattr_ap(struct vop_setextattr_args *ap)
1641 {
1642         int error;
1643
1644         DO_OPS(ap->a_head.a_ops, error, ap, vop_setextattr);
1645         return(error);
1646 }
1647
1648 int
1649 vop_createvobject_ap(struct vop_createvobject_args *ap)
1650 {
1651         int error;
1652
1653         DO_OPS(ap->a_head.a_ops, error, ap, vop_createvobject);
1654         return(error);
1655 }
1656
1657 int
1658 vop_destroyvobject_ap(struct vop_destroyvobject_args *ap)
1659 {
1660         int error;
1661
1662         DO_OPS(ap->a_head.a_ops, error, ap, vop_destroyvobject);
1663         return(error);
1664 }
1665
1666 int
1667 vop_getvobject_ap(struct vop_getvobject_args *ap)
1668 {
1669         int error;
1670
1671         DO_OPS(ap->a_head.a_ops, error, ap, vop_getvobject);
1672         return(error);
1673 }
1674
1675 int
1676 vop_vfsset_ap(struct vop_vfsset_args *ap)
1677 {
1678         int error;
1679
1680         DO_OPS(ap->a_head.a_ops, error, ap, vop_vfsset);
1681         return(error);
1682 }
1683