FreeBSD/Linux Kernel Cross Reference
sys/sys/vnode_if.h
1 /* $NetBSD: vnode_if.h,v 1.45 2004/01/25 18:06:49 hannken Exp $ */
2
3 /*
4 * Warning: This file is generated automatically.
5 * (Modifications made here may easily be lost!)
6 *
7 * Created from the file:
8 * NetBSD: vnode_if.src,v 1.38 2004/01/25 18:02:04 hannken Exp
9 * by the script:
10 * NetBSD: vnode_if.sh,v 1.34 2004/01/25 18:02:04 hannken Exp
11 */
12
13 /*
14 * Copyright (c) 1992, 1993, 1994, 1995
15 * The Regents of the University of California. All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
19 * are met:
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution.
25 * 3. Neither the name of the University nor the names of its contributors
26 * may be used to endorse or promote products derived from this software
27 * without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39 * SUCH DAMAGE.
40 */
41
42 #ifndef _SYS_VNODE_IF_H_
43 #define _SYS_VNODE_IF_H_
44
45 #ifdef _KERNEL
46 #if defined(_LKM) || defined(LKM)
47 /* LKMs always use non-inlined vnode ops. */
48 #define VNODE_OP_NOINLINE
49 #else
50 #include "opt_vnode_op_noinline.h"
51 #endif
52 #endif /* _KERNEL */
53
54 extern const struct vnodeop_desc vop_default_desc;
55
56
57 struct vop_lookup_args {
58 const struct vnodeop_desc *a_desc;
59 struct vnode *a_dvp;
60 struct vnode **a_vpp;
61 struct componentname *a_cnp;
62 };
63 extern const struct vnodeop_desc vop_lookup_desc;
64 #ifndef VNODE_OP_NOINLINE
65 static __inline
66 #endif
67 int VOP_LOOKUP(struct vnode *, struct vnode **, struct componentname *)
68 #ifndef VNODE_OP_NOINLINE
69 __attribute__((__unused__))
70 #endif
71 ;
72 #ifndef VNODE_OP_NOINLINE
73 static __inline int VOP_LOOKUP(dvp, vpp, cnp)
74 struct vnode *dvp;
75 struct vnode **vpp;
76 struct componentname *cnp;
77 {
78 struct vop_lookup_args a;
79 a.a_desc = VDESC(vop_lookup);
80 a.a_dvp = dvp;
81 a.a_vpp = vpp;
82 a.a_cnp = cnp;
83 return (VCALL(dvp, VOFFSET(vop_lookup), &a));
84 }
85 #endif
86
87 struct vop_create_args {
88 const struct vnodeop_desc *a_desc;
89 struct vnode *a_dvp;
90 struct vnode **a_vpp;
91 struct componentname *a_cnp;
92 struct vattr *a_vap;
93 };
94 extern const struct vnodeop_desc vop_create_desc;
95 #ifndef VNODE_OP_NOINLINE
96 static __inline
97 #endif
98 int VOP_CREATE(struct vnode *, struct vnode **, struct componentname *,
99 struct vattr *)
100 #ifndef VNODE_OP_NOINLINE
101 __attribute__((__unused__))
102 #endif
103 ;
104 #ifndef VNODE_OP_NOINLINE
105 static __inline int VOP_CREATE(dvp, vpp, cnp, vap)
106 struct vnode *dvp;
107 struct vnode **vpp;
108 struct componentname *cnp;
109 struct vattr *vap;
110 {
111 struct vop_create_args a;
112 a.a_desc = VDESC(vop_create);
113 a.a_dvp = dvp;
114 a.a_vpp = vpp;
115 a.a_cnp = cnp;
116 a.a_vap = vap;
117 return (VCALL(dvp, VOFFSET(vop_create), &a));
118 }
119 #endif
120
121 struct vop_mknod_args {
122 const struct vnodeop_desc *a_desc;
123 struct vnode *a_dvp;
124 struct vnode **a_vpp;
125 struct componentname *a_cnp;
126 struct vattr *a_vap;
127 };
128 extern const struct vnodeop_desc vop_mknod_desc;
129 #ifndef VNODE_OP_NOINLINE
130 static __inline
131 #endif
132 int VOP_MKNOD(struct vnode *, struct vnode **, struct componentname *,
133 struct vattr *)
134 #ifndef VNODE_OP_NOINLINE
135 __attribute__((__unused__))
136 #endif
137 ;
138 #ifndef VNODE_OP_NOINLINE
139 static __inline int VOP_MKNOD(dvp, vpp, cnp, vap)
140 struct vnode *dvp;
141 struct vnode **vpp;
142 struct componentname *cnp;
143 struct vattr *vap;
144 {
145 struct vop_mknod_args a;
146 a.a_desc = VDESC(vop_mknod);
147 a.a_dvp = dvp;
148 a.a_vpp = vpp;
149 a.a_cnp = cnp;
150 a.a_vap = vap;
151 return (VCALL(dvp, VOFFSET(vop_mknod), &a));
152 }
153 #endif
154
155 struct vop_open_args {
156 const struct vnodeop_desc *a_desc;
157 struct vnode *a_vp;
158 int a_mode;
159 struct ucred *a_cred;
160 struct proc *a_p;
161 };
162 extern const struct vnodeop_desc vop_open_desc;
163 #ifndef VNODE_OP_NOINLINE
164 static __inline
165 #endif
166 int VOP_OPEN(struct vnode *, int, struct ucred *, struct proc *)
167 #ifndef VNODE_OP_NOINLINE
168 __attribute__((__unused__))
169 #endif
170 ;
171 #ifndef VNODE_OP_NOINLINE
172 static __inline int VOP_OPEN(vp, mode, cred, p)
173 struct vnode *vp;
174 int mode;
175 struct ucred *cred;
176 struct proc *p;
177 {
178 struct vop_open_args a;
179 a.a_desc = VDESC(vop_open);
180 a.a_vp = vp;
181 a.a_mode = mode;
182 a.a_cred = cred;
183 a.a_p = p;
184 return (VCALL(vp, VOFFSET(vop_open), &a));
185 }
186 #endif
187
188 struct vop_close_args {
189 const struct vnodeop_desc *a_desc;
190 struct vnode *a_vp;
191 int a_fflag;
192 struct ucred *a_cred;
193 struct proc *a_p;
194 };
195 extern const struct vnodeop_desc vop_close_desc;
196 #ifndef VNODE_OP_NOINLINE
197 static __inline
198 #endif
199 int VOP_CLOSE(struct vnode *, int, struct ucred *, struct proc *)
200 #ifndef VNODE_OP_NOINLINE
201 __attribute__((__unused__))
202 #endif
203 ;
204 #ifndef VNODE_OP_NOINLINE
205 static __inline int VOP_CLOSE(vp, fflag, cred, p)
206 struct vnode *vp;
207 int fflag;
208 struct ucred *cred;
209 struct proc *p;
210 {
211 struct vop_close_args a;
212 a.a_desc = VDESC(vop_close);
213 a.a_vp = vp;
214 a.a_fflag = fflag;
215 a.a_cred = cred;
216 a.a_p = p;
217 return (VCALL(vp, VOFFSET(vop_close), &a));
218 }
219 #endif
220
221 struct vop_access_args {
222 const struct vnodeop_desc *a_desc;
223 struct vnode *a_vp;
224 int a_mode;
225 struct ucred *a_cred;
226 struct proc *a_p;
227 };
228 extern const struct vnodeop_desc vop_access_desc;
229 #ifndef VNODE_OP_NOINLINE
230 static __inline
231 #endif
232 int VOP_ACCESS(struct vnode *, int, struct ucred *, struct proc *)
233 #ifndef VNODE_OP_NOINLINE
234 __attribute__((__unused__))
235 #endif
236 ;
237 #ifndef VNODE_OP_NOINLINE
238 static __inline int VOP_ACCESS(vp, mode, cred, p)
239 struct vnode *vp;
240 int mode;
241 struct ucred *cred;
242 struct proc *p;
243 {
244 struct vop_access_args a;
245 a.a_desc = VDESC(vop_access);
246 a.a_vp = vp;
247 a.a_mode = mode;
248 a.a_cred = cred;
249 a.a_p = p;
250 return (VCALL(vp, VOFFSET(vop_access), &a));
251 }
252 #endif
253
254 struct vop_getattr_args {
255 const struct vnodeop_desc *a_desc;
256 struct vnode *a_vp;
257 struct vattr *a_vap;
258 struct ucred *a_cred;
259 struct proc *a_p;
260 };
261 extern const struct vnodeop_desc vop_getattr_desc;
262 #ifndef VNODE_OP_NOINLINE
263 static __inline
264 #endif
265 int VOP_GETATTR(struct vnode *, struct vattr *, struct ucred *, struct proc *)
266 #ifndef VNODE_OP_NOINLINE
267 __attribute__((__unused__))
268 #endif
269 ;
270 #ifndef VNODE_OP_NOINLINE
271 static __inline int VOP_GETATTR(vp, vap, cred, p)
272 struct vnode *vp;
273 struct vattr *vap;
274 struct ucred *cred;
275 struct proc *p;
276 {
277 struct vop_getattr_args a;
278 a.a_desc = VDESC(vop_getattr);
279 a.a_vp = vp;
280 a.a_vap = vap;
281 a.a_cred = cred;
282 a.a_p = p;
283 return (VCALL(vp, VOFFSET(vop_getattr), &a));
284 }
285 #endif
286
287 struct vop_setattr_args {
288 const struct vnodeop_desc *a_desc;
289 struct vnode *a_vp;
290 struct vattr *a_vap;
291 struct ucred *a_cred;
292 struct proc *a_p;
293 };
294 extern const struct vnodeop_desc vop_setattr_desc;
295 #ifndef VNODE_OP_NOINLINE
296 static __inline
297 #endif
298 int VOP_SETATTR(struct vnode *, struct vattr *, struct ucred *, struct proc *)
299 #ifndef VNODE_OP_NOINLINE
300 __attribute__((__unused__))
301 #endif
302 ;
303 #ifndef VNODE_OP_NOINLINE
304 static __inline int VOP_SETATTR(vp, vap, cred, p)
305 struct vnode *vp;
306 struct vattr *vap;
307 struct ucred *cred;
308 struct proc *p;
309 {
310 struct vop_setattr_args a;
311 a.a_desc = VDESC(vop_setattr);
312 a.a_vp = vp;
313 a.a_vap = vap;
314 a.a_cred = cred;
315 a.a_p = p;
316 return (VCALL(vp, VOFFSET(vop_setattr), &a));
317 }
318 #endif
319
320 struct vop_read_args {
321 const struct vnodeop_desc *a_desc;
322 struct vnode *a_vp;
323 struct uio *a_uio;
324 int a_ioflag;
325 struct ucred *a_cred;
326 };
327 extern const struct vnodeop_desc vop_read_desc;
328 #ifndef VNODE_OP_NOINLINE
329 static __inline
330 #endif
331 int VOP_READ(struct vnode *, struct uio *, int, struct ucred *)
332 #ifndef VNODE_OP_NOINLINE
333 __attribute__((__unused__))
334 #endif
335 ;
336 #ifndef VNODE_OP_NOINLINE
337 static __inline int VOP_READ(vp, uio, ioflag, cred)
338 struct vnode *vp;
339 struct uio *uio;
340 int ioflag;
341 struct ucred *cred;
342 {
343 struct vop_read_args a;
344 a.a_desc = VDESC(vop_read);
345 a.a_vp = vp;
346 a.a_uio = uio;
347 a.a_ioflag = ioflag;
348 a.a_cred = cred;
349 return (VCALL(vp, VOFFSET(vop_read), &a));
350 }
351 #endif
352
353 struct vop_write_args {
354 const struct vnodeop_desc *a_desc;
355 struct vnode *a_vp;
356 struct uio *a_uio;
357 int a_ioflag;
358 struct ucred *a_cred;
359 };
360 extern const struct vnodeop_desc vop_write_desc;
361 #ifndef VNODE_OP_NOINLINE
362 static __inline
363 #endif
364 int VOP_WRITE(struct vnode *, struct uio *, int, struct ucred *)
365 #ifndef VNODE_OP_NOINLINE
366 __attribute__((__unused__))
367 #endif
368 ;
369 #ifndef VNODE_OP_NOINLINE
370 static __inline int VOP_WRITE(vp, uio, ioflag, cred)
371 struct vnode *vp;
372 struct uio *uio;
373 int ioflag;
374 struct ucred *cred;
375 {
376 struct vop_write_args a;
377 a.a_desc = VDESC(vop_write);
378 a.a_vp = vp;
379 a.a_uio = uio;
380 a.a_ioflag = ioflag;
381 a.a_cred = cred;
382 return (VCALL(vp, VOFFSET(vop_write), &a));
383 }
384 #endif
385
386 struct vop_ioctl_args {
387 const struct vnodeop_desc *a_desc;
388 struct vnode *a_vp;
389 u_long a_command;
390 void *a_data;
391 int a_fflag;
392 struct ucred *a_cred;
393 struct proc *a_p;
394 };
395 extern const struct vnodeop_desc vop_ioctl_desc;
396 #ifndef VNODE_OP_NOINLINE
397 static __inline
398 #endif
399 int VOP_IOCTL(struct vnode *, u_long, void *, int, struct ucred *,
400 struct proc *)
401 #ifndef VNODE_OP_NOINLINE
402 __attribute__((__unused__))
403 #endif
404 ;
405 #ifndef VNODE_OP_NOINLINE
406 static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p)
407 struct vnode *vp;
408 u_long command;
409 void *data;
410 int fflag;
411 struct ucred *cred;
412 struct proc *p;
413 {
414 struct vop_ioctl_args a;
415 a.a_desc = VDESC(vop_ioctl);
416 a.a_vp = vp;
417 a.a_command = command;
418 a.a_data = data;
419 a.a_fflag = fflag;
420 a.a_cred = cred;
421 a.a_p = p;
422 return (VCALL(vp, VOFFSET(vop_ioctl), &a));
423 }
424 #endif
425
426 struct vop_fcntl_args {
427 const struct vnodeop_desc *a_desc;
428 struct vnode *a_vp;
429 u_int a_command;
430 void *a_data;
431 int a_fflag;
432 struct ucred *a_cred;
433 struct proc *a_p;
434 };
435 extern const struct vnodeop_desc vop_fcntl_desc;
436 #ifndef VNODE_OP_NOINLINE
437 static __inline
438 #endif
439 int VOP_FCNTL(struct vnode *, u_int, void *, int, struct ucred *,
440 struct proc *)
441 #ifndef VNODE_OP_NOINLINE
442 __attribute__((__unused__))
443 #endif
444 ;
445 #ifndef VNODE_OP_NOINLINE
446 static __inline int VOP_FCNTL(vp, command, data, fflag, cred, p)
447 struct vnode *vp;
448 u_int command;
449 void *data;
450 int fflag;
451 struct ucred *cred;
452 struct proc *p;
453 {
454 struct vop_fcntl_args a;
455 a.a_desc = VDESC(vop_fcntl);
456 a.a_vp = vp;
457 a.a_command = command;
458 a.a_data = data;
459 a.a_fflag = fflag;
460 a.a_cred = cred;
461 a.a_p = p;
462 return (VCALL(vp, VOFFSET(vop_fcntl), &a));
463 }
464 #endif
465
466 struct vop_poll_args {
467 const struct vnodeop_desc *a_desc;
468 struct vnode *a_vp;
469 int a_events;
470 struct proc *a_p;
471 };
472 extern const struct vnodeop_desc vop_poll_desc;
473 #ifndef VNODE_OP_NOINLINE
474 static __inline
475 #endif
476 int VOP_POLL(struct vnode *, int, struct proc *)
477 #ifndef VNODE_OP_NOINLINE
478 __attribute__((__unused__))
479 #endif
480 ;
481 #ifndef VNODE_OP_NOINLINE
482 static __inline int VOP_POLL(vp, events, p)
483 struct vnode *vp;
484 int events;
485 struct proc *p;
486 {
487 struct vop_poll_args a;
488 a.a_desc = VDESC(vop_poll);
489 a.a_vp = vp;
490 a.a_events = events;
491 a.a_p = p;
492 return (VCALL(vp, VOFFSET(vop_poll), &a));
493 }
494 #endif
495
496 struct vop_kqfilter_args {
497 const struct vnodeop_desc *a_desc;
498 struct vnode *a_vp;
499 struct knote *a_kn;
500 };
501 extern const struct vnodeop_desc vop_kqfilter_desc;
502 #ifndef VNODE_OP_NOINLINE
503 static __inline
504 #endif
505 int VOP_KQFILTER(struct vnode *, struct knote *)
506 #ifndef VNODE_OP_NOINLINE
507 __attribute__((__unused__))
508 #endif
509 ;
510 #ifndef VNODE_OP_NOINLINE
511 static __inline int VOP_KQFILTER(vp, kn)
512 struct vnode *vp;
513 struct knote *kn;
514 {
515 struct vop_kqfilter_args a;
516 a.a_desc = VDESC(vop_kqfilter);
517 a.a_vp = vp;
518 a.a_kn = kn;
519 return (VCALL(vp, VOFFSET(vop_kqfilter), &a));
520 }
521 #endif
522
523 struct vop_revoke_args {
524 const struct vnodeop_desc *a_desc;
525 struct vnode *a_vp;
526 int a_flags;
527 };
528 extern const struct vnodeop_desc vop_revoke_desc;
529 #ifndef VNODE_OP_NOINLINE
530 static __inline
531 #endif
532 int VOP_REVOKE(struct vnode *, int)
533 #ifndef VNODE_OP_NOINLINE
534 __attribute__((__unused__))
535 #endif
536 ;
537 #ifndef VNODE_OP_NOINLINE
538 static __inline int VOP_REVOKE(vp, flags)
539 struct vnode *vp;
540 int flags;
541 {
542 struct vop_revoke_args a;
543 a.a_desc = VDESC(vop_revoke);
544 a.a_vp = vp;
545 a.a_flags = flags;
546 return (VCALL(vp, VOFFSET(vop_revoke), &a));
547 }
548 #endif
549
550 struct vop_mmap_args {
551 const struct vnodeop_desc *a_desc;
552 struct vnode *a_vp;
553 int a_fflags;
554 struct ucred *a_cred;
555 struct proc *a_p;
556 };
557 extern const struct vnodeop_desc vop_mmap_desc;
558 #ifndef VNODE_OP_NOINLINE
559 static __inline
560 #endif
561 int VOP_MMAP(struct vnode *, int, struct ucred *, struct proc *)
562 #ifndef VNODE_OP_NOINLINE
563 __attribute__((__unused__))
564 #endif
565 ;
566 #ifndef VNODE_OP_NOINLINE
567 static __inline int VOP_MMAP(vp, fflags, cred, p)
568 struct vnode *vp;
569 int fflags;
570 struct ucred *cred;
571 struct proc *p;
572 {
573 struct vop_mmap_args a;
574 a.a_desc = VDESC(vop_mmap);
575 a.a_vp = vp;
576 a.a_fflags = fflags;
577 a.a_cred = cred;
578 a.a_p = p;
579 return (VCALL(vp, VOFFSET(vop_mmap), &a));
580 }
581 #endif
582
583 struct vop_fsync_args {
584 const struct vnodeop_desc *a_desc;
585 struct vnode *a_vp;
586 struct ucred *a_cred;
587 int a_flags;
588 off_t a_offlo;
589 off_t a_offhi;
590 struct proc *a_p;
591 };
592 extern const struct vnodeop_desc vop_fsync_desc;
593 #ifndef VNODE_OP_NOINLINE
594 static __inline
595 #endif
596 int VOP_FSYNC(struct vnode *, struct ucred *, int, off_t, off_t,
597 struct proc *)
598 #ifndef VNODE_OP_NOINLINE
599 __attribute__((__unused__))
600 #endif
601 ;
602 #ifndef VNODE_OP_NOINLINE
603 static __inline int VOP_FSYNC(vp, cred, flags, offlo, offhi, p)
604 struct vnode *vp;
605 struct ucred *cred;
606 int flags;
607 off_t offlo;
608 off_t offhi;
609 struct proc *p;
610 {
611 struct vop_fsync_args a;
612 a.a_desc = VDESC(vop_fsync);
613 a.a_vp = vp;
614 a.a_cred = cred;
615 a.a_flags = flags;
616 a.a_offlo = offlo;
617 a.a_offhi = offhi;
618 a.a_p = p;
619 return (VCALL(vp, VOFFSET(vop_fsync), &a));
620 }
621 #endif
622
623 struct vop_seek_args {
624 const struct vnodeop_desc *a_desc;
625 struct vnode *a_vp;
626 off_t a_oldoff;
627 off_t a_newoff;
628 struct ucred *a_cred;
629 };
630 extern const struct vnodeop_desc vop_seek_desc;
631 #ifndef VNODE_OP_NOINLINE
632 static __inline
633 #endif
634 int VOP_SEEK(struct vnode *, off_t, off_t, struct ucred *)
635 #ifndef VNODE_OP_NOINLINE
636 __attribute__((__unused__))
637 #endif
638 ;
639 #ifndef VNODE_OP_NOINLINE
640 static __inline int VOP_SEEK(vp, oldoff, newoff, cred)
641 struct vnode *vp;
642 off_t oldoff;
643 off_t newoff;
644 struct ucred *cred;
645 {
646 struct vop_seek_args a;
647 a.a_desc = VDESC(vop_seek);
648 a.a_vp = vp;
649 a.a_oldoff = oldoff;
650 a.a_newoff = newoff;
651 a.a_cred = cred;
652 return (VCALL(vp, VOFFSET(vop_seek), &a));
653 }
654 #endif
655
656 struct vop_remove_args {
657 const struct vnodeop_desc *a_desc;
658 struct vnode *a_dvp;
659 struct vnode *a_vp;
660 struct componentname *a_cnp;
661 };
662 extern const struct vnodeop_desc vop_remove_desc;
663 #ifndef VNODE_OP_NOINLINE
664 static __inline
665 #endif
666 int VOP_REMOVE(struct vnode *, struct vnode *, struct componentname *)
667 #ifndef VNODE_OP_NOINLINE
668 __attribute__((__unused__))
669 #endif
670 ;
671 #ifndef VNODE_OP_NOINLINE
672 static __inline int VOP_REMOVE(dvp, vp, cnp)
673 struct vnode *dvp;
674 struct vnode *vp;
675 struct componentname *cnp;
676 {
677 struct vop_remove_args a;
678 a.a_desc = VDESC(vop_remove);
679 a.a_dvp = dvp;
680 a.a_vp = vp;
681 a.a_cnp = cnp;
682 return (VCALL(dvp, VOFFSET(vop_remove), &a));
683 }
684 #endif
685
686 struct vop_link_args {
687 const struct vnodeop_desc *a_desc;
688 struct vnode *a_dvp;
689 struct vnode *a_vp;
690 struct componentname *a_cnp;
691 };
692 extern const struct vnodeop_desc vop_link_desc;
693 #ifndef VNODE_OP_NOINLINE
694 static __inline
695 #endif
696 int VOP_LINK(struct vnode *, struct vnode *, struct componentname *)
697 #ifndef VNODE_OP_NOINLINE
698 __attribute__((__unused__))
699 #endif
700 ;
701 #ifndef VNODE_OP_NOINLINE
702 static __inline int VOP_LINK(dvp, vp, cnp)
703 struct vnode *dvp;
704 struct vnode *vp;
705 struct componentname *cnp;
706 {
707 struct vop_link_args a;
708 a.a_desc = VDESC(vop_link);
709 a.a_dvp = dvp;
710 a.a_vp = vp;
711 a.a_cnp = cnp;
712 return (VCALL(dvp, VOFFSET(vop_link), &a));
713 }
714 #endif
715
716 struct vop_rename_args {
717 const struct vnodeop_desc *a_desc;
718 struct vnode *a_fdvp;
719 struct vnode *a_fvp;
720 struct componentname *a_fcnp;
721 struct vnode *a_tdvp;
722 struct vnode *a_tvp;
723 struct componentname *a_tcnp;
724 };
725 extern const struct vnodeop_desc vop_rename_desc;
726 #ifndef VNODE_OP_NOINLINE
727 static __inline
728 #endif
729 int VOP_RENAME(struct vnode *, struct vnode *, struct componentname *,
730 struct vnode *, struct vnode *, struct componentname *)
731 #ifndef VNODE_OP_NOINLINE
732 __attribute__((__unused__))
733 #endif
734 ;
735 #ifndef VNODE_OP_NOINLINE
736 static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
737 struct vnode *fdvp;
738 struct vnode *fvp;
739 struct componentname *fcnp;
740 struct vnode *tdvp;
741 struct vnode *tvp;
742 struct componentname *tcnp;
743 {
744 struct vop_rename_args a;
745 a.a_desc = VDESC(vop_rename);
746 a.a_fdvp = fdvp;
747 a.a_fvp = fvp;
748 a.a_fcnp = fcnp;
749 a.a_tdvp = tdvp;
750 a.a_tvp = tvp;
751 a.a_tcnp = tcnp;
752 return (VCALL(fdvp, VOFFSET(vop_rename), &a));
753 }
754 #endif
755
756 struct vop_mkdir_args {
757 const struct vnodeop_desc *a_desc;
758 struct vnode *a_dvp;
759 struct vnode **a_vpp;
760 struct componentname *a_cnp;
761 struct vattr *a_vap;
762 };
763 extern const struct vnodeop_desc vop_mkdir_desc;
764 #ifndef VNODE_OP_NOINLINE
765 static __inline
766 #endif
767 int VOP_MKDIR(struct vnode *, struct vnode **, struct componentname *,
768 struct vattr *)
769 #ifndef VNODE_OP_NOINLINE
770 __attribute__((__unused__))
771 #endif
772 ;
773 #ifndef VNODE_OP_NOINLINE
774 static __inline int VOP_MKDIR(dvp, vpp, cnp, vap)
775 struct vnode *dvp;
776 struct vnode **vpp;
777 struct componentname *cnp;
778 struct vattr *vap;
779 {
780 struct vop_mkdir_args a;
781 a.a_desc = VDESC(vop_mkdir);
782 a.a_dvp = dvp;
783 a.a_vpp = vpp;
784 a.a_cnp = cnp;
785 a.a_vap = vap;
786 return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
787 }
788 #endif
789
790 struct vop_rmdir_args {
791 const struct vnodeop_desc *a_desc;
792 struct vnode *a_dvp;
793 struct vnode *a_vp;
794 struct componentname *a_cnp;
795 };
796 extern const struct vnodeop_desc vop_rmdir_desc;
797 #ifndef VNODE_OP_NOINLINE
798 static __inline
799 #endif
800 int VOP_RMDIR(struct vnode *, struct vnode *, struct componentname *)
801 #ifndef VNODE_OP_NOINLINE
802 __attribute__((__unused__))
803 #endif
804 ;
805 #ifndef VNODE_OP_NOINLINE
806 static __inline int VOP_RMDIR(dvp, vp, cnp)
807 struct vnode *dvp;
808 struct vnode *vp;
809 struct componentname *cnp;
810 {
811 struct vop_rmdir_args a;
812 a.a_desc = VDESC(vop_rmdir);
813 a.a_dvp = dvp;
814 a.a_vp = vp;
815 a.a_cnp = cnp;
816 return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
817 }
818 #endif
819
820 struct vop_symlink_args {
821 const struct vnodeop_desc *a_desc;
822 struct vnode *a_dvp;
823 struct vnode **a_vpp;
824 struct componentname *a_cnp;
825 struct vattr *a_vap;
826 char *a_target;
827 };
828 extern const struct vnodeop_desc vop_symlink_desc;
829 #ifndef VNODE_OP_NOINLINE
830 static __inline
831 #endif
832 int VOP_SYMLINK(struct vnode *, struct vnode **, struct componentname *,
833 struct vattr *, char *)
834 #ifndef VNODE_OP_NOINLINE
835 __attribute__((__unused__))
836 #endif
837 ;
838 #ifndef VNODE_OP_NOINLINE
839 static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target)
840 struct vnode *dvp;
841 struct vnode **vpp;
842 struct componentname *cnp;
843 struct vattr *vap;
844 char *target;
845 {
846 struct vop_symlink_args a;
847 a.a_desc = VDESC(vop_symlink);
848 a.a_dvp = dvp;
849 a.a_vpp = vpp;
850 a.a_cnp = cnp;
851 a.a_vap = vap;
852 a.a_target = target;
853 return (VCALL(dvp, VOFFSET(vop_symlink), &a));
854 }
855 #endif
856
857 struct vop_readdir_args {
858 const struct vnodeop_desc *a_desc;
859 struct vnode *a_vp;
860 struct uio *a_uio;
861 struct ucred *a_cred;
862 int *a_eofflag;
863 off_t **a_cookies;
864 int *a_ncookies;
865 };
866 extern const struct vnodeop_desc vop_readdir_desc;
867 #ifndef VNODE_OP_NOINLINE
868 static __inline
869 #endif
870 int VOP_READDIR(struct vnode *, struct uio *, struct ucred *, int *,
871 off_t **, int *)
872 #ifndef VNODE_OP_NOINLINE
873 __attribute__((__unused__))
874 #endif
875 ;
876 #ifndef VNODE_OP_NOINLINE
877 static __inline int VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies)
878 struct vnode *vp;
879 struct uio *uio;
880 struct ucred *cred;
881 int *eofflag;
882 off_t **cookies;
883 int *ncookies;
884 {
885 struct vop_readdir_args a;
886 a.a_desc = VDESC(vop_readdir);
887 a.a_vp = vp;
888 a.a_uio = uio;
889 a.a_cred = cred;
890 a.a_eofflag = eofflag;
891 a.a_cookies = cookies;
892 a.a_ncookies = ncookies;
893 return (VCALL(vp, VOFFSET(vop_readdir), &a));
894 }
895 #endif
896
897 struct vop_readlink_args {
898 const struct vnodeop_desc *a_desc;
899 struct vnode *a_vp;
900 struct uio *a_uio;
901 struct ucred *a_cred;
902 };
903 extern const struct vnodeop_desc vop_readlink_desc;
904 #ifndef VNODE_OP_NOINLINE
905 static __inline
906 #endif
907 int VOP_READLINK(struct vnode *, struct uio *, struct ucred *)
908 #ifndef VNODE_OP_NOINLINE
909 __attribute__((__unused__))
910 #endif
911 ;
912 #ifndef VNODE_OP_NOINLINE
913 static __inline int VOP_READLINK(vp, uio, cred)
914 struct vnode *vp;
915 struct uio *uio;
916 struct ucred *cred;
917 {
918 struct vop_readlink_args a;
919 a.a_desc = VDESC(vop_readlink);
920 a.a_vp = vp;
921 a.a_uio = uio;
922 a.a_cred = cred;
923 return (VCALL(vp, VOFFSET(vop_readlink), &a));
924 }
925 #endif
926
927 struct vop_abortop_args {
928 const struct vnodeop_desc *a_desc;
929 struct vnode *a_dvp;
930 struct componentname *a_cnp;
931 };
932 extern const struct vnodeop_desc vop_abortop_desc;
933 #ifndef VNODE_OP_NOINLINE
934 static __inline
935 #endif
936 int VOP_ABORTOP(struct vnode *, struct componentname *)
937 #ifndef VNODE_OP_NOINLINE
938 __attribute__((__unused__))
939 #endif
940 ;
941 #ifndef VNODE_OP_NOINLINE
942 static __inline int VOP_ABORTOP(dvp, cnp)
943 struct vnode *dvp;
944 struct componentname *cnp;
945 {
946 struct vop_abortop_args a;
947 a.a_desc = VDESC(vop_abortop);
948 a.a_dvp = dvp;
949 a.a_cnp = cnp;
950 return (VCALL(dvp, VOFFSET(vop_abortop), &a));
951 }
952 #endif
953
954 struct vop_inactive_args {
955 const struct vnodeop_desc *a_desc;
956 struct vnode *a_vp;
957 struct proc *a_p;
958 };
959 extern const struct vnodeop_desc vop_inactive_desc;
960 #ifndef VNODE_OP_NOINLINE
961 static __inline
962 #endif
963 int VOP_INACTIVE(struct vnode *, struct proc *)
964 #ifndef VNODE_OP_NOINLINE
965 __attribute__((__unused__))
966 #endif
967 ;
968 #ifndef VNODE_OP_NOINLINE
969 static __inline int VOP_INACTIVE(vp, p)
970 struct vnode *vp;
971 struct proc *p;
972 {
973 struct vop_inactive_args a;
974 a.a_desc = VDESC(vop_inactive);
975 a.a_vp = vp;
976 a.a_p = p;
977 return (VCALL(vp, VOFFSET(vop_inactive), &a));
978 }
979 #endif
980
981 struct vop_reclaim_args {
982 const struct vnodeop_desc *a_desc;
983 struct vnode *a_vp;
984 struct proc *a_p;
985 };
986 extern const struct vnodeop_desc vop_reclaim_desc;
987 #ifndef VNODE_OP_NOINLINE
988 static __inline
989 #endif
990 int VOP_RECLAIM(struct vnode *, struct proc *)
991 #ifndef VNODE_OP_NOINLINE
992 __attribute__((__unused__))
993 #endif
994 ;
995 #ifndef VNODE_OP_NOINLINE
996 static __inline int VOP_RECLAIM(vp, p)
997 struct vnode *vp;
998 struct proc *p;
999 {
1000 struct vop_reclaim_args a;
1001 a.a_desc = VDESC(vop_reclaim);
1002 a.a_vp = vp;
1003 a.a_p = p;
1004 return (VCALL(vp, VOFFSET(vop_reclaim), &a));
1005 }
1006 #endif
1007
1008 struct vop_lock_args {
1009 const struct vnodeop_desc *a_desc;
1010 struct vnode *a_vp;
1011 int a_flags;
1012 };
1013 extern const struct vnodeop_desc vop_lock_desc;
1014 #ifndef VNODE_OP_NOINLINE
1015 static __inline
1016 #endif
1017 int VOP_LOCK(struct vnode *, int)
1018 #ifndef VNODE_OP_NOINLINE
1019 __attribute__((__unused__))
1020 #endif
1021 ;
1022 #ifndef VNODE_OP_NOINLINE
1023 static __inline int VOP_LOCK(vp, flags)
1024 struct vnode *vp;
1025 int flags;
1026 {
1027 struct vop_lock_args a;
1028 a.a_desc = VDESC(vop_lock);
1029 a.a_vp = vp;
1030 a.a_flags = flags;
1031 return (VCALL(vp, VOFFSET(vop_lock), &a));
1032 }
1033 #endif
1034
1035 struct vop_unlock_args {
1036 const struct vnodeop_desc *a_desc;
1037 struct vnode *a_vp;
1038 int a_flags;
1039 };
1040 extern const struct vnodeop_desc vop_unlock_desc;
1041 #ifndef VNODE_OP_NOINLINE
1042 static __inline
1043 #endif
1044 int VOP_UNLOCK(struct vnode *, int)
1045 #ifndef VNODE_OP_NOINLINE
1046 __attribute__((__unused__))
1047 #endif
1048 ;
1049 #ifndef VNODE_OP_NOINLINE
1050 static __inline int VOP_UNLOCK(vp, flags)
1051 struct vnode *vp;
1052 int flags;
1053 {
1054 struct vop_unlock_args a;
1055 a.a_desc = VDESC(vop_unlock);
1056 a.a_vp = vp;
1057 a.a_flags = flags;
1058 return (VCALL(vp, VOFFSET(vop_unlock), &a));
1059 }
1060 #endif
1061
1062 struct vop_bmap_args {
1063 const struct vnodeop_desc *a_desc;
1064 struct vnode *a_vp;
1065 daddr_t a_bn;
1066 struct vnode **a_vpp;
1067 daddr_t *a_bnp;
1068 int *a_runp;
1069 };
1070 extern const struct vnodeop_desc vop_bmap_desc;
1071 #ifndef VNODE_OP_NOINLINE
1072 static __inline
1073 #endif
1074 int VOP_BMAP(struct vnode *, daddr_t, struct vnode **, daddr_t *, int *)
1075 #ifndef VNODE_OP_NOINLINE
1076 __attribute__((__unused__))
1077 #endif
1078 ;
1079 #ifndef VNODE_OP_NOINLINE
1080 static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp)
1081 struct vnode *vp;
1082 daddr_t bn;
1083 struct vnode **vpp;
1084 daddr_t *bnp;
1085 int *runp;
1086 {
1087 struct vop_bmap_args a;
1088 a.a_desc = VDESC(vop_bmap);
1089 a.a_vp = vp;
1090 a.a_bn = bn;
1091 a.a_vpp = vpp;
1092 a.a_bnp = bnp;
1093 a.a_runp = runp;
1094 return (VCALL(vp, VOFFSET(vop_bmap), &a));
1095 }
1096 #endif
1097
1098 struct vop_strategy_args {
1099 const struct vnodeop_desc *a_desc;
1100 struct vnode *a_vp;
1101 struct buf *a_bp;
1102 };
1103 extern const struct vnodeop_desc vop_strategy_desc;
1104 #ifndef VNODE_OP_NOINLINE
1105 static __inline
1106 #endif
1107 int VOP_STRATEGY(struct vnode *, struct buf *)
1108 #ifndef VNODE_OP_NOINLINE
1109 __attribute__((__unused__))
1110 #endif
1111 ;
1112 #ifndef VNODE_OP_NOINLINE
1113 static __inline int VOP_STRATEGY(vp, bp)
1114 struct vnode *vp;
1115 struct buf *bp;
1116 {
1117 struct vop_strategy_args a;
1118 a.a_desc = VDESC(vop_strategy);
1119 a.a_vp = vp;
1120 a.a_bp = bp;
1121 return (VCALL(vp, VOFFSET(vop_strategy), &a));
1122 }
1123 #endif
1124
1125 struct vop_print_args {
1126 const struct vnodeop_desc *a_desc;
1127 struct vnode *a_vp;
1128 };
1129 extern const struct vnodeop_desc vop_print_desc;
1130 #ifndef VNODE_OP_NOINLINE
1131 static __inline
1132 #endif
1133 int VOP_PRINT(struct vnode *)
1134 #ifndef VNODE_OP_NOINLINE
1135 __attribute__((__unused__))
1136 #endif
1137 ;
1138 #ifndef VNODE_OP_NOINLINE
1139 static __inline int VOP_PRINT(vp)
1140 struct vnode *vp;
1141 {
1142 struct vop_print_args a;
1143 a.a_desc = VDESC(vop_print);
1144 a.a_vp = vp;
1145 return (VCALL(vp, VOFFSET(vop_print), &a));
1146 }
1147 #endif
1148
1149 struct vop_islocked_args {
1150 const struct vnodeop_desc *a_desc;
1151 struct vnode *a_vp;
1152 };
1153 extern const struct vnodeop_desc vop_islocked_desc;
1154 #ifndef VNODE_OP_NOINLINE
1155 static __inline
1156 #endif
1157 int VOP_ISLOCKED(struct vnode *)
1158 #ifndef VNODE_OP_NOINLINE
1159 __attribute__((__unused__))
1160 #endif
1161 ;
1162 #ifndef VNODE_OP_NOINLINE
1163 static __inline int VOP_ISLOCKED(vp)
1164 struct vnode *vp;
1165 {
1166 struct vop_islocked_args a;
1167 a.a_desc = VDESC(vop_islocked);
1168 a.a_vp = vp;
1169 return (VCALL(vp, VOFFSET(vop_islocked), &a));
1170 }
1171 #endif
1172
1173 struct vop_pathconf_args {
1174 const struct vnodeop_desc *a_desc;
1175 struct vnode *a_vp;
1176 int a_name;
1177 register_t *a_retval;
1178 };
1179 extern const struct vnodeop_desc vop_pathconf_desc;
1180 #ifndef VNODE_OP_NOINLINE
1181 static __inline
1182 #endif
1183 int VOP_PATHCONF(struct vnode *, int, register_t *)
1184 #ifndef VNODE_OP_NOINLINE
1185 __attribute__((__unused__))
1186 #endif
1187 ;
1188 #ifndef VNODE_OP_NOINLINE
1189 static __inline int VOP_PATHCONF(vp, name, retval)
1190 struct vnode *vp;
1191 int name;
1192 register_t *retval;
1193 {
1194 struct vop_pathconf_args a;
1195 a.a_desc = VDESC(vop_pathconf);
1196 a.a_vp = vp;
1197 a.a_name = name;
1198 a.a_retval = retval;
1199 return (VCALL(vp, VOFFSET(vop_pathconf), &a));
1200 }
1201 #endif
1202
1203 struct vop_advlock_args {
1204 const struct vnodeop_desc *a_desc;
1205 struct vnode *a_vp;
1206 void *a_id;
1207 int a_op;
1208 struct flock *a_fl;
1209 int a_flags;
1210 };
1211 extern const struct vnodeop_desc vop_advlock_desc;
1212 #ifndef VNODE_OP_NOINLINE
1213 static __inline
1214 #endif
1215 int VOP_ADVLOCK(struct vnode *, void *, int, struct flock *, int)
1216 #ifndef VNODE_OP_NOINLINE
1217 __attribute__((__unused__))
1218 #endif
1219 ;
1220 #ifndef VNODE_OP_NOINLINE
1221 static __inline int VOP_ADVLOCK(vp, id, op, fl, flags)
1222 struct vnode *vp;
1223 void *id;
1224 int op;
1225 struct flock *fl;
1226 int flags;
1227 {
1228 struct vop_advlock_args a;
1229 a.a_desc = VDESC(vop_advlock);
1230 a.a_vp = vp;
1231 a.a_id = id;
1232 a.a_op = op;
1233 a.a_fl = fl;
1234 a.a_flags = flags;
1235 return (VCALL(vp, VOFFSET(vop_advlock), &a));
1236 }
1237 #endif
1238
1239 struct vop_blkatoff_args {
1240 const struct vnodeop_desc *a_desc;
1241 struct vnode *a_vp;
1242 off_t a_offset;
1243 char **a_res;
1244 struct buf **a_bpp;
1245 };
1246 extern const struct vnodeop_desc vop_blkatoff_desc;
1247 #ifndef VNODE_OP_NOINLINE
1248 static __inline
1249 #endif
1250 int VOP_BLKATOFF(struct vnode *, off_t, char **, struct buf **)
1251 #ifndef VNODE_OP_NOINLINE
1252 __attribute__((__unused__))
1253 #endif
1254 ;
1255 #ifndef VNODE_OP_NOINLINE
1256 static __inline int VOP_BLKATOFF(vp, offset, res, bpp)
1257 struct vnode *vp;
1258 off_t offset;
1259 char **res;
1260 struct buf **bpp;
1261 {
1262 struct vop_blkatoff_args a;
1263 a.a_desc = VDESC(vop_blkatoff);
1264 a.a_vp = vp;
1265 a.a_offset = offset;
1266 a.a_res = res;
1267 a.a_bpp = bpp;
1268 return (VCALL(vp, VOFFSET(vop_blkatoff), &a));
1269 }
1270 #endif
1271
1272 struct vop_valloc_args {
1273 const struct vnodeop_desc *a_desc;
1274 struct vnode *a_pvp;
1275 int a_mode;
1276 struct ucred *a_cred;
1277 struct vnode **a_vpp;
1278 };
1279 extern const struct vnodeop_desc vop_valloc_desc;
1280 #ifndef VNODE_OP_NOINLINE
1281 static __inline
1282 #endif
1283 int VOP_VALLOC(struct vnode *, int, struct ucred *, struct vnode **)
1284 #ifndef VNODE_OP_NOINLINE
1285 __attribute__((__unused__))
1286 #endif
1287 ;
1288 #ifndef VNODE_OP_NOINLINE
1289 static __inline int VOP_VALLOC(pvp, mode, cred, vpp)
1290 struct vnode *pvp;
1291 int mode;
1292 struct ucred *cred;
1293 struct vnode **vpp;
1294 {
1295 struct vop_valloc_args a;
1296 a.a_desc = VDESC(vop_valloc);
1297 a.a_pvp = pvp;
1298 a.a_mode = mode;
1299 a.a_cred = cred;
1300 a.a_vpp = vpp;
1301 return (VCALL(pvp, VOFFSET(vop_valloc), &a));
1302 }
1303 #endif
1304
1305 struct vop_balloc_args {
1306 const struct vnodeop_desc *a_desc;
1307 struct vnode *a_vp;
1308 off_t a_startoffset;
1309 int a_size;
1310 struct ucred *a_cred;
1311 int a_flags;
1312 struct buf **a_bpp;
1313 };
1314 extern const struct vnodeop_desc vop_balloc_desc;
1315 #ifndef VNODE_OP_NOINLINE
1316 static __inline
1317 #endif
1318 int VOP_BALLOC(struct vnode *, off_t, int, struct ucred *, int, struct buf **)
1319 #ifndef VNODE_OP_NOINLINE
1320 __attribute__((__unused__))
1321 #endif
1322 ;
1323 #ifndef VNODE_OP_NOINLINE
1324 static __inline int VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
1325 struct vnode *vp;
1326 off_t startoffset;
1327 int size;
1328 struct ucred *cred;
1329 int flags;
1330 struct buf **bpp;
1331 {
1332 struct vop_balloc_args a;
1333 a.a_desc = VDESC(vop_balloc);
1334 a.a_vp = vp;
1335 a.a_startoffset = startoffset;
1336 a.a_size = size;
1337 a.a_cred = cred;
1338 a.a_flags = flags;
1339 a.a_bpp = bpp;
1340 return (VCALL(vp, VOFFSET(vop_balloc), &a));
1341 }
1342 #endif
1343
1344 struct vop_reallocblks_args {
1345 const struct vnodeop_desc *a_desc;
1346 struct vnode *a_vp;
1347 struct cluster_save *a_buflist;
1348 };
1349 extern const struct vnodeop_desc vop_reallocblks_desc;
1350 #ifndef VNODE_OP_NOINLINE
1351 static __inline
1352 #endif
1353 int VOP_REALLOCBLKS(struct vnode *, struct cluster_save *)
1354 #ifndef VNODE_OP_NOINLINE
1355 __attribute__((__unused__))
1356 #endif
1357 ;
1358 #ifndef VNODE_OP_NOINLINE
1359 static __inline int VOP_REALLOCBLKS(vp, buflist)
1360 struct vnode *vp;
1361 struct cluster_save *buflist;
1362 {
1363 struct vop_reallocblks_args a;
1364 a.a_desc = VDESC(vop_reallocblks);
1365 a.a_vp = vp;
1366 a.a_buflist = buflist;
1367 return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
1368 }
1369 #endif
1370
1371 struct vop_vfree_args {
1372 const struct vnodeop_desc *a_desc;
1373 struct vnode *a_pvp;
1374 ino_t a_ino;
1375 int a_mode;
1376 };
1377 extern const struct vnodeop_desc vop_vfree_desc;
1378 #ifndef VNODE_OP_NOINLINE
1379 static __inline
1380 #endif
1381 int VOP_VFREE(struct vnode *, ino_t, int)
1382 #ifndef VNODE_OP_NOINLINE
1383 __attribute__((__unused__))
1384 #endif
1385 ;
1386 #ifndef VNODE_OP_NOINLINE
1387 static __inline int VOP_VFREE(pvp, ino, mode)
1388 struct vnode *pvp;
1389 ino_t ino;
1390 int mode;
1391 {
1392 struct vop_vfree_args a;
1393 a.a_desc = VDESC(vop_vfree);
1394 a.a_pvp = pvp;
1395 a.a_ino = ino;
1396 a.a_mode = mode;
1397 return (VCALL(pvp, VOFFSET(vop_vfree), &a));
1398 }
1399 #endif
1400
1401 struct vop_truncate_args {
1402 const struct vnodeop_desc *a_desc;
1403 struct vnode *a_vp;
1404 off_t a_length;
1405 int a_flags;
1406 struct ucred *a_cred;
1407 struct proc *a_p;
1408 };
1409 extern const struct vnodeop_desc vop_truncate_desc;
1410 #ifndef VNODE_OP_NOINLINE
1411 static __inline
1412 #endif
1413 int VOP_TRUNCATE(struct vnode *, off_t, int, struct ucred *, struct proc *)
1414 #ifndef VNODE_OP_NOINLINE
1415 __attribute__((__unused__))
1416 #endif
1417 ;
1418 #ifndef VNODE_OP_NOINLINE
1419 static __inline int VOP_TRUNCATE(vp, length, flags, cred, p)
1420 struct vnode *vp;
1421 off_t length;
1422 int flags;
1423 struct ucred *cred;
1424 struct proc *p;
1425 {
1426 struct vop_truncate_args a;
1427 a.a_desc = VDESC(vop_truncate);
1428 a.a_vp = vp;
1429 a.a_length = length;
1430 a.a_flags = flags;
1431 a.a_cred = cred;
1432 a.a_p = p;
1433 return (VCALL(vp, VOFFSET(vop_truncate), &a));
1434 }
1435 #endif
1436
1437 struct vop_update_args {
1438 const struct vnodeop_desc *a_desc;
1439 struct vnode *a_vp;
1440 struct timespec *a_access;
1441 struct timespec *a_modify;
1442 int a_flags;
1443 };
1444 extern const struct vnodeop_desc vop_update_desc;
1445 #ifndef VNODE_OP_NOINLINE
1446 static __inline
1447 #endif
1448 int VOP_UPDATE(struct vnode *, struct timespec *, struct timespec *, int)
1449 #ifndef VNODE_OP_NOINLINE
1450 __attribute__((__unused__))
1451 #endif
1452 ;
1453 #ifndef VNODE_OP_NOINLINE
1454 static __inline int VOP_UPDATE(vp, access, modify, flags)
1455 struct vnode *vp;
1456 struct timespec *access;
1457 struct timespec *modify;
1458 int flags;
1459 {
1460 struct vop_update_args a;
1461 a.a_desc = VDESC(vop_update);
1462 a.a_vp = vp;
1463 a.a_access = access;
1464 a.a_modify = modify;
1465 a.a_flags = flags;
1466 return (VCALL(vp, VOFFSET(vop_update), &a));
1467 }
1468 #endif
1469
1470 struct vop_lease_args {
1471 const struct vnodeop_desc *a_desc;
1472 struct vnode *a_vp;
1473 struct proc *a_p;
1474 struct ucred *a_cred;
1475 int a_flag;
1476 };
1477 extern const struct vnodeop_desc vop_lease_desc;
1478 #ifndef VNODE_OP_NOINLINE
1479 static __inline
1480 #endif
1481 int VOP_LEASE(struct vnode *, struct proc *, struct ucred *, int)
1482 #ifndef VNODE_OP_NOINLINE
1483 __attribute__((__unused__))
1484 #endif
1485 ;
1486 #ifndef VNODE_OP_NOINLINE
1487 static __inline int VOP_LEASE(vp, p, cred, flag)
1488 struct vnode *vp;
1489 struct proc *p;
1490 struct ucred *cred;
1491 int flag;
1492 {
1493 struct vop_lease_args a;
1494 a.a_desc = VDESC(vop_lease);
1495 a.a_vp = vp;
1496 a.a_p = p;
1497 a.a_cred = cred;
1498 a.a_flag = flag;
1499 return (VCALL(vp, VOFFSET(vop_lease), &a));
1500 }
1501 #endif
1502
1503 struct vop_whiteout_args {
1504 const struct vnodeop_desc *a_desc;
1505 struct vnode *a_dvp;
1506 struct componentname *a_cnp;
1507 int a_flags;
1508 };
1509 extern const struct vnodeop_desc vop_whiteout_desc;
1510 #ifndef VNODE_OP_NOINLINE
1511 static __inline
1512 #endif
1513 int VOP_WHITEOUT(struct vnode *, struct componentname *, int)
1514 #ifndef VNODE_OP_NOINLINE
1515 __attribute__((__unused__))
1516 #endif
1517 ;
1518 #ifndef VNODE_OP_NOINLINE
1519 static __inline int VOP_WHITEOUT(dvp, cnp, flags)
1520 struct vnode *dvp;
1521 struct componentname *cnp;
1522 int flags;
1523 {
1524 struct vop_whiteout_args a;
1525 a.a_desc = VDESC(vop_whiteout);
1526 a.a_dvp = dvp;
1527 a.a_cnp = cnp;
1528 a.a_flags = flags;
1529 return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
1530 }
1531 #endif
1532
1533 struct vop_getpages_args {
1534 const struct vnodeop_desc *a_desc;
1535 struct vnode *a_vp;
1536 voff_t a_offset;
1537 struct vm_page **a_m;
1538 int *a_count;
1539 int a_centeridx;
1540 vm_prot_t a_access_type;
1541 int a_advice;
1542 int a_flags;
1543 };
1544 extern const struct vnodeop_desc vop_getpages_desc;
1545 #ifndef VNODE_OP_NOINLINE
1546 static __inline
1547 #endif
1548 int VOP_GETPAGES(struct vnode *, voff_t, struct vm_page **, int *, int,
1549 vm_prot_t, int, int)
1550 #ifndef VNODE_OP_NOINLINE
1551 __attribute__((__unused__))
1552 #endif
1553 ;
1554 #ifndef VNODE_OP_NOINLINE
1555 static __inline int VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags)
1556 struct vnode *vp;
1557 voff_t offset;
1558 struct vm_page **m;
1559 int *count;
1560 int centeridx;
1561 vm_prot_t access_type;
1562 int advice;
1563 int flags;
1564 {
1565 struct vop_getpages_args a;
1566 a.a_desc = VDESC(vop_getpages);
1567 a.a_vp = vp;
1568 a.a_offset = offset;
1569 a.a_m = m;
1570 a.a_count = count;
1571 a.a_centeridx = centeridx;
1572 a.a_access_type = access_type;
1573 a.a_advice = advice;
1574 a.a_flags = flags;
1575 return (VCALL(vp, VOFFSET(vop_getpages), &a));
1576 }
1577 #endif
1578
1579 struct vop_putpages_args {
1580 const struct vnodeop_desc *a_desc;
1581 struct vnode *a_vp;
1582 voff_t a_offlo;
1583 voff_t a_offhi;
1584 int a_flags;
1585 };
1586 extern const struct vnodeop_desc vop_putpages_desc;
1587 #ifndef VNODE_OP_NOINLINE
1588 static __inline
1589 #endif
1590 int VOP_PUTPAGES(struct vnode *, voff_t, voff_t, int)
1591 #ifndef VNODE_OP_NOINLINE
1592 __attribute__((__unused__))
1593 #endif
1594 ;
1595 #ifndef VNODE_OP_NOINLINE
1596 static __inline int VOP_PUTPAGES(vp, offlo, offhi, flags)
1597 struct vnode *vp;
1598 voff_t offlo;
1599 voff_t offhi;
1600 int flags;
1601 {
1602 struct vop_putpages_args a;
1603 a.a_desc = VDESC(vop_putpages);
1604 a.a_vp = vp;
1605 a.a_offlo = offlo;
1606 a.a_offhi = offhi;
1607 a.a_flags = flags;
1608 return (VCALL(vp, VOFFSET(vop_putpages), &a));
1609 }
1610 #endif
1611
1612 /* Special cases: */
1613 #include <sys/buf.h>
1614
1615 struct vop_bwrite_args {
1616 const struct vnodeop_desc *a_desc;
1617 struct buf *a_bp;
1618 };
1619 extern const struct vnodeop_desc vop_bwrite_desc;
1620 #ifndef VNODE_OP_NOINLINE
1621 static __inline
1622 #endif
1623 int VOP_BWRITE(struct buf *)
1624 #ifndef VNODE_OP_NOINLINE
1625 __attribute__((__unused__))
1626 #endif
1627 ;
1628 #ifndef VNODE_OP_NOINLINE
1629 static __inline int VOP_BWRITE(bp)
1630 struct buf *bp;
1631 {
1632 struct vop_bwrite_args a;
1633 a.a_desc = VDESC(vop_bwrite);
1634 a.a_bp = bp;
1635 return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
1636 }
1637 #endif
1638
1639 #define VNODE_OPS_COUNT 50
1640
1641 /* End of special cases. */
1642
1643 #endif /* !_SYS_VNODE_IF_H_ */
Cache object: 6e924c76f850af1363ed7d201dc114bd
|