initial-freebsd-port-work-20010414
[openafs.git] / src / afs / FBSD / vnode_if.h
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * This file is produced automatically.
12  * Do not modify anything in here by hand.
13  *
14  * Created from @(#)vnode_if.sh 8.1 (Berkeley) 6/10/93
15  */
16
17 extern struct vnodeop_desc vop_default_desc;
18 struct vop_islocked_args {
19         struct vnodeop_desc *a_desc;
20         struct vnode *a_vp;
21         struct proc *a_p;
22 };
23 extern struct vnodeop_desc vop_islocked_desc;
24 static __inline int VOP_ISLOCKED __P((
25         struct vnode *vp,
26         struct proc *p));
27 static __inline int VOP_ISLOCKED(vp, p)
28         struct vnode *vp;
29         struct proc *p;
30 {
31         struct vop_islocked_args a;
32         int rc;
33         a.a_desc = VDESC(vop_islocked);
34         a.a_vp = vp;
35         a.a_p = p;
36         rc = VCALL(vp, VOFFSET(vop_islocked), &a);
37         return (rc);
38 }
39 struct vop_lookup_args {
40         struct vnodeop_desc *a_desc;
41         struct vnode *a_dvp;
42         struct vnode **a_vpp;
43         struct componentname *a_cnp;
44 };
45 extern struct vnodeop_desc vop_lookup_desc;
46 static __inline int VOP_LOOKUP __P((
47         struct vnode *dvp,
48         struct vnode **vpp,
49         struct componentname *cnp));
50 static __inline int VOP_LOOKUP(dvp, vpp, cnp)
51         struct vnode *dvp;
52         struct vnode **vpp;
53         struct componentname *cnp;
54 {
55         struct vop_lookup_args a;
56         int rc;
57         a.a_desc = VDESC(vop_lookup);
58         a.a_dvp = dvp;
59         a.a_vpp = vpp;
60         a.a_cnp = cnp;
61         rc = VCALL(dvp, VOFFSET(vop_lookup), &a);
62         return (rc);
63 }
64 struct vop_cachedlookup_args {
65         struct vnodeop_desc *a_desc;
66         struct vnode *a_dvp;
67         struct vnode **a_vpp;
68         struct componentname *a_cnp;
69 };
70 extern struct vnodeop_desc vop_cachedlookup_desc;
71 static __inline int VOP_CACHEDLOOKUP __P((
72         struct vnode *dvp,
73         struct vnode **vpp,
74         struct componentname *cnp));
75 static __inline int VOP_CACHEDLOOKUP(dvp, vpp, cnp)
76         struct vnode *dvp;
77         struct vnode **vpp;
78         struct componentname *cnp;
79 {
80         struct vop_cachedlookup_args a;
81         int rc;
82         a.a_desc = VDESC(vop_cachedlookup);
83         a.a_dvp = dvp;
84         a.a_vpp = vpp;
85         a.a_cnp = cnp;
86         rc = VCALL(dvp, VOFFSET(vop_cachedlookup), &a);
87         return (rc);
88 }
89 struct vop_create_args {
90         struct vnodeop_desc *a_desc;
91         struct vnode *a_dvp;
92         struct vnode **a_vpp;
93         struct componentname *a_cnp;
94         struct vattr *a_vap;
95 };
96 extern struct vnodeop_desc vop_create_desc;
97 static __inline int VOP_CREATE __P((
98         struct vnode *dvp,
99         struct vnode **vpp,
100         struct componentname *cnp,
101         struct vattr *vap));
102 static __inline int VOP_CREATE(dvp, vpp, cnp, vap)
103         struct vnode *dvp;
104         struct vnode **vpp;
105         struct componentname *cnp;
106         struct vattr *vap;
107 {
108         struct vop_create_args a;
109         int rc;
110         a.a_desc = VDESC(vop_create);
111         a.a_dvp = dvp;
112         a.a_vpp = vpp;
113         a.a_cnp = cnp;
114         a.a_vap = vap;
115         rc = VCALL(dvp, VOFFSET(vop_create), &a);
116         return (rc);
117 }
118 struct vop_whiteout_args {
119         struct vnodeop_desc *a_desc;
120         struct vnode *a_dvp;
121         struct componentname *a_cnp;
122         int a_flags;
123 };
124 extern struct vnodeop_desc vop_whiteout_desc;
125 static __inline int VOP_WHITEOUT __P((
126         struct vnode *dvp,
127         struct componentname *cnp,
128         int flags));
129 static __inline int VOP_WHITEOUT(dvp, cnp, flags)
130         struct vnode *dvp;
131         struct componentname *cnp;
132         int flags;
133 {
134         struct vop_whiteout_args a;
135         int rc;
136         a.a_desc = VDESC(vop_whiteout);
137         a.a_dvp = dvp;
138         a.a_cnp = cnp;
139         a.a_flags = flags;
140         rc = VCALL(dvp, VOFFSET(vop_whiteout), &a);
141         return (rc);
142 }
143 struct vop_mknod_args {
144         struct vnodeop_desc *a_desc;
145         struct vnode *a_dvp;
146         struct vnode **a_vpp;
147         struct componentname *a_cnp;
148         struct vattr *a_vap;
149 };
150 extern struct vnodeop_desc vop_mknod_desc;
151 static __inline int VOP_MKNOD __P((
152         struct vnode *dvp,
153         struct vnode **vpp,
154         struct componentname *cnp,
155         struct vattr *vap));
156 static __inline int VOP_MKNOD(dvp, vpp, cnp, vap)
157         struct vnode *dvp;
158         struct vnode **vpp;
159         struct componentname *cnp;
160         struct vattr *vap;
161 {
162         struct vop_mknod_args a;
163         int rc;
164         a.a_desc = VDESC(vop_mknod);
165         a.a_dvp = dvp;
166         a.a_vpp = vpp;
167         a.a_cnp = cnp;
168         a.a_vap = vap;
169         rc = VCALL(dvp, VOFFSET(vop_mknod), &a);
170         return (rc);
171 }
172 struct vop_open_args {
173         struct vnodeop_desc *a_desc;
174         struct vnode *a_vp;
175         int a_mode;
176         struct ucred *a_cred;
177         struct proc *a_p;
178 };
179 extern struct vnodeop_desc vop_open_desc;
180 static __inline int VOP_OPEN __P((
181         struct vnode *vp,
182         int mode,
183         struct ucred *cred,
184         struct proc *p));
185 static __inline int VOP_OPEN(vp, mode, cred, p)
186         struct vnode *vp;
187         int mode;
188         struct ucred *cred;
189         struct proc *p;
190 {
191         struct vop_open_args a;
192         int rc;
193         a.a_desc = VDESC(vop_open);
194         a.a_vp = vp;
195         a.a_mode = mode;
196         a.a_cred = cred;
197         a.a_p = p;
198         rc = VCALL(vp, VOFFSET(vop_open), &a);
199         return (rc);
200 }
201 struct vop_close_args {
202         struct vnodeop_desc *a_desc;
203         struct vnode *a_vp;
204         int a_fflag;
205         struct ucred *a_cred;
206         struct proc *a_p;
207 };
208 extern struct vnodeop_desc vop_close_desc;
209 static __inline int VOP_CLOSE __P((
210         struct vnode *vp,
211         int fflag,
212         struct ucred *cred,
213         struct proc *p));
214 static __inline int VOP_CLOSE(vp, fflag, cred, p)
215         struct vnode *vp;
216         int fflag;
217         struct ucred *cred;
218         struct proc *p;
219 {
220         struct vop_close_args a;
221         int rc;
222         a.a_desc = VDESC(vop_close);
223         a.a_vp = vp;
224         a.a_fflag = fflag;
225         a.a_cred = cred;
226         a.a_p = p;
227         rc = VCALL(vp, VOFFSET(vop_close), &a);
228         return (rc);
229 }
230 struct vop_access_args {
231         struct vnodeop_desc *a_desc;
232         struct vnode *a_vp;
233         int a_mode;
234         struct ucred *a_cred;
235         struct proc *a_p;
236 };
237 extern struct vnodeop_desc vop_access_desc;
238 static __inline int VOP_ACCESS __P((
239         struct vnode *vp,
240         int mode,
241         struct ucred *cred,
242         struct proc *p));
243 static __inline int VOP_ACCESS(vp, mode, cred, p)
244         struct vnode *vp;
245         int mode;
246         struct ucred *cred;
247         struct proc *p;
248 {
249         struct vop_access_args a;
250         int rc;
251         a.a_desc = VDESC(vop_access);
252         a.a_vp = vp;
253         a.a_mode = mode;
254         a.a_cred = cred;
255         a.a_p = p;
256         rc = VCALL(vp, VOFFSET(vop_access), &a);
257         return (rc);
258 }
259 struct vop_getattr_args {
260         struct vnodeop_desc *a_desc;
261         struct vnode *a_vp;
262         struct vattr *a_vap;
263         struct ucred *a_cred;
264         struct proc *a_p;
265 };
266 extern struct vnodeop_desc vop_getattr_desc;
267 static __inline int VOP_GETATTR __P((
268         struct vnode *vp,
269         struct vattr *vap,
270         struct ucred *cred,
271         struct proc *p));
272 static __inline int VOP_GETATTR(vp, vap, cred, p)
273         struct vnode *vp;
274         struct vattr *vap;
275         struct ucred *cred;
276         struct proc *p;
277 {
278         struct vop_getattr_args a;
279         int rc;
280         a.a_desc = VDESC(vop_getattr);
281         a.a_vp = vp;
282         a.a_vap = vap;
283         a.a_cred = cred;
284         a.a_p = p;
285         rc = VCALL(vp, VOFFSET(vop_getattr), &a);
286         return (rc);
287 }
288 struct vop_setattr_args {
289         struct vnodeop_desc *a_desc;
290         struct vnode *a_vp;
291         struct vattr *a_vap;
292         struct ucred *a_cred;
293         struct proc *a_p;
294 };
295 extern struct vnodeop_desc vop_setattr_desc;
296 static __inline int VOP_SETATTR __P((
297         struct vnode *vp,
298         struct vattr *vap,
299         struct ucred *cred,
300         struct proc *p));
301 static __inline int VOP_SETATTR(vp, vap, cred, p)
302         struct vnode *vp;
303         struct vattr *vap;
304         struct ucred *cred;
305         struct proc *p;
306 {
307         struct vop_setattr_args a;
308         int rc;
309         a.a_desc = VDESC(vop_setattr);
310         a.a_vp = vp;
311         a.a_vap = vap;
312         a.a_cred = cred;
313         a.a_p = p;
314         rc = VCALL(vp, VOFFSET(vop_setattr), &a);
315         return (rc);
316 }
317 struct vop_read_args {
318         struct vnodeop_desc *a_desc;
319         struct vnode *a_vp;
320         struct uio *a_uio;
321         int a_ioflag;
322         struct ucred *a_cred;
323 };
324 extern struct vnodeop_desc vop_read_desc;
325 static __inline int VOP_READ __P((
326         struct vnode *vp,
327         struct uio *uio,
328         int ioflag,
329         struct ucred *cred));
330 static __inline int VOP_READ(vp, uio, ioflag, cred)
331         struct vnode *vp;
332         struct uio *uio;
333         int ioflag;
334         struct ucred *cred;
335 {
336         struct vop_read_args a;
337         int rc;
338         a.a_desc = VDESC(vop_read);
339         a.a_vp = vp;
340         a.a_uio = uio;
341         a.a_ioflag = ioflag;
342         a.a_cred = cred;
343         rc = VCALL(vp, VOFFSET(vop_read), &a);
344         return (rc);
345 }
346 struct vop_write_args {
347         struct vnodeop_desc *a_desc;
348         struct vnode *a_vp;
349         struct uio *a_uio;
350         int a_ioflag;
351         struct ucred *a_cred;
352 };
353 extern struct vnodeop_desc vop_write_desc;
354 static __inline int VOP_WRITE __P((
355         struct vnode *vp,
356         struct uio *uio,
357         int ioflag,
358         struct ucred *cred));
359 static __inline int VOP_WRITE(vp, uio, ioflag, cred)
360         struct vnode *vp;
361         struct uio *uio;
362         int ioflag;
363         struct ucred *cred;
364 {
365         struct vop_write_args a;
366         int rc;
367         a.a_desc = VDESC(vop_write);
368         a.a_vp = vp;
369         a.a_uio = uio;
370         a.a_ioflag = ioflag;
371         a.a_cred = cred;
372         rc = VCALL(vp, VOFFSET(vop_write), &a);
373         return (rc);
374 }
375 struct vop_lease_args {
376         struct vnodeop_desc *a_desc;
377         struct vnode *a_vp;
378         struct proc *a_p;
379         struct ucred *a_cred;
380         int a_flag;
381 };
382 extern struct vnodeop_desc vop_lease_desc;
383 static __inline int VOP_LEASE __P((
384         struct vnode *vp,
385         struct proc *p,
386         struct ucred *cred,
387         int flag));
388 static __inline int VOP_LEASE(vp, p, cred, flag)
389         struct vnode *vp;
390         struct proc *p;
391         struct ucred *cred;
392         int flag;
393 {
394         struct vop_lease_args a;
395         int rc;
396         a.a_desc = VDESC(vop_lease);
397         a.a_vp = vp;
398         a.a_p = p;
399         a.a_cred = cred;
400         a.a_flag = flag;
401         rc = VCALL(vp, VOFFSET(vop_lease), &a);
402         return (rc);
403 }
404 struct vop_ioctl_args {
405         struct vnodeop_desc *a_desc;
406         struct vnode *a_vp;
407         u_long a_command;
408         caddr_t a_data;
409         int a_fflag;
410         struct ucred *a_cred;
411         struct proc *a_p;
412 };
413 extern struct vnodeop_desc vop_ioctl_desc;
414 static __inline int VOP_IOCTL __P((
415         struct vnode *vp,
416         u_long command,
417         caddr_t data,
418         int fflag,
419         struct ucred *cred,
420         struct proc *p));
421 static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p)
422         struct vnode *vp;
423         u_long command;
424         caddr_t data;
425         int fflag;
426         struct ucred *cred;
427         struct proc *p;
428 {
429         struct vop_ioctl_args a;
430         int rc;
431         a.a_desc = VDESC(vop_ioctl);
432         a.a_vp = vp;
433         a.a_command = command;
434         a.a_data = data;
435         a.a_fflag = fflag;
436         a.a_cred = cred;
437         a.a_p = p;
438         rc = VCALL(vp, VOFFSET(vop_ioctl), &a);
439         return (rc);
440 }
441 struct vop_poll_args {
442         struct vnodeop_desc *a_desc;
443         struct vnode *a_vp;
444         int a_events;
445         struct ucred *a_cred;
446         struct proc *a_p;
447 };
448 extern struct vnodeop_desc vop_poll_desc;
449 static __inline int VOP_POLL __P((
450         struct vnode *vp,
451         int events,
452         struct ucred *cred,
453         struct proc *p));
454 static __inline int VOP_POLL(vp, events, cred, p)
455         struct vnode *vp;
456         int events;
457         struct ucred *cred;
458         struct proc *p;
459 {
460         struct vop_poll_args a;
461         int rc;
462         a.a_desc = VDESC(vop_poll);
463         a.a_vp = vp;
464         a.a_events = events;
465         a.a_cred = cred;
466         a.a_p = p;
467         rc = VCALL(vp, VOFFSET(vop_poll), &a);
468         return (rc);
469 }
470 struct vop_revoke_args {
471         struct vnodeop_desc *a_desc;
472         struct vnode *a_vp;
473         int a_flags;
474 };
475 extern struct vnodeop_desc vop_revoke_desc;
476 static __inline int VOP_REVOKE __P((
477         struct vnode *vp,
478         int flags));
479 static __inline int VOP_REVOKE(vp, flags)
480         struct vnode *vp;
481         int flags;
482 {
483         struct vop_revoke_args a;
484         int rc;
485         a.a_desc = VDESC(vop_revoke);
486         a.a_vp = vp;
487         a.a_flags = flags;
488         rc = VCALL(vp, VOFFSET(vop_revoke), &a);
489         return (rc);
490 }
491 struct vop_mmap_args {
492         struct vnodeop_desc *a_desc;
493         struct vnode *a_vp;
494         int a_fflags;
495         struct ucred *a_cred;
496         struct proc *a_p;
497 };
498 extern struct vnodeop_desc vop_mmap_desc;
499 static __inline int VOP_MMAP __P((
500         struct vnode *vp,
501         int fflags,
502         struct ucred *cred,
503         struct proc *p));
504 static __inline int VOP_MMAP(vp, fflags, cred, p)
505         struct vnode *vp;
506         int fflags;
507         struct ucred *cred;
508         struct proc *p;
509 {
510         struct vop_mmap_args a;
511         int rc;
512         a.a_desc = VDESC(vop_mmap);
513         a.a_vp = vp;
514         a.a_fflags = fflags;
515         a.a_cred = cred;
516         a.a_p = p;
517         rc = VCALL(vp, VOFFSET(vop_mmap), &a);
518         return (rc);
519 }
520 struct vop_fsync_args {
521         struct vnodeop_desc *a_desc;
522         struct vnode *a_vp;
523         struct ucred *a_cred;
524         int a_waitfor;
525         struct proc *a_p;
526 };
527 extern struct vnodeop_desc vop_fsync_desc;
528 static __inline int VOP_FSYNC __P((
529         struct vnode *vp,
530         struct ucred *cred,
531         int waitfor,
532         struct proc *p));
533 static __inline int VOP_FSYNC(vp, cred, waitfor, p)
534         struct vnode *vp;
535         struct ucred *cred;
536         int waitfor;
537         struct proc *p;
538 {
539         struct vop_fsync_args a;
540         int rc;
541         a.a_desc = VDESC(vop_fsync);
542         a.a_vp = vp;
543         a.a_cred = cred;
544         a.a_waitfor = waitfor;
545         a.a_p = p;
546         rc = VCALL(vp, VOFFSET(vop_fsync), &a);
547         return (rc);
548 }
549 struct vop_remove_args {
550         struct vnodeop_desc *a_desc;
551         struct vnode *a_dvp;
552         struct vnode *a_vp;
553         struct componentname *a_cnp;
554 };
555 extern struct vnodeop_desc vop_remove_desc;
556 static __inline int VOP_REMOVE __P((
557         struct vnode *dvp,
558         struct vnode *vp,
559         struct componentname *cnp));
560 static __inline int VOP_REMOVE(dvp, vp, cnp)
561         struct vnode *dvp;
562         struct vnode *vp;
563         struct componentname *cnp;
564 {
565         struct vop_remove_args a;
566         int rc;
567         a.a_desc = VDESC(vop_remove);
568         a.a_dvp = dvp;
569         a.a_vp = vp;
570         a.a_cnp = cnp;
571         rc = VCALL(dvp, VOFFSET(vop_remove), &a);
572         return (rc);
573 }
574 struct vop_link_args {
575         struct vnodeop_desc *a_desc;
576         struct vnode *a_tdvp;
577         struct vnode *a_vp;
578         struct componentname *a_cnp;
579 };
580 extern struct vnodeop_desc vop_link_desc;
581 static __inline int VOP_LINK __P((
582         struct vnode *tdvp,
583         struct vnode *vp,
584         struct componentname *cnp));
585 static __inline int VOP_LINK(tdvp, vp, cnp)
586         struct vnode *tdvp;
587         struct vnode *vp;
588         struct componentname *cnp;
589 {
590         struct vop_link_args a;
591         int rc;
592         a.a_desc = VDESC(vop_link);
593         a.a_tdvp = tdvp;
594         a.a_vp = vp;
595         a.a_cnp = cnp;
596         rc = VCALL(tdvp, VOFFSET(vop_link), &a);
597         return (rc);
598 }
599 struct vop_rename_args {
600         struct vnodeop_desc *a_desc;
601         struct vnode *a_fdvp;
602         struct vnode *a_fvp;
603         struct componentname *a_fcnp;
604         struct vnode *a_tdvp;
605         struct vnode *a_tvp;
606         struct componentname *a_tcnp;
607 };
608 extern struct vnodeop_desc vop_rename_desc;
609 static __inline int VOP_RENAME __P((
610         struct vnode *fdvp,
611         struct vnode *fvp,
612         struct componentname *fcnp,
613         struct vnode *tdvp,
614         struct vnode *tvp,
615         struct componentname *tcnp));
616 static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
617         struct vnode *fdvp;
618         struct vnode *fvp;
619         struct componentname *fcnp;
620         struct vnode *tdvp;
621         struct vnode *tvp;
622         struct componentname *tcnp;
623 {
624         struct vop_rename_args a;
625         int rc;
626         a.a_desc = VDESC(vop_rename);
627         a.a_fdvp = fdvp;
628         a.a_fvp = fvp;
629         a.a_fcnp = fcnp;
630         a.a_tdvp = tdvp;
631         a.a_tvp = tvp;
632         a.a_tcnp = tcnp;
633         rc = VCALL(fdvp, VOFFSET(vop_rename), &a);
634         return (rc);
635 }
636 struct vop_mkdir_args {
637         struct vnodeop_desc *a_desc;
638         struct vnode *a_dvp;
639         struct vnode **a_vpp;
640         struct componentname *a_cnp;
641         struct vattr *a_vap;
642 };
643 extern struct vnodeop_desc vop_mkdir_desc;
644 static __inline int VOP_MKDIR __P((
645         struct vnode *dvp,
646         struct vnode **vpp,
647         struct componentname *cnp,
648         struct vattr *vap));
649 static __inline int VOP_MKDIR(dvp, vpp, cnp, vap)
650         struct vnode *dvp;
651         struct vnode **vpp;
652         struct componentname *cnp;
653         struct vattr *vap;
654 {
655         struct vop_mkdir_args a;
656         int rc;
657         a.a_desc = VDESC(vop_mkdir);
658         a.a_dvp = dvp;
659         a.a_vpp = vpp;
660         a.a_cnp = cnp;
661         a.a_vap = vap;
662         rc = VCALL(dvp, VOFFSET(vop_mkdir), &a);
663         return (rc);
664 }
665 struct vop_rmdir_args {
666         struct vnodeop_desc *a_desc;
667         struct vnode *a_dvp;
668         struct vnode *a_vp;
669         struct componentname *a_cnp;
670 };
671 extern struct vnodeop_desc vop_rmdir_desc;
672 static __inline int VOP_RMDIR __P((
673         struct vnode *dvp,
674         struct vnode *vp,
675         struct componentname *cnp));
676 static __inline int VOP_RMDIR(dvp, vp, cnp)
677         struct vnode *dvp;
678         struct vnode *vp;
679         struct componentname *cnp;
680 {
681         struct vop_rmdir_args a;
682         int rc;
683         a.a_desc = VDESC(vop_rmdir);
684         a.a_dvp = dvp;
685         a.a_vp = vp;
686         a.a_cnp = cnp;
687         rc = VCALL(dvp, VOFFSET(vop_rmdir), &a);
688         return (rc);
689 }
690 struct vop_symlink_args {
691         struct vnodeop_desc *a_desc;
692         struct vnode *a_dvp;
693         struct vnode **a_vpp;
694         struct componentname *a_cnp;
695         struct vattr *a_vap;
696         char *a_target;
697 };
698 extern struct vnodeop_desc vop_symlink_desc;
699 static __inline int VOP_SYMLINK __P((
700         struct vnode *dvp,
701         struct vnode **vpp,
702         struct componentname *cnp,
703         struct vattr *vap,
704         char *target));
705 static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target)
706         struct vnode *dvp;
707         struct vnode **vpp;
708         struct componentname *cnp;
709         struct vattr *vap;
710         char *target;
711 {
712         struct vop_symlink_args a;
713         int rc;
714         a.a_desc = VDESC(vop_symlink);
715         a.a_dvp = dvp;
716         a.a_vpp = vpp;
717         a.a_cnp = cnp;
718         a.a_vap = vap;
719         a.a_target = target;
720         rc = VCALL(dvp, VOFFSET(vop_symlink), &a);
721         return (rc);
722 }
723 struct vop_readdir_args {
724         struct vnodeop_desc *a_desc;
725         struct vnode *a_vp;
726         struct uio *a_uio;
727         struct ucred *a_cred;
728         int *a_eofflag;
729         int *a_ncookies;
730         u_long **a_cookies;
731 };
732 extern struct vnodeop_desc vop_readdir_desc;
733 static __inline int VOP_READDIR __P((
734         struct vnode *vp,
735         struct uio *uio,
736         struct ucred *cred,
737         int *eofflag,
738         int *ncookies,
739         u_long **cookies));
740 static __inline int VOP_READDIR(vp, uio, cred, eofflag, ncookies, cookies)
741         struct vnode *vp;
742         struct uio *uio;
743         struct ucred *cred;
744         int *eofflag;
745         int *ncookies;
746         u_long **cookies;
747 {
748         struct vop_readdir_args a;
749         int rc;
750         a.a_desc = VDESC(vop_readdir);
751         a.a_vp = vp;
752         a.a_uio = uio;
753         a.a_cred = cred;
754         a.a_eofflag = eofflag;
755         a.a_ncookies = ncookies;
756         a.a_cookies = cookies;
757         rc = VCALL(vp, VOFFSET(vop_readdir), &a);
758         return (rc);
759 }
760 struct vop_readlink_args {
761         struct vnodeop_desc *a_desc;
762         struct vnode *a_vp;
763         struct uio *a_uio;
764         struct ucred *a_cred;
765 };
766 extern struct vnodeop_desc vop_readlink_desc;
767 static __inline int VOP_READLINK __P((
768         struct vnode *vp,
769         struct uio *uio,
770         struct ucred *cred));
771 static __inline int VOP_READLINK(vp, uio, cred)
772         struct vnode *vp;
773         struct uio *uio;
774         struct ucred *cred;
775 {
776         struct vop_readlink_args a;
777         int rc;
778         a.a_desc = VDESC(vop_readlink);
779         a.a_vp = vp;
780         a.a_uio = uio;
781         a.a_cred = cred;
782         rc = VCALL(vp, VOFFSET(vop_readlink), &a);
783         return (rc);
784 }
785 struct vop_inactive_args {
786         struct vnodeop_desc *a_desc;
787         struct vnode *a_vp;
788         struct proc *a_p;
789 };
790 extern struct vnodeop_desc vop_inactive_desc;
791 static __inline int VOP_INACTIVE __P((
792         struct vnode *vp,
793         struct proc *p));
794 static __inline int VOP_INACTIVE(vp, p)
795         struct vnode *vp;
796         struct proc *p;
797 {
798         struct vop_inactive_args a;
799         int rc;
800         a.a_desc = VDESC(vop_inactive);
801         a.a_vp = vp;
802         a.a_p = p;
803         rc = VCALL(vp, VOFFSET(vop_inactive), &a);
804         return (rc);
805 }
806 struct vop_reclaim_args {
807         struct vnodeop_desc *a_desc;
808         struct vnode *a_vp;
809         struct proc *a_p;
810 };
811 extern struct vnodeop_desc vop_reclaim_desc;
812 static __inline int VOP_RECLAIM __P((
813         struct vnode *vp,
814         struct proc *p));
815 static __inline int VOP_RECLAIM(vp, p)
816         struct vnode *vp;
817         struct proc *p;
818 {
819         struct vop_reclaim_args a;
820         int rc;
821         a.a_desc = VDESC(vop_reclaim);
822         a.a_vp = vp;
823         a.a_p = p;
824         rc = VCALL(vp, VOFFSET(vop_reclaim), &a);
825         return (rc);
826 }
827 struct vop_lock_args {
828         struct vnodeop_desc *a_desc;
829         struct vnode *a_vp;
830         int a_flags;
831         struct proc *a_p;
832 };
833 extern struct vnodeop_desc vop_lock_desc;
834 static __inline int VOP_LOCK __P((
835         struct vnode *vp,
836         int flags,
837         struct proc *p));
838 static __inline int VOP_LOCK(vp, flags, p)
839         struct vnode *vp;
840         int flags;
841         struct proc *p;
842 {
843         struct vop_lock_args a;
844         int rc;
845         a.a_desc = VDESC(vop_lock);
846         a.a_vp = vp;
847         a.a_flags = flags;
848         a.a_p = p;
849         rc = VCALL(vp, VOFFSET(vop_lock), &a);
850         return (rc);
851 }
852 struct vop_unlock_args {
853         struct vnodeop_desc *a_desc;
854         struct vnode *a_vp;
855         int a_flags;
856         struct proc *a_p;
857 };
858 extern struct vnodeop_desc vop_unlock_desc;
859 static __inline int VOP_UNLOCK __P((
860         struct vnode *vp,
861         int flags,
862         struct proc *p));
863 static __inline int VOP_UNLOCK(vp, flags, p)
864         struct vnode *vp;
865         int flags;
866         struct proc *p;
867 {
868         struct vop_unlock_args a;
869         int rc;
870         a.a_desc = VDESC(vop_unlock);
871         a.a_vp = vp;
872         a.a_flags = flags;
873         a.a_p = p;
874         rc = VCALL(vp, VOFFSET(vop_unlock), &a);
875         return (rc);
876 }
877 struct vop_bmap_args {
878         struct vnodeop_desc *a_desc;
879         struct vnode *a_vp;
880         daddr_t a_bn;
881         struct vnode **a_vpp;
882         daddr_t *a_bnp;
883         int *a_runp;
884         int *a_runb;
885 };
886 extern struct vnodeop_desc vop_bmap_desc;
887 static __inline int VOP_BMAP __P((
888         struct vnode *vp,
889         daddr_t bn,
890         struct vnode **vpp,
891         daddr_t *bnp,
892         int *runp,
893         int *runb));
894 static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp, runb)
895         struct vnode *vp;
896         daddr_t bn;
897         struct vnode **vpp;
898         daddr_t *bnp;
899         int *runp;
900         int *runb;
901 {
902         struct vop_bmap_args a;
903         int rc;
904         a.a_desc = VDESC(vop_bmap);
905         a.a_vp = vp;
906         a.a_bn = bn;
907         a.a_vpp = vpp;
908         a.a_bnp = bnp;
909         a.a_runp = runp;
910         a.a_runb = runb;
911         rc = VCALL(vp, VOFFSET(vop_bmap), &a);
912         return (rc);
913 }
914 struct vop_strategy_args {
915         struct vnodeop_desc *a_desc;
916         struct vnode *a_vp;
917         struct buf *a_bp;
918 };
919 extern struct vnodeop_desc vop_strategy_desc;
920 static __inline int VOP_STRATEGY __P((
921         struct vnode *vp,
922         struct buf *bp));
923 static __inline int VOP_STRATEGY(vp, bp)
924         struct vnode *vp;
925         struct buf *bp;
926 {
927         struct vop_strategy_args a;
928         int rc;
929         a.a_desc = VDESC(vop_strategy);
930         a.a_vp = vp;
931         a.a_bp = bp;
932         rc = VCALL(vp, VOFFSET(vop_strategy), &a);
933         return (rc);
934 }
935 struct vop_print_args {
936         struct vnodeop_desc *a_desc;
937         struct vnode *a_vp;
938 };
939 extern struct vnodeop_desc vop_print_desc;
940 static __inline int VOP_PRINT __P((
941         struct vnode *vp));
942 static __inline int VOP_PRINT(vp)
943         struct vnode *vp;
944 {
945         struct vop_print_args a;
946         int rc;
947         a.a_desc = VDESC(vop_print);
948         a.a_vp = vp;
949         rc = VCALL(vp, VOFFSET(vop_print), &a);
950         return (rc);
951 }
952 struct vop_pathconf_args {
953         struct vnodeop_desc *a_desc;
954         struct vnode *a_vp;
955         int a_name;
956         register_t *a_retval;
957 };
958 extern struct vnodeop_desc vop_pathconf_desc;
959 static __inline int VOP_PATHCONF __P((
960         struct vnode *vp,
961         int name,
962         register_t *retval));
963 static __inline int VOP_PATHCONF(vp, name, retval)
964         struct vnode *vp;
965         int name;
966         register_t *retval;
967 {
968         struct vop_pathconf_args a;
969         int rc;
970         a.a_desc = VDESC(vop_pathconf);
971         a.a_vp = vp;
972         a.a_name = name;
973         a.a_retval = retval;
974         rc = VCALL(vp, VOFFSET(vop_pathconf), &a);
975         return (rc);
976 }
977 struct vop_advlock_args {
978         struct vnodeop_desc *a_desc;
979         struct vnode *a_vp;
980         caddr_t a_id;
981         int a_op;
982         struct flock *a_fl;
983         int a_flags;
984 };
985 extern struct vnodeop_desc vop_advlock_desc;
986 static __inline int VOP_ADVLOCK __P((
987         struct vnode *vp,
988         caddr_t id,
989         int op,
990         struct flock *fl,
991         int flags));
992 static __inline int VOP_ADVLOCK(vp, id, op, fl, flags)
993         struct vnode *vp;
994         caddr_t id;
995         int op;
996         struct flock *fl;
997         int flags;
998 {
999         struct vop_advlock_args a;
1000         int rc;
1001         a.a_desc = VDESC(vop_advlock);
1002         a.a_vp = vp;
1003         a.a_id = id;
1004         a.a_op = op;
1005         a.a_fl = fl;
1006         a.a_flags = flags;
1007         rc = VCALL(vp, VOFFSET(vop_advlock), &a);
1008         return (rc);
1009 }
1010 struct vop_balloc_args {
1011         struct vnodeop_desc *a_desc;
1012         struct vnode *a_vp;
1013         off_t a_startoffset;
1014         int a_size;
1015         struct ucred *a_cred;
1016         int a_flags;
1017         struct buf **a_bpp;
1018 };
1019 extern struct vnodeop_desc vop_balloc_desc;
1020 static __inline int VOP_BALLOC __P((
1021         struct vnode *vp,
1022         off_t startoffset,
1023         int size,
1024         struct ucred *cred,
1025         int flags,
1026         struct buf **bpp));
1027 static __inline int VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
1028         struct vnode *vp;
1029         off_t startoffset;
1030         int size;
1031         struct ucred *cred;
1032         int flags;
1033         struct buf **bpp;
1034 {
1035         struct vop_balloc_args a;
1036         int rc;
1037         a.a_desc = VDESC(vop_balloc);
1038         a.a_vp = vp;
1039         a.a_startoffset = startoffset;
1040         a.a_size = size;
1041         a.a_cred = cred;
1042         a.a_flags = flags;
1043         a.a_bpp = bpp;
1044         rc = VCALL(vp, VOFFSET(vop_balloc), &a);
1045         return (rc);
1046 }
1047 struct vop_reallocblks_args {
1048         struct vnodeop_desc *a_desc;
1049         struct vnode *a_vp;
1050         struct cluster_save *a_buflist;
1051 };
1052 extern struct vnodeop_desc vop_reallocblks_desc;
1053 static __inline int VOP_REALLOCBLKS __P((
1054         struct vnode *vp,
1055         struct cluster_save *buflist));
1056 static __inline int VOP_REALLOCBLKS(vp, buflist)
1057         struct vnode *vp;
1058         struct cluster_save *buflist;
1059 {
1060         struct vop_reallocblks_args a;
1061         int rc;
1062         a.a_desc = VDESC(vop_reallocblks);
1063         a.a_vp = vp;
1064         a.a_buflist = buflist;
1065         rc = VCALL(vp, VOFFSET(vop_reallocblks), &a);
1066         return (rc);
1067 }
1068 struct vop_getpages_args {
1069         struct vnodeop_desc *a_desc;
1070         struct vnode *a_vp;
1071         vm_page_t *a_m;
1072         int a_count;
1073         int a_reqpage;
1074         vm_ooffset_t a_offset;
1075 };
1076 extern struct vnodeop_desc vop_getpages_desc;
1077 static __inline int VOP_GETPAGES __P((
1078         struct vnode *vp,
1079         vm_page_t *m,
1080         int count,
1081         int reqpage,
1082         vm_ooffset_t offset));
1083 static __inline int VOP_GETPAGES(vp, m, count, reqpage, offset)
1084         struct vnode *vp;
1085         vm_page_t *m;
1086         int count;
1087         int reqpage;
1088         vm_ooffset_t offset;
1089 {
1090         struct vop_getpages_args a;
1091         int rc;
1092         a.a_desc = VDESC(vop_getpages);
1093         a.a_vp = vp;
1094         a.a_m = m;
1095         a.a_count = count;
1096         a.a_reqpage = reqpage;
1097         a.a_offset = offset;
1098         rc = VCALL(vp, VOFFSET(vop_getpages), &a);
1099         return (rc);
1100 }
1101 struct vop_putpages_args {
1102         struct vnodeop_desc *a_desc;
1103         struct vnode *a_vp;
1104         vm_page_t *a_m;
1105         int a_count;
1106         int a_sync;
1107         int *a_rtvals;
1108         vm_ooffset_t a_offset;
1109 };
1110 extern struct vnodeop_desc vop_putpages_desc;
1111 static __inline int VOP_PUTPAGES __P((
1112         struct vnode *vp,
1113         vm_page_t *m,
1114         int count,
1115         int sync,
1116         int *rtvals,
1117         vm_ooffset_t offset));
1118 static __inline int VOP_PUTPAGES(vp, m, count, sync, rtvals, offset)
1119         struct vnode *vp;
1120         vm_page_t *m;
1121         int count;
1122         int sync;
1123         int *rtvals;
1124         vm_ooffset_t offset;
1125 {
1126         struct vop_putpages_args a;
1127         int rc;
1128         a.a_desc = VDESC(vop_putpages);
1129         a.a_vp = vp;
1130         a.a_m = m;
1131         a.a_count = count;
1132         a.a_sync = sync;
1133         a.a_rtvals = rtvals;
1134         a.a_offset = offset;
1135         rc = VCALL(vp, VOFFSET(vop_putpages), &a);
1136         return (rc);
1137 }
1138 struct vop_freeblks_args {
1139         struct vnodeop_desc *a_desc;
1140         struct vnode *a_vp;
1141         daddr_t a_addr;
1142         daddr_t a_length;
1143 };
1144 extern struct vnodeop_desc vop_freeblks_desc;
1145 static __inline int VOP_FREEBLKS __P((
1146         struct vnode *vp,
1147         daddr_t addr,
1148         daddr_t length));
1149 static __inline int VOP_FREEBLKS(vp, addr, length)
1150         struct vnode *vp;
1151         daddr_t addr;
1152         daddr_t length;
1153 {
1154         struct vop_freeblks_args a;
1155         int rc;
1156         a.a_desc = VDESC(vop_freeblks);
1157         a.a_vp = vp;
1158         a.a_addr = addr;
1159         a.a_length = length;
1160         rc = VCALL(vp, VOFFSET(vop_freeblks), &a);
1161         return (rc);
1162 }
1163 struct vop_bwrite_args {
1164         struct vnodeop_desc *a_desc;
1165         struct vnode *a_vp;
1166         struct buf *a_bp;
1167 };
1168 extern struct vnodeop_desc vop_bwrite_desc;
1169 static __inline int VOP_BWRITE __P((
1170         struct vnode *vp,
1171         struct buf *bp));
1172 static __inline int VOP_BWRITE(vp, bp)
1173         struct vnode *vp;
1174         struct buf *bp;
1175 {
1176         struct vop_bwrite_args a;
1177         int rc;
1178         a.a_desc = VDESC(vop_bwrite);
1179         a.a_vp = vp;
1180         a.a_bp = bp;
1181         rc = VCALL(vp, VOFFSET(vop_bwrite), &a);
1182         return (rc);
1183 }
1184 struct vop_getacl_args {
1185         struct vnodeop_desc *a_desc;
1186         struct vnode *a_vp;
1187         acl_type_t a_type;
1188         struct acl *a_aclp;
1189         struct ucred *a_cred;
1190         struct proc *a_p;
1191 };
1192 extern struct vnodeop_desc vop_getacl_desc;
1193 static __inline int VOP_GETACL __P((
1194         struct vnode *vp,
1195         acl_type_t type,
1196         struct acl *aclp,
1197         struct ucred *cred,
1198         struct proc *p));
1199 static __inline int VOP_GETACL(vp, type, aclp, cred, p)
1200         struct vnode *vp;
1201         acl_type_t type;
1202         struct acl *aclp;
1203         struct ucred *cred;
1204         struct proc *p;
1205 {
1206         struct vop_getacl_args a;
1207         int rc;
1208         a.a_desc = VDESC(vop_getacl);
1209         a.a_vp = vp;
1210         a.a_type = type;
1211         a.a_aclp = aclp;
1212         a.a_cred = cred;
1213         a.a_p = p;
1214         rc = VCALL(vp, VOFFSET(vop_getacl), &a);
1215         return (rc);
1216 }
1217 struct vop_setacl_args {
1218         struct vnodeop_desc *a_desc;
1219         struct vnode *a_vp;
1220         acl_type_t a_type;
1221         struct acl *a_aclp;
1222         struct ucred *a_cred;
1223         struct proc *a_p;
1224 };
1225 extern struct vnodeop_desc vop_setacl_desc;
1226 static __inline int VOP_SETACL __P((
1227         struct vnode *vp,
1228         acl_type_t type,
1229         struct acl *aclp,
1230         struct ucred *cred,
1231         struct proc *p));
1232 static __inline int VOP_SETACL(vp, type, aclp, cred, p)
1233         struct vnode *vp;
1234         acl_type_t type;
1235         struct acl *aclp;
1236         struct ucred *cred;
1237         struct proc *p;
1238 {
1239         struct vop_setacl_args a;
1240         int rc;
1241         a.a_desc = VDESC(vop_setacl);
1242         a.a_vp = vp;
1243         a.a_type = type;
1244         a.a_aclp = aclp;
1245         a.a_cred = cred;
1246         a.a_p = p;
1247         rc = VCALL(vp, VOFFSET(vop_setacl), &a);
1248         return (rc);
1249 }
1250 struct vop_aclcheck_args {
1251         struct vnodeop_desc *a_desc;
1252         struct vnode *a_vp;
1253         acl_type_t a_type;
1254         struct acl *a_aclp;
1255         struct ucred *a_cred;
1256         struct proc *a_p;
1257 };
1258 extern struct vnodeop_desc vop_aclcheck_desc;
1259 static __inline int VOP_ACLCHECK __P((
1260         struct vnode *vp,
1261         acl_type_t type,
1262         struct acl *aclp,
1263         struct ucred *cred,
1264         struct proc *p));
1265 static __inline int VOP_ACLCHECK(vp, type, aclp, cred, p)
1266         struct vnode *vp;
1267         acl_type_t type;
1268         struct acl *aclp;
1269         struct ucred *cred;
1270         struct proc *p;
1271 {
1272         struct vop_aclcheck_args a;
1273         int rc;
1274         a.a_desc = VDESC(vop_aclcheck);
1275         a.a_vp = vp;
1276         a.a_type = type;
1277         a.a_aclp = aclp;
1278         a.a_cred = cred;
1279         a.a_p = p;
1280         rc = VCALL(vp, VOFFSET(vop_aclcheck), &a);
1281         return (rc);
1282 }
1283 struct vop_getextattr_args {
1284         struct vnodeop_desc *a_desc;
1285         struct vnode *a_vp;
1286         char *a_name;
1287         struct uio *a_uio;
1288         struct ucred *a_cred;
1289         struct proc *a_p;
1290 };
1291 extern struct vnodeop_desc vop_getextattr_desc;
1292 static __inline int VOP_GETEXTATTR __P((
1293         struct vnode *vp,
1294         char *name,
1295         struct uio *uio,
1296         struct ucred *cred,
1297         struct proc *p));
1298 static __inline int VOP_GETEXTATTR(vp, name, uio, cred, p)
1299         struct vnode *vp;
1300         char *name;
1301         struct uio *uio;
1302         struct ucred *cred;
1303         struct proc *p;
1304 {
1305         struct vop_getextattr_args a;
1306         int rc;
1307         a.a_desc = VDESC(vop_getextattr);
1308         a.a_vp = vp;
1309         a.a_name = name;
1310         a.a_uio = uio;
1311         a.a_cred = cred;
1312         a.a_p = p;
1313         rc = VCALL(vp, VOFFSET(vop_getextattr), &a);
1314         return (rc);
1315 }
1316 struct vop_setextattr_args {
1317         struct vnodeop_desc *a_desc;
1318         struct vnode *a_vp;
1319         char *a_name;
1320         struct uio *a_uio;
1321         struct ucred *a_cred;
1322         struct proc *a_p;
1323 };
1324 extern struct vnodeop_desc vop_setextattr_desc;
1325 static __inline int VOP_SETEXTATTR __P((
1326         struct vnode *vp,
1327         char *name,
1328         struct uio *uio,
1329         struct ucred *cred,
1330         struct proc *p));
1331 static __inline int VOP_SETEXTATTR(vp, name, uio, cred, p)
1332         struct vnode *vp;
1333         char *name;
1334         struct uio *uio;
1335         struct ucred *cred;
1336         struct proc *p;
1337 {
1338         struct vop_setextattr_args a;
1339         int rc;
1340         a.a_desc = VDESC(vop_setextattr);
1341         a.a_vp = vp;
1342         a.a_name = name;
1343         a.a_uio = uio;
1344         a.a_cred = cred;
1345         a.a_p = p;
1346         rc = VCALL(vp, VOFFSET(vop_setextattr), &a);
1347         return (rc);
1348 }