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