FreeBSD/Linux Kernel Cross Reference
sys/kern/vnode_if.c
1 /* $NetBSD: vnode_if.c,v 1.53 2005/02/26 22:15:10 perry Exp $ */
2
3 /*
4 * Warning: DO NOT EDIT! This file is automatically generated!
5 * (Modifications made here may easily be lost!)
6 *
7 * Created from the file:
8 * NetBSD: vnode_if.src,v 1.44 2005/02/26 22:14:39 perry Exp
9 * by the script:
10 * NetBSD: vnode_if.sh,v 1.38 2005/02/26 22:06:38 perry 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.53 2005/02/26 22:15:10 perry 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 #include "opt_vnode_lockdebug.h"
56
57 #include <sys/param.h>
58 #include <sys/mount.h>
59 #include <sys/buf.h>
60 #include <sys/vnode.h>
61
62 const struct vnodeop_desc vop_default_desc = {
63 0,
64 "default",
65 0,
66 NULL,
67 VDESC_NO_OFFSET,
68 VDESC_NO_OFFSET,
69 VDESC_NO_OFFSET,
70 VDESC_NO_OFFSET,
71 NULL,
72 };
73
74
75 /* Special cases: */
76
77 const int vop_bwrite_vp_offsets[] = {
78 VDESC_NO_OFFSET
79 };
80 const struct vnodeop_desc vop_bwrite_desc = {
81 1,
82 "vop_bwrite",
83 0,
84 vop_bwrite_vp_offsets,
85 VDESC_NO_OFFSET,
86 VDESC_NO_OFFSET,
87 VDESC_NO_OFFSET,
88 VDESC_NO_OFFSET,
89 NULL,
90 };
91 #ifdef VNODE_OP_NOINLINE
92 int
93 VOP_BWRITE(bp)
94 struct buf *bp;
95 {
96 struct vop_bwrite_args a;
97 #ifdef VNODE_LOCKDEBUG
98 #endif
99 a.a_desc = VDESC(vop_bwrite);
100 a.a_bp = bp;
101 return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
102 }
103 #endif
104
105 /* End of special cases */
106
107 const int vop_lookup_vp_offsets[] = {
108 VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp),
109 VDESC_NO_OFFSET
110 };
111 const struct vnodeop_desc vop_lookup_desc = {
112 2,
113 "vop_lookup",
114 0,
115 vop_lookup_vp_offsets,
116 VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp),
117 VDESC_NO_OFFSET,
118 VDESC_NO_OFFSET,
119 VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp),
120 NULL,
121 };
122 #ifdef VNODE_OP_NOINLINE
123 int
124 VOP_LOOKUP(dvp, vpp, cnp)
125 struct vnode *dvp;
126 struct vnode **vpp;
127 struct componentname *cnp;
128 {
129 struct vop_lookup_args a;
130 #ifdef VNODE_LOCKDEBUG
131 #endif
132 a.a_desc = VDESC(vop_lookup);
133 a.a_dvp = dvp;
134 a.a_vpp = vpp;
135 a.a_cnp = cnp;
136 return (VCALL(dvp, VOFFSET(vop_lookup), &a));
137 }
138 #endif
139
140 const int vop_create_vp_offsets[] = {
141 VOPARG_OFFSETOF(struct vop_create_args,a_dvp),
142 VDESC_NO_OFFSET
143 };
144 const struct vnodeop_desc vop_create_desc = {
145 3,
146 "vop_create",
147 0 | VDESC_VP0_WILLPUT,
148 vop_create_vp_offsets,
149 VOPARG_OFFSETOF(struct vop_create_args, a_vpp),
150 VDESC_NO_OFFSET,
151 VDESC_NO_OFFSET,
152 VOPARG_OFFSETOF(struct vop_create_args, a_cnp),
153 NULL,
154 };
155 #ifdef VNODE_OP_NOINLINE
156 int
157 VOP_CREATE(dvp, vpp, cnp, vap)
158 struct vnode *dvp;
159 struct vnode **vpp;
160 struct componentname *cnp;
161 struct vattr *vap;
162 {
163 struct vop_create_args a;
164 #ifdef VNODE_LOCKDEBUG
165 int islocked_dvp;
166 #endif
167 a.a_desc = VDESC(vop_create);
168 a.a_dvp = dvp;
169 #ifdef VNODE_LOCKDEBUG
170 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
171 if (islocked_dvp != 1)
172 panic("vop_create: dvp: locked %d, expected %d", islocked_dvp, 1);
173 #endif
174 a.a_vpp = vpp;
175 a.a_cnp = cnp;
176 a.a_vap = vap;
177 return (VCALL(dvp, VOFFSET(vop_create), &a));
178 }
179 #endif
180
181 const int vop_mknod_vp_offsets[] = {
182 VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp),
183 VDESC_NO_OFFSET
184 };
185 const struct vnodeop_desc vop_mknod_desc = {
186 4,
187 "vop_mknod",
188 0 | VDESC_VP0_WILLPUT,
189 vop_mknod_vp_offsets,
190 VOPARG_OFFSETOF(struct vop_mknod_args, a_vpp),
191 VDESC_NO_OFFSET,
192 VDESC_NO_OFFSET,
193 VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp),
194 NULL,
195 };
196 #ifdef VNODE_OP_NOINLINE
197 int
198 VOP_MKNOD(dvp, vpp, cnp, vap)
199 struct vnode *dvp;
200 struct vnode **vpp;
201 struct componentname *cnp;
202 struct vattr *vap;
203 {
204 struct vop_mknod_args a;
205 #ifdef VNODE_LOCKDEBUG
206 int islocked_dvp;
207 #endif
208 a.a_desc = VDESC(vop_mknod);
209 a.a_dvp = dvp;
210 #ifdef VNODE_LOCKDEBUG
211 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
212 if (islocked_dvp != 1)
213 panic("vop_mknod: dvp: locked %d, expected %d", islocked_dvp, 1);
214 #endif
215 a.a_vpp = vpp;
216 a.a_cnp = cnp;
217 a.a_vap = vap;
218 return (VCALL(dvp, VOFFSET(vop_mknod), &a));
219 }
220 #endif
221
222 const int vop_open_vp_offsets[] = {
223 VOPARG_OFFSETOF(struct vop_open_args,a_vp),
224 VDESC_NO_OFFSET
225 };
226 const struct vnodeop_desc vop_open_desc = {
227 5,
228 "vop_open",
229 0,
230 vop_open_vp_offsets,
231 VDESC_NO_OFFSET,
232 VOPARG_OFFSETOF(struct vop_open_args, a_cred),
233 VOPARG_OFFSETOF(struct vop_open_args, a_p),
234 VDESC_NO_OFFSET,
235 NULL,
236 };
237 #ifdef VNODE_OP_NOINLINE
238 int
239 VOP_OPEN(vp, mode, cred, p)
240 struct vnode *vp;
241 int mode;
242 struct ucred *cred;
243 struct proc *p;
244 {
245 struct vop_open_args a;
246 #ifdef VNODE_LOCKDEBUG
247 int islocked_vp;
248 #endif
249 a.a_desc = VDESC(vop_open);
250 a.a_vp = vp;
251 #ifdef VNODE_LOCKDEBUG
252 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
253 if (islocked_vp != 1)
254 panic("vop_open: vp: locked %d, expected %d", islocked_vp, 1);
255 #endif
256 a.a_mode = mode;
257 a.a_cred = cred;
258 a.a_p = p;
259 return (VCALL(vp, VOFFSET(vop_open), &a));
260 }
261 #endif
262
263 const int vop_close_vp_offsets[] = {
264 VOPARG_OFFSETOF(struct vop_close_args,a_vp),
265 VDESC_NO_OFFSET
266 };
267 const struct vnodeop_desc vop_close_desc = {
268 6,
269 "vop_close",
270 0,
271 vop_close_vp_offsets,
272 VDESC_NO_OFFSET,
273 VOPARG_OFFSETOF(struct vop_close_args, a_cred),
274 VOPARG_OFFSETOF(struct vop_close_args, a_p),
275 VDESC_NO_OFFSET,
276 NULL,
277 };
278 #ifdef VNODE_OP_NOINLINE
279 int
280 VOP_CLOSE(vp, fflag, cred, p)
281 struct vnode *vp;
282 int fflag;
283 struct ucred *cred;
284 struct proc *p;
285 {
286 struct vop_close_args a;
287 #ifdef VNODE_LOCKDEBUG
288 int islocked_vp;
289 #endif
290 a.a_desc = VDESC(vop_close);
291 a.a_vp = vp;
292 #ifdef VNODE_LOCKDEBUG
293 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
294 if (islocked_vp != 1)
295 panic("vop_close: vp: locked %d, expected %d", islocked_vp, 1);
296 #endif
297 a.a_fflag = fflag;
298 a.a_cred = cred;
299 a.a_p = p;
300 return (VCALL(vp, VOFFSET(vop_close), &a));
301 }
302 #endif
303
304 const int vop_access_vp_offsets[] = {
305 VOPARG_OFFSETOF(struct vop_access_args,a_vp),
306 VDESC_NO_OFFSET
307 };
308 const struct vnodeop_desc vop_access_desc = {
309 7,
310 "vop_access",
311 0,
312 vop_access_vp_offsets,
313 VDESC_NO_OFFSET,
314 VOPARG_OFFSETOF(struct vop_access_args, a_cred),
315 VOPARG_OFFSETOF(struct vop_access_args, a_p),
316 VDESC_NO_OFFSET,
317 NULL,
318 };
319 #ifdef VNODE_OP_NOINLINE
320 int
321 VOP_ACCESS(vp, mode, cred, p)
322 struct vnode *vp;
323 int mode;
324 struct ucred *cred;
325 struct proc *p;
326 {
327 struct vop_access_args a;
328 #ifdef VNODE_LOCKDEBUG
329 int islocked_vp;
330 #endif
331 a.a_desc = VDESC(vop_access);
332 a.a_vp = vp;
333 #ifdef VNODE_LOCKDEBUG
334 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
335 if (islocked_vp != 1)
336 panic("vop_access: vp: locked %d, expected %d", islocked_vp, 1);
337 #endif
338 a.a_mode = mode;
339 a.a_cred = cred;
340 a.a_p = p;
341 return (VCALL(vp, VOFFSET(vop_access), &a));
342 }
343 #endif
344
345 const int vop_getattr_vp_offsets[] = {
346 VOPARG_OFFSETOF(struct vop_getattr_args,a_vp),
347 VDESC_NO_OFFSET
348 };
349 const struct vnodeop_desc vop_getattr_desc = {
350 8,
351 "vop_getattr",
352 0,
353 vop_getattr_vp_offsets,
354 VDESC_NO_OFFSET,
355 VOPARG_OFFSETOF(struct vop_getattr_args, a_cred),
356 VOPARG_OFFSETOF(struct vop_getattr_args, a_p),
357 VDESC_NO_OFFSET,
358 NULL,
359 };
360 #ifdef VNODE_OP_NOINLINE
361 int
362 VOP_GETATTR(vp, vap, cred, p)
363 struct vnode *vp;
364 struct vattr *vap;
365 struct ucred *cred;
366 struct proc *p;
367 {
368 struct vop_getattr_args a;
369 #ifdef VNODE_LOCKDEBUG
370 #endif
371 a.a_desc = VDESC(vop_getattr);
372 a.a_vp = vp;
373 a.a_vap = vap;
374 a.a_cred = cred;
375 a.a_p = p;
376 return (VCALL(vp, VOFFSET(vop_getattr), &a));
377 }
378 #endif
379
380 const int vop_setattr_vp_offsets[] = {
381 VOPARG_OFFSETOF(struct vop_setattr_args,a_vp),
382 VDESC_NO_OFFSET
383 };
384 const struct vnodeop_desc vop_setattr_desc = {
385 9,
386 "vop_setattr",
387 0,
388 vop_setattr_vp_offsets,
389 VDESC_NO_OFFSET,
390 VOPARG_OFFSETOF(struct vop_setattr_args, a_cred),
391 VOPARG_OFFSETOF(struct vop_setattr_args, a_p),
392 VDESC_NO_OFFSET,
393 NULL,
394 };
395 #ifdef VNODE_OP_NOINLINE
396 int
397 VOP_SETATTR(vp, vap, cred, p)
398 struct vnode *vp;
399 struct vattr *vap;
400 struct ucred *cred;
401 struct proc *p;
402 {
403 struct vop_setattr_args a;
404 #ifdef VNODE_LOCKDEBUG
405 int islocked_vp;
406 #endif
407 a.a_desc = VDESC(vop_setattr);
408 a.a_vp = vp;
409 #ifdef VNODE_LOCKDEBUG
410 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
411 if (islocked_vp != 1)
412 panic("vop_setattr: vp: locked %d, expected %d", islocked_vp, 1);
413 #endif
414 a.a_vap = vap;
415 a.a_cred = cred;
416 a.a_p = p;
417 return (VCALL(vp, VOFFSET(vop_setattr), &a));
418 }
419 #endif
420
421 const int vop_read_vp_offsets[] = {
422 VOPARG_OFFSETOF(struct vop_read_args,a_vp),
423 VDESC_NO_OFFSET
424 };
425 const struct vnodeop_desc vop_read_desc = {
426 10,
427 "vop_read",
428 0,
429 vop_read_vp_offsets,
430 VDESC_NO_OFFSET,
431 VOPARG_OFFSETOF(struct vop_read_args, a_cred),
432 VDESC_NO_OFFSET,
433 VDESC_NO_OFFSET,
434 NULL,
435 };
436 #ifdef VNODE_OP_NOINLINE
437 int
438 VOP_READ(vp, uio, ioflag, cred)
439 struct vnode *vp;
440 struct uio *uio;
441 int ioflag;
442 struct ucred *cred;
443 {
444 struct vop_read_args a;
445 #ifdef VNODE_LOCKDEBUG
446 int islocked_vp;
447 #endif
448 a.a_desc = VDESC(vop_read);
449 a.a_vp = vp;
450 #ifdef VNODE_LOCKDEBUG
451 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
452 if (islocked_vp != 1)
453 panic("vop_read: vp: locked %d, expected %d", islocked_vp, 1);
454 #endif
455 a.a_uio = uio;
456 a.a_ioflag = ioflag;
457 a.a_cred = cred;
458 return (VCALL(vp, VOFFSET(vop_read), &a));
459 }
460 #endif
461
462 const int vop_write_vp_offsets[] = {
463 VOPARG_OFFSETOF(struct vop_write_args,a_vp),
464 VDESC_NO_OFFSET
465 };
466 const struct vnodeop_desc vop_write_desc = {
467 11,
468 "vop_write",
469 0,
470 vop_write_vp_offsets,
471 VDESC_NO_OFFSET,
472 VOPARG_OFFSETOF(struct vop_write_args, a_cred),
473 VDESC_NO_OFFSET,
474 VDESC_NO_OFFSET,
475 NULL,
476 };
477 #ifdef VNODE_OP_NOINLINE
478 int
479 VOP_WRITE(vp, uio, ioflag, cred)
480 struct vnode *vp;
481 struct uio *uio;
482 int ioflag;
483 struct ucred *cred;
484 {
485 struct vop_write_args a;
486 #ifdef VNODE_LOCKDEBUG
487 int islocked_vp;
488 #endif
489 a.a_desc = VDESC(vop_write);
490 a.a_vp = vp;
491 #ifdef VNODE_LOCKDEBUG
492 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
493 if (islocked_vp != 1)
494 panic("vop_write: vp: locked %d, expected %d", islocked_vp, 1);
495 #endif
496 a.a_uio = uio;
497 a.a_ioflag = ioflag;
498 a.a_cred = cred;
499 return (VCALL(vp, VOFFSET(vop_write), &a));
500 }
501 #endif
502
503 const int vop_ioctl_vp_offsets[] = {
504 VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp),
505 VDESC_NO_OFFSET
506 };
507 const struct vnodeop_desc vop_ioctl_desc = {
508 12,
509 "vop_ioctl",
510 0,
511 vop_ioctl_vp_offsets,
512 VDESC_NO_OFFSET,
513 VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred),
514 VOPARG_OFFSETOF(struct vop_ioctl_args, a_p),
515 VDESC_NO_OFFSET,
516 NULL,
517 };
518 #ifdef VNODE_OP_NOINLINE
519 int
520 VOP_IOCTL(vp, command, data, fflag, cred, p)
521 struct vnode *vp;
522 u_long command;
523 void *data;
524 int fflag;
525 struct ucred *cred;
526 struct proc *p;
527 {
528 struct vop_ioctl_args a;
529 #ifdef VNODE_LOCKDEBUG
530 int islocked_vp;
531 #endif
532 a.a_desc = VDESC(vop_ioctl);
533 a.a_vp = vp;
534 #ifdef VNODE_LOCKDEBUG
535 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
536 if (islocked_vp != 0)
537 panic("vop_ioctl: vp: locked %d, expected %d", islocked_vp, 0);
538 #endif
539 a.a_command = command;
540 a.a_data = data;
541 a.a_fflag = fflag;
542 a.a_cred = cred;
543 a.a_p = p;
544 return (VCALL(vp, VOFFSET(vop_ioctl), &a));
545 }
546 #endif
547
548 const int vop_fcntl_vp_offsets[] = {
549 VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp),
550 VDESC_NO_OFFSET
551 };
552 const struct vnodeop_desc vop_fcntl_desc = {
553 13,
554 "vop_fcntl",
555 0,
556 vop_fcntl_vp_offsets,
557 VDESC_NO_OFFSET,
558 VOPARG_OFFSETOF(struct vop_fcntl_args, a_cred),
559 VOPARG_OFFSETOF(struct vop_fcntl_args, a_p),
560 VDESC_NO_OFFSET,
561 NULL,
562 };
563 #ifdef VNODE_OP_NOINLINE
564 int
565 VOP_FCNTL(vp, command, data, fflag, cred, p)
566 struct vnode *vp;
567 u_int command;
568 void *data;
569 int fflag;
570 struct ucred *cred;
571 struct proc *p;
572 {
573 struct vop_fcntl_args a;
574 #ifdef VNODE_LOCKDEBUG
575 int islocked_vp;
576 #endif
577 a.a_desc = VDESC(vop_fcntl);
578 a.a_vp = vp;
579 #ifdef VNODE_LOCKDEBUG
580 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
581 if (islocked_vp != 1)
582 panic("vop_fcntl: vp: locked %d, expected %d", islocked_vp, 1);
583 #endif
584 a.a_command = command;
585 a.a_data = data;
586 a.a_fflag = fflag;
587 a.a_cred = cred;
588 a.a_p = p;
589 return (VCALL(vp, VOFFSET(vop_fcntl), &a));
590 }
591 #endif
592
593 const int vop_poll_vp_offsets[] = {
594 VOPARG_OFFSETOF(struct vop_poll_args,a_vp),
595 VDESC_NO_OFFSET
596 };
597 const struct vnodeop_desc vop_poll_desc = {
598 14,
599 "vop_poll",
600 0,
601 vop_poll_vp_offsets,
602 VDESC_NO_OFFSET,
603 VDESC_NO_OFFSET,
604 VOPARG_OFFSETOF(struct vop_poll_args, a_p),
605 VDESC_NO_OFFSET,
606 NULL,
607 };
608 #ifdef VNODE_OP_NOINLINE
609 int
610 VOP_POLL(vp, events, p)
611 struct vnode *vp;
612 int events;
613 struct proc *p;
614 {
615 struct vop_poll_args a;
616 #ifdef VNODE_LOCKDEBUG
617 int islocked_vp;
618 #endif
619 a.a_desc = VDESC(vop_poll);
620 a.a_vp = vp;
621 #ifdef VNODE_LOCKDEBUG
622 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
623 if (islocked_vp != 0)
624 panic("vop_poll: vp: locked %d, expected %d", islocked_vp, 0);
625 #endif
626 a.a_events = events;
627 a.a_p = p;
628 return (VCALL(vp, VOFFSET(vop_poll), &a));
629 }
630 #endif
631
632 const int vop_kqfilter_vp_offsets[] = {
633 VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp),
634 VDESC_NO_OFFSET
635 };
636 const struct vnodeop_desc vop_kqfilter_desc = {
637 15,
638 "vop_kqfilter",
639 0,
640 vop_kqfilter_vp_offsets,
641 VDESC_NO_OFFSET,
642 VDESC_NO_OFFSET,
643 VDESC_NO_OFFSET,
644 VDESC_NO_OFFSET,
645 NULL,
646 };
647 #ifdef VNODE_OP_NOINLINE
648 int
649 VOP_KQFILTER(vp, kn)
650 struct vnode *vp;
651 struct knote *kn;
652 {
653 struct vop_kqfilter_args a;
654 #ifdef VNODE_LOCKDEBUG
655 int islocked_vp;
656 #endif
657 a.a_desc = VDESC(vop_kqfilter);
658 a.a_vp = vp;
659 #ifdef VNODE_LOCKDEBUG
660 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
661 if (islocked_vp != 0)
662 panic("vop_kqfilter: vp: locked %d, expected %d", islocked_vp, 0);
663 #endif
664 a.a_kn = kn;
665 return (VCALL(vp, VOFFSET(vop_kqfilter), &a));
666 }
667 #endif
668
669 const int vop_revoke_vp_offsets[] = {
670 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp),
671 VDESC_NO_OFFSET
672 };
673 const struct vnodeop_desc vop_revoke_desc = {
674 16,
675 "vop_revoke",
676 0,
677 vop_revoke_vp_offsets,
678 VDESC_NO_OFFSET,
679 VDESC_NO_OFFSET,
680 VDESC_NO_OFFSET,
681 VDESC_NO_OFFSET,
682 NULL,
683 };
684 #ifdef VNODE_OP_NOINLINE
685 int
686 VOP_REVOKE(vp, flags)
687 struct vnode *vp;
688 int flags;
689 {
690 struct vop_revoke_args a;
691 #ifdef VNODE_LOCKDEBUG
692 int islocked_vp;
693 #endif
694 a.a_desc = VDESC(vop_revoke);
695 a.a_vp = vp;
696 #ifdef VNODE_LOCKDEBUG
697 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
698 if (islocked_vp != 0)
699 panic("vop_revoke: vp: locked %d, expected %d", islocked_vp, 0);
700 #endif
701 a.a_flags = flags;
702 return (VCALL(vp, VOFFSET(vop_revoke), &a));
703 }
704 #endif
705
706 const int vop_mmap_vp_offsets[] = {
707 VOPARG_OFFSETOF(struct vop_mmap_args,a_vp),
708 VDESC_NO_OFFSET
709 };
710 const struct vnodeop_desc vop_mmap_desc = {
711 17,
712 "vop_mmap",
713 0,
714 vop_mmap_vp_offsets,
715 VDESC_NO_OFFSET,
716 VOPARG_OFFSETOF(struct vop_mmap_args, a_cred),
717 VOPARG_OFFSETOF(struct vop_mmap_args, a_p),
718 VDESC_NO_OFFSET,
719 NULL,
720 };
721 #ifdef VNODE_OP_NOINLINE
722 int
723 VOP_MMAP(vp, fflags, cred, p)
724 struct vnode *vp;
725 int fflags;
726 struct ucred *cred;
727 struct proc *p;
728 {
729 struct vop_mmap_args a;
730 #ifdef VNODE_LOCKDEBUG
731 #endif
732 a.a_desc = VDESC(vop_mmap);
733 a.a_vp = vp;
734 a.a_fflags = fflags;
735 a.a_cred = cred;
736 a.a_p = p;
737 return (VCALL(vp, VOFFSET(vop_mmap), &a));
738 }
739 #endif
740
741 const int vop_fsync_vp_offsets[] = {
742 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp),
743 VDESC_NO_OFFSET
744 };
745 const struct vnodeop_desc vop_fsync_desc = {
746 18,
747 "vop_fsync",
748 0,
749 vop_fsync_vp_offsets,
750 VDESC_NO_OFFSET,
751 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred),
752 VOPARG_OFFSETOF(struct vop_fsync_args, a_p),
753 VDESC_NO_OFFSET,
754 NULL,
755 };
756 #ifdef VNODE_OP_NOINLINE
757 int
758 VOP_FSYNC(vp, cred, flags, offlo, offhi, p)
759 struct vnode *vp;
760 struct ucred *cred;
761 int flags;
762 off_t offlo;
763 off_t offhi;
764 struct proc *p;
765 {
766 struct vop_fsync_args a;
767 #ifdef VNODE_LOCKDEBUG
768 int islocked_vp;
769 #endif
770 a.a_desc = VDESC(vop_fsync);
771 a.a_vp = vp;
772 #ifdef VNODE_LOCKDEBUG
773 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
774 if (islocked_vp != 1)
775 panic("vop_fsync: vp: locked %d, expected %d", islocked_vp, 1);
776 #endif
777 a.a_cred = cred;
778 a.a_flags = flags;
779 a.a_offlo = offlo;
780 a.a_offhi = offhi;
781 a.a_p = p;
782 return (VCALL(vp, VOFFSET(vop_fsync), &a));
783 }
784 #endif
785
786 const int vop_seek_vp_offsets[] = {
787 VOPARG_OFFSETOF(struct vop_seek_args,a_vp),
788 VDESC_NO_OFFSET
789 };
790 const struct vnodeop_desc vop_seek_desc = {
791 19,
792 "vop_seek",
793 0,
794 vop_seek_vp_offsets,
795 VDESC_NO_OFFSET,
796 VOPARG_OFFSETOF(struct vop_seek_args, a_cred),
797 VDESC_NO_OFFSET,
798 VDESC_NO_OFFSET,
799 NULL,
800 };
801 #ifdef VNODE_OP_NOINLINE
802 int
803 VOP_SEEK(vp, oldoff, newoff, cred)
804 struct vnode *vp;
805 off_t oldoff;
806 off_t newoff;
807 struct ucred *cred;
808 {
809 struct vop_seek_args a;
810 #ifdef VNODE_LOCKDEBUG
811 #endif
812 a.a_desc = VDESC(vop_seek);
813 a.a_vp = vp;
814 a.a_oldoff = oldoff;
815 a.a_newoff = newoff;
816 a.a_cred = cred;
817 return (VCALL(vp, VOFFSET(vop_seek), &a));
818 }
819 #endif
820
821 const int vop_remove_vp_offsets[] = {
822 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp),
823 VOPARG_OFFSETOF(struct vop_remove_args,a_vp),
824 VDESC_NO_OFFSET
825 };
826 const struct vnodeop_desc vop_remove_desc = {
827 20,
828 "vop_remove",
829 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
830 vop_remove_vp_offsets,
831 VDESC_NO_OFFSET,
832 VDESC_NO_OFFSET,
833 VDESC_NO_OFFSET,
834 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp),
835 NULL,
836 };
837 #ifdef VNODE_OP_NOINLINE
838 int
839 VOP_REMOVE(dvp, vp, cnp)
840 struct vnode *dvp;
841 struct vnode *vp;
842 struct componentname *cnp;
843 {
844 struct vop_remove_args a;
845 #ifdef VNODE_LOCKDEBUG
846 int islocked_dvp;
847 int islocked_vp;
848 #endif
849 a.a_desc = VDESC(vop_remove);
850 a.a_dvp = dvp;
851 #ifdef VNODE_LOCKDEBUG
852 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
853 if (islocked_dvp != 1)
854 panic("vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1);
855 #endif
856 a.a_vp = vp;
857 #ifdef VNODE_LOCKDEBUG
858 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
859 if (islocked_vp != 1)
860 panic("vop_remove: vp: locked %d, expected %d", islocked_vp, 1);
861 #endif
862 a.a_cnp = cnp;
863 return (VCALL(dvp, VOFFSET(vop_remove), &a));
864 }
865 #endif
866
867 const int vop_link_vp_offsets[] = {
868 VOPARG_OFFSETOF(struct vop_link_args,a_dvp),
869 VOPARG_OFFSETOF(struct vop_link_args,a_vp),
870 VDESC_NO_OFFSET
871 };
872 const struct vnodeop_desc vop_link_desc = {
873 21,
874 "vop_link",
875 0 | VDESC_VP0_WILLPUT,
876 vop_link_vp_offsets,
877 VDESC_NO_OFFSET,
878 VDESC_NO_OFFSET,
879 VDESC_NO_OFFSET,
880 VOPARG_OFFSETOF(struct vop_link_args, a_cnp),
881 NULL,
882 };
883 #ifdef VNODE_OP_NOINLINE
884 int
885 VOP_LINK(dvp, vp, cnp)
886 struct vnode *dvp;
887 struct vnode *vp;
888 struct componentname *cnp;
889 {
890 struct vop_link_args a;
891 #ifdef VNODE_LOCKDEBUG
892 int islocked_dvp;
893 int islocked_vp;
894 #endif
895 a.a_desc = VDESC(vop_link);
896 a.a_dvp = dvp;
897 #ifdef VNODE_LOCKDEBUG
898 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
899 if (islocked_dvp != 1)
900 panic("vop_link: dvp: locked %d, expected %d", islocked_dvp, 1);
901 #endif
902 a.a_vp = vp;
903 #ifdef VNODE_LOCKDEBUG
904 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
905 if (islocked_vp != 0)
906 panic("vop_link: vp: locked %d, expected %d", islocked_vp, 0);
907 #endif
908 a.a_cnp = cnp;
909 return (VCALL(dvp, VOFFSET(vop_link), &a));
910 }
911 #endif
912
913 const int vop_rename_vp_offsets[] = {
914 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp),
915 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp),
916 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp),
917 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp),
918 VDESC_NO_OFFSET
919 };
920 const struct vnodeop_desc vop_rename_desc = {
921 22,
922 "vop_rename",
923 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT,
924 vop_rename_vp_offsets,
925 VDESC_NO_OFFSET,
926 VDESC_NO_OFFSET,
927 VDESC_NO_OFFSET,
928 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp),
929 NULL,
930 };
931 #ifdef VNODE_OP_NOINLINE
932 int
933 VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
934 struct vnode *fdvp;
935 struct vnode *fvp;
936 struct componentname *fcnp;
937 struct vnode *tdvp;
938 struct vnode *tvp;
939 struct componentname *tcnp;
940 {
941 struct vop_rename_args a;
942 #ifdef VNODE_LOCKDEBUG
943 int islocked_fdvp;
944 int islocked_fvp;
945 int islocked_tdvp;
946 #endif
947 a.a_desc = VDESC(vop_rename);
948 a.a_fdvp = fdvp;
949 #ifdef VNODE_LOCKDEBUG
950 islocked_fdvp = (fdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0;
951 if (islocked_fdvp != 0)
952 panic("vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0);
953 #endif
954 a.a_fvp = fvp;
955 #ifdef VNODE_LOCKDEBUG
956 islocked_fvp = (fvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0;
957 if (islocked_fvp != 0)
958 panic("vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0);
959 #endif
960 a.a_fcnp = fcnp;
961 a.a_tdvp = tdvp;
962 #ifdef VNODE_LOCKDEBUG
963 islocked_tdvp = (tdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1;
964 if (islocked_tdvp != 1)
965 panic("vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1);
966 #endif
967 a.a_tvp = tvp;
968 a.a_tcnp = tcnp;
969 return (VCALL(fdvp, VOFFSET(vop_rename), &a));
970 }
971 #endif
972
973 const int vop_mkdir_vp_offsets[] = {
974 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp),
975 VDESC_NO_OFFSET
976 };
977 const struct vnodeop_desc vop_mkdir_desc = {
978 23,
979 "vop_mkdir",
980 0 | VDESC_VP0_WILLPUT,
981 vop_mkdir_vp_offsets,
982 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp),
983 VDESC_NO_OFFSET,
984 VDESC_NO_OFFSET,
985 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp),
986 NULL,
987 };
988 #ifdef VNODE_OP_NOINLINE
989 int
990 VOP_MKDIR(dvp, vpp, cnp, vap)
991 struct vnode *dvp;
992 struct vnode **vpp;
993 struct componentname *cnp;
994 struct vattr *vap;
995 {
996 struct vop_mkdir_args a;
997 #ifdef VNODE_LOCKDEBUG
998 int islocked_dvp;
999 #endif
1000 a.a_desc = VDESC(vop_mkdir);
1001 a.a_dvp = dvp;
1002 #ifdef VNODE_LOCKDEBUG
1003 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
1004 if (islocked_dvp != 1)
1005 panic("vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1);
1006 #endif
1007 a.a_vpp = vpp;
1008 a.a_cnp = cnp;
1009 a.a_vap = vap;
1010 return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
1011 }
1012 #endif
1013
1014 const int vop_rmdir_vp_offsets[] = {
1015 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp),
1016 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp),
1017 VDESC_NO_OFFSET
1018 };
1019 const struct vnodeop_desc vop_rmdir_desc = {
1020 24,
1021 "vop_rmdir",
1022 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
1023 vop_rmdir_vp_offsets,
1024 VDESC_NO_OFFSET,
1025 VDESC_NO_OFFSET,
1026 VDESC_NO_OFFSET,
1027 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp),
1028 NULL,
1029 };
1030 #ifdef VNODE_OP_NOINLINE
1031 int
1032 VOP_RMDIR(dvp, vp, cnp)
1033 struct vnode *dvp;
1034 struct vnode *vp;
1035 struct componentname *cnp;
1036 {
1037 struct vop_rmdir_args a;
1038 #ifdef VNODE_LOCKDEBUG
1039 int islocked_dvp;
1040 int islocked_vp;
1041 #endif
1042 a.a_desc = VDESC(vop_rmdir);
1043 a.a_dvp = dvp;
1044 #ifdef VNODE_LOCKDEBUG
1045 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
1046 if (islocked_dvp != 1)
1047 panic("vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1);
1048 #endif
1049 a.a_vp = vp;
1050 #ifdef VNODE_LOCKDEBUG
1051 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1052 if (islocked_vp != 1)
1053 panic("vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1);
1054 #endif
1055 a.a_cnp = cnp;
1056 return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
1057 }
1058 #endif
1059
1060 const int vop_symlink_vp_offsets[] = {
1061 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp),
1062 VDESC_NO_OFFSET
1063 };
1064 const struct vnodeop_desc vop_symlink_desc = {
1065 25,
1066 "vop_symlink",
1067 0 | VDESC_VP0_WILLPUT,
1068 vop_symlink_vp_offsets,
1069 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp),
1070 VDESC_NO_OFFSET,
1071 VDESC_NO_OFFSET,
1072 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp),
1073 NULL,
1074 };
1075 #ifdef VNODE_OP_NOINLINE
1076 int
1077 VOP_SYMLINK(dvp, vpp, cnp, vap, target)
1078 struct vnode *dvp;
1079 struct vnode **vpp;
1080 struct componentname *cnp;
1081 struct vattr *vap;
1082 char *target;
1083 {
1084 struct vop_symlink_args a;
1085 #ifdef VNODE_LOCKDEBUG
1086 int islocked_dvp;
1087 #endif
1088 a.a_desc = VDESC(vop_symlink);
1089 a.a_dvp = dvp;
1090 #ifdef VNODE_LOCKDEBUG
1091 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
1092 if (islocked_dvp != 1)
1093 panic("vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1);
1094 #endif
1095 a.a_vpp = vpp;
1096 a.a_cnp = cnp;
1097 a.a_vap = vap;
1098 a.a_target = target;
1099 return (VCALL(dvp, VOFFSET(vop_symlink), &a));
1100 }
1101 #endif
1102
1103 const int vop_readdir_vp_offsets[] = {
1104 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp),
1105 VDESC_NO_OFFSET
1106 };
1107 const struct vnodeop_desc vop_readdir_desc = {
1108 26,
1109 "vop_readdir",
1110 0,
1111 vop_readdir_vp_offsets,
1112 VDESC_NO_OFFSET,
1113 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred),
1114 VDESC_NO_OFFSET,
1115 VDESC_NO_OFFSET,
1116 NULL,
1117 };
1118 #ifdef VNODE_OP_NOINLINE
1119 int
1120 VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies)
1121 struct vnode *vp;
1122 struct uio *uio;
1123 struct ucred *cred;
1124 int *eofflag;
1125 off_t **cookies;
1126 int *ncookies;
1127 {
1128 struct vop_readdir_args a;
1129 #ifdef VNODE_LOCKDEBUG
1130 int islocked_vp;
1131 #endif
1132 a.a_desc = VDESC(vop_readdir);
1133 a.a_vp = vp;
1134 #ifdef VNODE_LOCKDEBUG
1135 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1136 if (islocked_vp != 1)
1137 panic("vop_readdir: vp: locked %d, expected %d", islocked_vp, 1);
1138 #endif
1139 a.a_uio = uio;
1140 a.a_cred = cred;
1141 a.a_eofflag = eofflag;
1142 a.a_cookies = cookies;
1143 a.a_ncookies = ncookies;
1144 return (VCALL(vp, VOFFSET(vop_readdir), &a));
1145 }
1146 #endif
1147
1148 const int vop_readlink_vp_offsets[] = {
1149 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp),
1150 VDESC_NO_OFFSET
1151 };
1152 const struct vnodeop_desc vop_readlink_desc = {
1153 27,
1154 "vop_readlink",
1155 0,
1156 vop_readlink_vp_offsets,
1157 VDESC_NO_OFFSET,
1158 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred),
1159 VDESC_NO_OFFSET,
1160 VDESC_NO_OFFSET,
1161 NULL,
1162 };
1163 #ifdef VNODE_OP_NOINLINE
1164 int
1165 VOP_READLINK(vp, uio, cred)
1166 struct vnode *vp;
1167 struct uio *uio;
1168 struct ucred *cred;
1169 {
1170 struct vop_readlink_args a;
1171 #ifdef VNODE_LOCKDEBUG
1172 int islocked_vp;
1173 #endif
1174 a.a_desc = VDESC(vop_readlink);
1175 a.a_vp = vp;
1176 #ifdef VNODE_LOCKDEBUG
1177 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1178 if (islocked_vp != 1)
1179 panic("vop_readlink: vp: locked %d, expected %d", islocked_vp, 1);
1180 #endif
1181 a.a_uio = uio;
1182 a.a_cred = cred;
1183 return (VCALL(vp, VOFFSET(vop_readlink), &a));
1184 }
1185 #endif
1186
1187 const int vop_abortop_vp_offsets[] = {
1188 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp),
1189 VDESC_NO_OFFSET
1190 };
1191 const struct vnodeop_desc vop_abortop_desc = {
1192 28,
1193 "vop_abortop",
1194 0,
1195 vop_abortop_vp_offsets,
1196 VDESC_NO_OFFSET,
1197 VDESC_NO_OFFSET,
1198 VDESC_NO_OFFSET,
1199 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp),
1200 NULL,
1201 };
1202 #ifdef VNODE_OP_NOINLINE
1203 int
1204 VOP_ABORTOP(dvp, cnp)
1205 struct vnode *dvp;
1206 struct componentname *cnp;
1207 {
1208 struct vop_abortop_args a;
1209 #ifdef VNODE_LOCKDEBUG
1210 #endif
1211 a.a_desc = VDESC(vop_abortop);
1212 a.a_dvp = dvp;
1213 a.a_cnp = cnp;
1214 return (VCALL(dvp, VOFFSET(vop_abortop), &a));
1215 }
1216 #endif
1217
1218 const int vop_inactive_vp_offsets[] = {
1219 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp),
1220 VDESC_NO_OFFSET
1221 };
1222 const struct vnodeop_desc vop_inactive_desc = {
1223 29,
1224 "vop_inactive",
1225 0 | VDESC_VP0_WILLUNLOCK,
1226 vop_inactive_vp_offsets,
1227 VDESC_NO_OFFSET,
1228 VDESC_NO_OFFSET,
1229 VOPARG_OFFSETOF(struct vop_inactive_args, a_p),
1230 VDESC_NO_OFFSET,
1231 NULL,
1232 };
1233 #ifdef VNODE_OP_NOINLINE
1234 int
1235 VOP_INACTIVE(vp, p)
1236 struct vnode *vp;
1237 struct proc *p;
1238 {
1239 struct vop_inactive_args a;
1240 #ifdef VNODE_LOCKDEBUG
1241 int islocked_vp;
1242 #endif
1243 a.a_desc = VDESC(vop_inactive);
1244 a.a_vp = vp;
1245 #ifdef VNODE_LOCKDEBUG
1246 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1247 if (islocked_vp != 1)
1248 panic("vop_inactive: vp: locked %d, expected %d", islocked_vp, 1);
1249 #endif
1250 a.a_p = p;
1251 return (VCALL(vp, VOFFSET(vop_inactive), &a));
1252 }
1253 #endif
1254
1255 const int vop_reclaim_vp_offsets[] = {
1256 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp),
1257 VDESC_NO_OFFSET
1258 };
1259 const struct vnodeop_desc vop_reclaim_desc = {
1260 30,
1261 "vop_reclaim",
1262 0,
1263 vop_reclaim_vp_offsets,
1264 VDESC_NO_OFFSET,
1265 VDESC_NO_OFFSET,
1266 VOPARG_OFFSETOF(struct vop_reclaim_args, a_p),
1267 VDESC_NO_OFFSET,
1268 NULL,
1269 };
1270 #ifdef VNODE_OP_NOINLINE
1271 int
1272 VOP_RECLAIM(vp, p)
1273 struct vnode *vp;
1274 struct proc *p;
1275 {
1276 struct vop_reclaim_args a;
1277 #ifdef VNODE_LOCKDEBUG
1278 int islocked_vp;
1279 #endif
1280 a.a_desc = VDESC(vop_reclaim);
1281 a.a_vp = vp;
1282 #ifdef VNODE_LOCKDEBUG
1283 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
1284 if (islocked_vp != 0)
1285 panic("vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0);
1286 #endif
1287 a.a_p = p;
1288 return (VCALL(vp, VOFFSET(vop_reclaim), &a));
1289 }
1290 #endif
1291
1292 const int vop_lock_vp_offsets[] = {
1293 VOPARG_OFFSETOF(struct vop_lock_args,a_vp),
1294 VDESC_NO_OFFSET
1295 };
1296 const struct vnodeop_desc vop_lock_desc = {
1297 31,
1298 "vop_lock",
1299 0,
1300 vop_lock_vp_offsets,
1301 VDESC_NO_OFFSET,
1302 VDESC_NO_OFFSET,
1303 VDESC_NO_OFFSET,
1304 VDESC_NO_OFFSET,
1305 NULL,
1306 };
1307 #ifdef VNODE_OP_NOINLINE
1308 int
1309 VOP_LOCK(vp, flags)
1310 struct vnode *vp;
1311 int flags;
1312 {
1313 struct vop_lock_args a;
1314 #ifdef VNODE_LOCKDEBUG
1315 int islocked_vp;
1316 #endif
1317 a.a_desc = VDESC(vop_lock);
1318 a.a_vp = vp;
1319 #ifdef VNODE_LOCKDEBUG
1320 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
1321 if (islocked_vp != 0)
1322 panic("vop_lock: vp: locked %d, expected %d", islocked_vp, 0);
1323 #endif
1324 a.a_flags = flags;
1325 return (VCALL(vp, VOFFSET(vop_lock), &a));
1326 }
1327 #endif
1328
1329 const int vop_unlock_vp_offsets[] = {
1330 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp),
1331 VDESC_NO_OFFSET
1332 };
1333 const struct vnodeop_desc vop_unlock_desc = {
1334 32,
1335 "vop_unlock",
1336 0,
1337 vop_unlock_vp_offsets,
1338 VDESC_NO_OFFSET,
1339 VDESC_NO_OFFSET,
1340 VDESC_NO_OFFSET,
1341 VDESC_NO_OFFSET,
1342 NULL,
1343 };
1344 #ifdef VNODE_OP_NOINLINE
1345 int
1346 VOP_UNLOCK(vp, flags)
1347 struct vnode *vp;
1348 int flags;
1349 {
1350 struct vop_unlock_args a;
1351 #ifdef VNODE_LOCKDEBUG
1352 int islocked_vp;
1353 #endif
1354 a.a_desc = VDESC(vop_unlock);
1355 a.a_vp = vp;
1356 #ifdef VNODE_LOCKDEBUG
1357 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1358 if (islocked_vp != 1)
1359 panic("vop_unlock: vp: locked %d, expected %d", islocked_vp, 1);
1360 #endif
1361 a.a_flags = flags;
1362 return (VCALL(vp, VOFFSET(vop_unlock), &a));
1363 }
1364 #endif
1365
1366 const int vop_bmap_vp_offsets[] = {
1367 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp),
1368 VDESC_NO_OFFSET
1369 };
1370 const struct vnodeop_desc vop_bmap_desc = {
1371 33,
1372 "vop_bmap",
1373 0,
1374 vop_bmap_vp_offsets,
1375 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp),
1376 VDESC_NO_OFFSET,
1377 VDESC_NO_OFFSET,
1378 VDESC_NO_OFFSET,
1379 NULL,
1380 };
1381 #ifdef VNODE_OP_NOINLINE
1382 int
1383 VOP_BMAP(vp, bn, vpp, bnp, runp)
1384 struct vnode *vp;
1385 daddr_t bn;
1386 struct vnode **vpp;
1387 daddr_t *bnp;
1388 int *runp;
1389 {
1390 struct vop_bmap_args a;
1391 #ifdef VNODE_LOCKDEBUG
1392 int islocked_vp;
1393 #endif
1394 a.a_desc = VDESC(vop_bmap);
1395 a.a_vp = vp;
1396 #ifdef VNODE_LOCKDEBUG
1397 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1398 if (islocked_vp != 1)
1399 panic("vop_bmap: vp: locked %d, expected %d", islocked_vp, 1);
1400 #endif
1401 a.a_bn = bn;
1402 a.a_vpp = vpp;
1403 a.a_bnp = bnp;
1404 a.a_runp = runp;
1405 return (VCALL(vp, VOFFSET(vop_bmap), &a));
1406 }
1407 #endif
1408
1409 const int vop_strategy_vp_offsets[] = {
1410 VOPARG_OFFSETOF(struct vop_strategy_args,a_vp),
1411 VDESC_NO_OFFSET
1412 };
1413 const struct vnodeop_desc vop_strategy_desc = {
1414 34,
1415 "vop_strategy",
1416 0,
1417 vop_strategy_vp_offsets,
1418 VDESC_NO_OFFSET,
1419 VDESC_NO_OFFSET,
1420 VDESC_NO_OFFSET,
1421 VDESC_NO_OFFSET,
1422 NULL,
1423 };
1424 #ifdef VNODE_OP_NOINLINE
1425 int
1426 VOP_STRATEGY(vp, bp)
1427 struct vnode *vp;
1428 struct buf *bp;
1429 {
1430 struct vop_strategy_args a;
1431 #ifdef VNODE_LOCKDEBUG
1432 #endif
1433 a.a_desc = VDESC(vop_strategy);
1434 a.a_vp = vp;
1435 a.a_bp = bp;
1436 return (VCALL(vp, VOFFSET(vop_strategy), &a));
1437 }
1438 #endif
1439
1440 const int vop_print_vp_offsets[] = {
1441 VOPARG_OFFSETOF(struct vop_print_args,a_vp),
1442 VDESC_NO_OFFSET
1443 };
1444 const struct vnodeop_desc vop_print_desc = {
1445 35,
1446 "vop_print",
1447 0,
1448 vop_print_vp_offsets,
1449 VDESC_NO_OFFSET,
1450 VDESC_NO_OFFSET,
1451 VDESC_NO_OFFSET,
1452 VDESC_NO_OFFSET,
1453 NULL,
1454 };
1455 #ifdef VNODE_OP_NOINLINE
1456 int
1457 VOP_PRINT(vp)
1458 struct vnode *vp;
1459 {
1460 struct vop_print_args a;
1461 #ifdef VNODE_LOCKDEBUG
1462 #endif
1463 a.a_desc = VDESC(vop_print);
1464 a.a_vp = vp;
1465 return (VCALL(vp, VOFFSET(vop_print), &a));
1466 }
1467 #endif
1468
1469 const int vop_islocked_vp_offsets[] = {
1470 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp),
1471 VDESC_NO_OFFSET
1472 };
1473 const struct vnodeop_desc vop_islocked_desc = {
1474 36,
1475 "vop_islocked",
1476 0,
1477 vop_islocked_vp_offsets,
1478 VDESC_NO_OFFSET,
1479 VDESC_NO_OFFSET,
1480 VDESC_NO_OFFSET,
1481 VDESC_NO_OFFSET,
1482 NULL,
1483 };
1484 #ifdef VNODE_OP_NOINLINE
1485 int
1486 VOP_ISLOCKED(vp)
1487 struct vnode *vp;
1488 {
1489 struct vop_islocked_args a;
1490 #ifdef VNODE_LOCKDEBUG
1491 #endif
1492 a.a_desc = VDESC(vop_islocked);
1493 a.a_vp = vp;
1494 return (VCALL(vp, VOFFSET(vop_islocked), &a));
1495 }
1496 #endif
1497
1498 const int vop_pathconf_vp_offsets[] = {
1499 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp),
1500 VDESC_NO_OFFSET
1501 };
1502 const struct vnodeop_desc vop_pathconf_desc = {
1503 37,
1504 "vop_pathconf",
1505 0,
1506 vop_pathconf_vp_offsets,
1507 VDESC_NO_OFFSET,
1508 VDESC_NO_OFFSET,
1509 VDESC_NO_OFFSET,
1510 VDESC_NO_OFFSET,
1511 NULL,
1512 };
1513 #ifdef VNODE_OP_NOINLINE
1514 int
1515 VOP_PATHCONF(vp, name, retval)
1516 struct vnode *vp;
1517 int name;
1518 register_t *retval;
1519 {
1520 struct vop_pathconf_args a;
1521 #ifdef VNODE_LOCKDEBUG
1522 int islocked_vp;
1523 #endif
1524 a.a_desc = VDESC(vop_pathconf);
1525 a.a_vp = vp;
1526 #ifdef VNODE_LOCKDEBUG
1527 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1528 if (islocked_vp != 1)
1529 panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1);
1530 #endif
1531 a.a_name = name;
1532 a.a_retval = retval;
1533 return (VCALL(vp, VOFFSET(vop_pathconf), &a));
1534 }
1535 #endif
1536
1537 const int vop_advlock_vp_offsets[] = {
1538 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp),
1539 VDESC_NO_OFFSET
1540 };
1541 const struct vnodeop_desc vop_advlock_desc = {
1542 38,
1543 "vop_advlock",
1544 0,
1545 vop_advlock_vp_offsets,
1546 VDESC_NO_OFFSET,
1547 VDESC_NO_OFFSET,
1548 VDESC_NO_OFFSET,
1549 VDESC_NO_OFFSET,
1550 NULL,
1551 };
1552 #ifdef VNODE_OP_NOINLINE
1553 int
1554 VOP_ADVLOCK(vp, id, op, fl, flags)
1555 struct vnode *vp;
1556 void *id;
1557 int op;
1558 struct flock *fl;
1559 int flags;
1560 {
1561 struct vop_advlock_args a;
1562 #ifdef VNODE_LOCKDEBUG
1563 int islocked_vp;
1564 #endif
1565 a.a_desc = VDESC(vop_advlock);
1566 a.a_vp = vp;
1567 #ifdef VNODE_LOCKDEBUG
1568 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
1569 if (islocked_vp != 0)
1570 panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0);
1571 #endif
1572 a.a_id = id;
1573 a.a_op = op;
1574 a.a_fl = fl;
1575 a.a_flags = flags;
1576 return (VCALL(vp, VOFFSET(vop_advlock), &a));
1577 }
1578 #endif
1579
1580 const int vop_blkatoff_vp_offsets[] = {
1581 VOPARG_OFFSETOF(struct vop_blkatoff_args,a_vp),
1582 VDESC_NO_OFFSET
1583 };
1584 const struct vnodeop_desc vop_blkatoff_desc = {
1585 39,
1586 "vop_blkatoff",
1587 0,
1588 vop_blkatoff_vp_offsets,
1589 VDESC_NO_OFFSET,
1590 VDESC_NO_OFFSET,
1591 VDESC_NO_OFFSET,
1592 VDESC_NO_OFFSET,
1593 NULL,
1594 };
1595 #ifdef VNODE_OP_NOINLINE
1596 int
1597 VOP_BLKATOFF(vp, offset, res, bpp)
1598 struct vnode *vp;
1599 off_t offset;
1600 char **res;
1601 struct buf **bpp;
1602 {
1603 struct vop_blkatoff_args a;
1604 #ifdef VNODE_LOCKDEBUG
1605 int islocked_vp;
1606 #endif
1607 a.a_desc = VDESC(vop_blkatoff);
1608 a.a_vp = vp;
1609 #ifdef VNODE_LOCKDEBUG
1610 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1611 if (islocked_vp != 1)
1612 panic("vop_blkatoff: vp: locked %d, expected %d", islocked_vp, 1);
1613 #endif
1614 a.a_offset = offset;
1615 a.a_res = res;
1616 a.a_bpp = bpp;
1617 return (VCALL(vp, VOFFSET(vop_blkatoff), &a));
1618 }
1619 #endif
1620
1621 const int vop_valloc_vp_offsets[] = {
1622 VOPARG_OFFSETOF(struct vop_valloc_args,a_pvp),
1623 VDESC_NO_OFFSET
1624 };
1625 const struct vnodeop_desc vop_valloc_desc = {
1626 40,
1627 "vop_valloc",
1628 0,
1629 vop_valloc_vp_offsets,
1630 VOPARG_OFFSETOF(struct vop_valloc_args, a_vpp),
1631 VOPARG_OFFSETOF(struct vop_valloc_args, a_cred),
1632 VDESC_NO_OFFSET,
1633 VDESC_NO_OFFSET,
1634 NULL,
1635 };
1636 #ifdef VNODE_OP_NOINLINE
1637 int
1638 VOP_VALLOC(pvp, mode, cred, vpp)
1639 struct vnode *pvp;
1640 int mode;
1641 struct ucred *cred;
1642 struct vnode **vpp;
1643 {
1644 struct vop_valloc_args a;
1645 #ifdef VNODE_LOCKDEBUG
1646 int islocked_pvp;
1647 #endif
1648 a.a_desc = VDESC(vop_valloc);
1649 a.a_pvp = pvp;
1650 #ifdef VNODE_LOCKDEBUG
1651 islocked_pvp = (pvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(pvp) == LK_EXCLUSIVE) : 1;
1652 if (islocked_pvp != 1)
1653 panic("vop_valloc: pvp: locked %d, expected %d", islocked_pvp, 1);
1654 #endif
1655 a.a_mode = mode;
1656 a.a_cred = cred;
1657 a.a_vpp = vpp;
1658 return (VCALL(pvp, VOFFSET(vop_valloc), &a));
1659 }
1660 #endif
1661
1662 const int vop_balloc_vp_offsets[] = {
1663 VOPARG_OFFSETOF(struct vop_balloc_args,a_vp),
1664 VDESC_NO_OFFSET
1665 };
1666 const struct vnodeop_desc vop_balloc_desc = {
1667 41,
1668 "vop_balloc",
1669 0,
1670 vop_balloc_vp_offsets,
1671 VDESC_NO_OFFSET,
1672 VOPARG_OFFSETOF(struct vop_balloc_args, a_cred),
1673 VDESC_NO_OFFSET,
1674 VDESC_NO_OFFSET,
1675 NULL,
1676 };
1677 #ifdef VNODE_OP_NOINLINE
1678 int
1679 VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
1680 struct vnode *vp;
1681 off_t startoffset;
1682 int size;
1683 struct ucred *cred;
1684 int flags;
1685 struct buf **bpp;
1686 {
1687 struct vop_balloc_args a;
1688 #ifdef VNODE_LOCKDEBUG
1689 int islocked_vp;
1690 #endif
1691 a.a_desc = VDESC(vop_balloc);
1692 a.a_vp = vp;
1693 #ifdef VNODE_LOCKDEBUG
1694 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1695 if (islocked_vp != 1)
1696 panic("vop_balloc: vp: locked %d, expected %d", islocked_vp, 1);
1697 #endif
1698 a.a_startoffset = startoffset;
1699 a.a_size = size;
1700 a.a_cred = cred;
1701 a.a_flags = flags;
1702 a.a_bpp = bpp;
1703 return (VCALL(vp, VOFFSET(vop_balloc), &a));
1704 }
1705 #endif
1706
1707 const int vop_reallocblks_vp_offsets[] = {
1708 VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp),
1709 VDESC_NO_OFFSET
1710 };
1711 const struct vnodeop_desc vop_reallocblks_desc = {
1712 42,
1713 "vop_reallocblks",
1714 0,
1715 vop_reallocblks_vp_offsets,
1716 VDESC_NO_OFFSET,
1717 VDESC_NO_OFFSET,
1718 VDESC_NO_OFFSET,
1719 VDESC_NO_OFFSET,
1720 NULL,
1721 };
1722 #ifdef VNODE_OP_NOINLINE
1723 int
1724 VOP_REALLOCBLKS(vp, buflist)
1725 struct vnode *vp;
1726 struct cluster_save *buflist;
1727 {
1728 struct vop_reallocblks_args a;
1729 #ifdef VNODE_LOCKDEBUG
1730 int islocked_vp;
1731 #endif
1732 a.a_desc = VDESC(vop_reallocblks);
1733 a.a_vp = vp;
1734 #ifdef VNODE_LOCKDEBUG
1735 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1736 if (islocked_vp != 1)
1737 panic("vop_reallocblks: vp: locked %d, expected %d", islocked_vp, 1);
1738 #endif
1739 a.a_buflist = buflist;
1740 return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
1741 }
1742 #endif
1743
1744 const int vop_vfree_vp_offsets[] = {
1745 VOPARG_OFFSETOF(struct vop_vfree_args,a_pvp),
1746 VDESC_NO_OFFSET
1747 };
1748 const struct vnodeop_desc vop_vfree_desc = {
1749 43,
1750 "vop_vfree",
1751 0,
1752 vop_vfree_vp_offsets,
1753 VDESC_NO_OFFSET,
1754 VDESC_NO_OFFSET,
1755 VDESC_NO_OFFSET,
1756 VDESC_NO_OFFSET,
1757 NULL,
1758 };
1759 #ifdef VNODE_OP_NOINLINE
1760 int
1761 VOP_VFREE(pvp, ino, mode)
1762 struct vnode *pvp;
1763 ino_t ino;
1764 int mode;
1765 {
1766 struct vop_vfree_args a;
1767 #ifdef VNODE_LOCKDEBUG
1768 int islocked_pvp;
1769 #endif
1770 a.a_desc = VDESC(vop_vfree);
1771 a.a_pvp = pvp;
1772 #ifdef VNODE_LOCKDEBUG
1773 islocked_pvp = (pvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(pvp) == LK_EXCLUSIVE) : 1;
1774 if (islocked_pvp != 1)
1775 panic("vop_vfree: pvp: locked %d, expected %d", islocked_pvp, 1);
1776 #endif
1777 a.a_ino = ino;
1778 a.a_mode = mode;
1779 return (VCALL(pvp, VOFFSET(vop_vfree), &a));
1780 }
1781 #endif
1782
1783 const int vop_truncate_vp_offsets[] = {
1784 VOPARG_OFFSETOF(struct vop_truncate_args,a_vp),
1785 VDESC_NO_OFFSET
1786 };
1787 const struct vnodeop_desc vop_truncate_desc = {
1788 44,
1789 "vop_truncate",
1790 0,
1791 vop_truncate_vp_offsets,
1792 VDESC_NO_OFFSET,
1793 VOPARG_OFFSETOF(struct vop_truncate_args, a_cred),
1794 VOPARG_OFFSETOF(struct vop_truncate_args, a_p),
1795 VDESC_NO_OFFSET,
1796 NULL,
1797 };
1798 #ifdef VNODE_OP_NOINLINE
1799 int
1800 VOP_TRUNCATE(vp, length, flags, cred, p)
1801 struct vnode *vp;
1802 off_t length;
1803 int flags;
1804 struct ucred *cred;
1805 struct proc *p;
1806 {
1807 struct vop_truncate_args a;
1808 #ifdef VNODE_LOCKDEBUG
1809 int islocked_vp;
1810 #endif
1811 a.a_desc = VDESC(vop_truncate);
1812 a.a_vp = vp;
1813 #ifdef VNODE_LOCKDEBUG
1814 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1815 if (islocked_vp != 1)
1816 panic("vop_truncate: vp: locked %d, expected %d", islocked_vp, 1);
1817 #endif
1818 a.a_length = length;
1819 a.a_flags = flags;
1820 a.a_cred = cred;
1821 a.a_p = p;
1822 return (VCALL(vp, VOFFSET(vop_truncate), &a));
1823 }
1824 #endif
1825
1826 const int vop_update_vp_offsets[] = {
1827 VOPARG_OFFSETOF(struct vop_update_args,a_vp),
1828 VDESC_NO_OFFSET
1829 };
1830 const struct vnodeop_desc vop_update_desc = {
1831 45,
1832 "vop_update",
1833 0,
1834 vop_update_vp_offsets,
1835 VDESC_NO_OFFSET,
1836 VDESC_NO_OFFSET,
1837 VDESC_NO_OFFSET,
1838 VDESC_NO_OFFSET,
1839 NULL,
1840 };
1841 #ifdef VNODE_OP_NOINLINE
1842 int
1843 VOP_UPDATE(vp, access, modify, flags)
1844 struct vnode *vp;
1845 struct timespec *access;
1846 struct timespec *modify;
1847 int flags;
1848 {
1849 struct vop_update_args a;
1850 #ifdef VNODE_LOCKDEBUG
1851 int islocked_vp;
1852 #endif
1853 a.a_desc = VDESC(vop_update);
1854 a.a_vp = vp;
1855 #ifdef VNODE_LOCKDEBUG
1856 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
1857 if (islocked_vp != 1)
1858 panic("vop_update: vp: locked %d, expected %d", islocked_vp, 1);
1859 #endif
1860 a.a_access = access;
1861 a.a_modify = modify;
1862 a.a_flags = flags;
1863 return (VCALL(vp, VOFFSET(vop_update), &a));
1864 }
1865 #endif
1866
1867 const int vop_lease_vp_offsets[] = {
1868 VOPARG_OFFSETOF(struct vop_lease_args,a_vp),
1869 VDESC_NO_OFFSET
1870 };
1871 const struct vnodeop_desc vop_lease_desc = {
1872 46,
1873 "vop_lease",
1874 0,
1875 vop_lease_vp_offsets,
1876 VDESC_NO_OFFSET,
1877 VOPARG_OFFSETOF(struct vop_lease_args, a_cred),
1878 VOPARG_OFFSETOF(struct vop_lease_args, a_p),
1879 VDESC_NO_OFFSET,
1880 NULL,
1881 };
1882 #ifdef VNODE_OP_NOINLINE
1883 int
1884 VOP_LEASE(vp, p, cred, flag)
1885 struct vnode *vp;
1886 struct proc *p;
1887 struct ucred *cred;
1888 int flag;
1889 {
1890 struct vop_lease_args a;
1891 #ifdef VNODE_LOCKDEBUG
1892 #endif
1893 a.a_desc = VDESC(vop_lease);
1894 a.a_vp = vp;
1895 a.a_p = p;
1896 a.a_cred = cred;
1897 a.a_flag = flag;
1898 return (VCALL(vp, VOFFSET(vop_lease), &a));
1899 }
1900 #endif
1901
1902 const int vop_whiteout_vp_offsets[] = {
1903 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp),
1904 VDESC_NO_OFFSET
1905 };
1906 const struct vnodeop_desc vop_whiteout_desc = {
1907 47,
1908 "vop_whiteout",
1909 0,
1910 vop_whiteout_vp_offsets,
1911 VDESC_NO_OFFSET,
1912 VDESC_NO_OFFSET,
1913 VDESC_NO_OFFSET,
1914 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp),
1915 NULL,
1916 };
1917 #ifdef VNODE_OP_NOINLINE
1918 int
1919 VOP_WHITEOUT(dvp, cnp, flags)
1920 struct vnode *dvp;
1921 struct componentname *cnp;
1922 int flags;
1923 {
1924 struct vop_whiteout_args a;
1925 #ifdef VNODE_LOCKDEBUG
1926 int islocked_dvp;
1927 #endif
1928 a.a_desc = VDESC(vop_whiteout);
1929 a.a_dvp = dvp;
1930 #ifdef VNODE_LOCKDEBUG
1931 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
1932 if (islocked_dvp != 1)
1933 panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1);
1934 #endif
1935 a.a_cnp = cnp;
1936 a.a_flags = flags;
1937 return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
1938 }
1939 #endif
1940
1941 const int vop_getpages_vp_offsets[] = {
1942 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp),
1943 VDESC_NO_OFFSET
1944 };
1945 const struct vnodeop_desc vop_getpages_desc = {
1946 48,
1947 "vop_getpages",
1948 0,
1949 vop_getpages_vp_offsets,
1950 VDESC_NO_OFFSET,
1951 VDESC_NO_OFFSET,
1952 VDESC_NO_OFFSET,
1953 VDESC_NO_OFFSET,
1954 NULL,
1955 };
1956 #ifdef VNODE_OP_NOINLINE
1957 int
1958 VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags)
1959 struct vnode *vp;
1960 voff_t offset;
1961 struct vm_page **m;
1962 int *count;
1963 int centeridx;
1964 vm_prot_t access_type;
1965 int advice;
1966 int flags;
1967 {
1968 struct vop_getpages_args a;
1969 #ifdef VNODE_LOCKDEBUG
1970 #endif
1971 a.a_desc = VDESC(vop_getpages);
1972 a.a_vp = vp;
1973 a.a_offset = offset;
1974 a.a_m = m;
1975 a.a_count = count;
1976 a.a_centeridx = centeridx;
1977 a.a_access_type = access_type;
1978 a.a_advice = advice;
1979 a.a_flags = flags;
1980 return (VCALL(vp, VOFFSET(vop_getpages), &a));
1981 }
1982 #endif
1983
1984 const int vop_putpages_vp_offsets[] = {
1985 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp),
1986 VDESC_NO_OFFSET
1987 };
1988 const struct vnodeop_desc vop_putpages_desc = {
1989 49,
1990 "vop_putpages",
1991 0,
1992 vop_putpages_vp_offsets,
1993 VDESC_NO_OFFSET,
1994 VDESC_NO_OFFSET,
1995 VDESC_NO_OFFSET,
1996 VDESC_NO_OFFSET,
1997 NULL,
1998 };
1999 #ifdef VNODE_OP_NOINLINE
2000 int
2001 VOP_PUTPAGES(vp, offlo, offhi, flags)
2002 struct vnode *vp;
2003 voff_t offlo;
2004 voff_t offhi;
2005 int flags;
2006 {
2007 struct vop_putpages_args a;
2008 #ifdef VNODE_LOCKDEBUG
2009 #endif
2010 a.a_desc = VDESC(vop_putpages);
2011 a.a_vp = vp;
2012 a.a_offlo = offlo;
2013 a.a_offhi = offhi;
2014 a.a_flags = flags;
2015 return (VCALL(vp, VOFFSET(vop_putpages), &a));
2016 }
2017 #endif
2018
2019 const int vop_closeextattr_vp_offsets[] = {
2020 VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp),
2021 VDESC_NO_OFFSET
2022 };
2023 const struct vnodeop_desc vop_closeextattr_desc = {
2024 50,
2025 "vop_closeextattr",
2026 0,
2027 vop_closeextattr_vp_offsets,
2028 VDESC_NO_OFFSET,
2029 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred),
2030 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_p),
2031 VDESC_NO_OFFSET,
2032 NULL,
2033 };
2034 #ifdef VNODE_OP_NOINLINE
2035 int
2036 VOP_CLOSEEXTATTR(vp, commit, cred, p)
2037 struct vnode *vp;
2038 int commit;
2039 struct ucred *cred;
2040 struct proc *p;
2041 {
2042 struct vop_closeextattr_args a;
2043 #ifdef VNODE_LOCKDEBUG
2044 int islocked_vp;
2045 #endif
2046 a.a_desc = VDESC(vop_closeextattr);
2047 a.a_vp = vp;
2048 #ifdef VNODE_LOCKDEBUG
2049 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
2050 if (islocked_vp != 1)
2051 panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1);
2052 #endif
2053 a.a_commit = commit;
2054 a.a_cred = cred;
2055 a.a_p = p;
2056 return (VCALL(vp, VOFFSET(vop_closeextattr), &a));
2057 }
2058 #endif
2059
2060 const int vop_getextattr_vp_offsets[] = {
2061 VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp),
2062 VDESC_NO_OFFSET
2063 };
2064 const struct vnodeop_desc vop_getextattr_desc = {
2065 51,
2066 "vop_getextattr",
2067 0,
2068 vop_getextattr_vp_offsets,
2069 VDESC_NO_OFFSET,
2070 VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred),
2071 VOPARG_OFFSETOF(struct vop_getextattr_args, a_p),
2072 VDESC_NO_OFFSET,
2073 NULL,
2074 };
2075 #ifdef VNODE_OP_NOINLINE
2076 int
2077 VOP_GETEXTATTR(vp, attrnamespace, name, uio, size, cred, p)
2078 struct vnode *vp;
2079 int attrnamespace;
2080 const char *name;
2081 struct uio *uio;
2082 size_t *size;
2083 struct ucred *cred;
2084 struct proc *p;
2085 {
2086 struct vop_getextattr_args a;
2087 #ifdef VNODE_LOCKDEBUG
2088 int islocked_vp;
2089 #endif
2090 a.a_desc = VDESC(vop_getextattr);
2091 a.a_vp = vp;
2092 #ifdef VNODE_LOCKDEBUG
2093 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
2094 if (islocked_vp != 1)
2095 panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1);
2096 #endif
2097 a.a_attrnamespace = attrnamespace;
2098 a.a_name = name;
2099 a.a_uio = uio;
2100 a.a_size = size;
2101 a.a_cred = cred;
2102 a.a_p = p;
2103 return (VCALL(vp, VOFFSET(vop_getextattr), &a));
2104 }
2105 #endif
2106
2107 const int vop_listextattr_vp_offsets[] = {
2108 VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp),
2109 VDESC_NO_OFFSET
2110 };
2111 const struct vnodeop_desc vop_listextattr_desc = {
2112 52,
2113 "vop_listextattr",
2114 0,
2115 vop_listextattr_vp_offsets,
2116 VDESC_NO_OFFSET,
2117 VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred),
2118 VOPARG_OFFSETOF(struct vop_listextattr_args, a_p),
2119 VDESC_NO_OFFSET,
2120 NULL,
2121 };
2122 #ifdef VNODE_OP_NOINLINE
2123 int
2124 VOP_LISTEXTATTR(vp, attrnamespace, uio, size, cred, p)
2125 struct vnode *vp;
2126 int attrnamespace;
2127 struct uio *uio;
2128 size_t *size;
2129 struct ucred *cred;
2130 struct proc *p;
2131 {
2132 struct vop_listextattr_args a;
2133 #ifdef VNODE_LOCKDEBUG
2134 int islocked_vp;
2135 #endif
2136 a.a_desc = VDESC(vop_listextattr);
2137 a.a_vp = vp;
2138 #ifdef VNODE_LOCKDEBUG
2139 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
2140 if (islocked_vp != 1)
2141 panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1);
2142 #endif
2143 a.a_attrnamespace = attrnamespace;
2144 a.a_uio = uio;
2145 a.a_size = size;
2146 a.a_cred = cred;
2147 a.a_p = p;
2148 return (VCALL(vp, VOFFSET(vop_listextattr), &a));
2149 }
2150 #endif
2151
2152 const int vop_openextattr_vp_offsets[] = {
2153 VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp),
2154 VDESC_NO_OFFSET
2155 };
2156 const struct vnodeop_desc vop_openextattr_desc = {
2157 53,
2158 "vop_openextattr",
2159 0,
2160 vop_openextattr_vp_offsets,
2161 VDESC_NO_OFFSET,
2162 VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred),
2163 VOPARG_OFFSETOF(struct vop_openextattr_args, a_p),
2164 VDESC_NO_OFFSET,
2165 NULL,
2166 };
2167 #ifdef VNODE_OP_NOINLINE
2168 int
2169 VOP_OPENEXTATTR(vp, cred, p)
2170 struct vnode *vp;
2171 struct ucred *cred;
2172 struct proc *p;
2173 {
2174 struct vop_openextattr_args a;
2175 #ifdef VNODE_LOCKDEBUG
2176 int islocked_vp;
2177 #endif
2178 a.a_desc = VDESC(vop_openextattr);
2179 a.a_vp = vp;
2180 #ifdef VNODE_LOCKDEBUG
2181 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
2182 if (islocked_vp != 1)
2183 panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1);
2184 #endif
2185 a.a_cred = cred;
2186 a.a_p = p;
2187 return (VCALL(vp, VOFFSET(vop_openextattr), &a));
2188 }
2189 #endif
2190
2191 const int vop_deleteextattr_vp_offsets[] = {
2192 VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp),
2193 VDESC_NO_OFFSET
2194 };
2195 const struct vnodeop_desc vop_deleteextattr_desc = {
2196 54,
2197 "vop_deleteextattr",
2198 0,
2199 vop_deleteextattr_vp_offsets,
2200 VDESC_NO_OFFSET,
2201 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred),
2202 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_p),
2203 VDESC_NO_OFFSET,
2204 NULL,
2205 };
2206 #ifdef VNODE_OP_NOINLINE
2207 int
2208 VOP_DELETEEXTATTR(vp, attrnamespace, name, cred, p)
2209 struct vnode *vp;
2210 int attrnamespace;
2211 const char *name;
2212 struct ucred *cred;
2213 struct proc *p;
2214 {
2215 struct vop_deleteextattr_args a;
2216 #ifdef VNODE_LOCKDEBUG
2217 int islocked_vp;
2218 #endif
2219 a.a_desc = VDESC(vop_deleteextattr);
2220 a.a_vp = vp;
2221 #ifdef VNODE_LOCKDEBUG
2222 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
2223 if (islocked_vp != 1)
2224 panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1);
2225 #endif
2226 a.a_attrnamespace = attrnamespace;
2227 a.a_name = name;
2228 a.a_cred = cred;
2229 a.a_p = p;
2230 return (VCALL(vp, VOFFSET(vop_deleteextattr), &a));
2231 }
2232 #endif
2233
2234 const int vop_setextattr_vp_offsets[] = {
2235 VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp),
2236 VDESC_NO_OFFSET
2237 };
2238 const struct vnodeop_desc vop_setextattr_desc = {
2239 55,
2240 "vop_setextattr",
2241 0,
2242 vop_setextattr_vp_offsets,
2243 VDESC_NO_OFFSET,
2244 VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred),
2245 VOPARG_OFFSETOF(struct vop_setextattr_args, a_p),
2246 VDESC_NO_OFFSET,
2247 NULL,
2248 };
2249 #ifdef VNODE_OP_NOINLINE
2250 int
2251 VOP_SETEXTATTR(vp, attrnamespace, name, uio, cred, p)
2252 struct vnode *vp;
2253 int attrnamespace;
2254 const char *name;
2255 struct uio *uio;
2256 struct ucred *cred;
2257 struct proc *p;
2258 {
2259 struct vop_setextattr_args a;
2260 #ifdef VNODE_LOCKDEBUG
2261 int islocked_vp;
2262 #endif
2263 a.a_desc = VDESC(vop_setextattr);
2264 a.a_vp = vp;
2265 #ifdef VNODE_LOCKDEBUG
2266 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
2267 if (islocked_vp != 1)
2268 panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1);
2269 #endif
2270 a.a_attrnamespace = attrnamespace;
2271 a.a_name = name;
2272 a.a_uio = uio;
2273 a.a_cred = cred;
2274 a.a_p = p;
2275 return (VCALL(vp, VOFFSET(vop_setextattr), &a));
2276 }
2277 #endif
2278
2279 /* End of special cases. */
2280
2281 const struct vnodeop_desc * const vfs_op_descs[] = {
2282 &vop_default_desc, /* MUST BE FIRST */
2283 &vop_bwrite_desc, /* XXX: SPECIAL CASE */
2284
2285 &vop_lookup_desc,
2286 &vop_create_desc,
2287 &vop_mknod_desc,
2288 &vop_open_desc,
2289 &vop_close_desc,
2290 &vop_access_desc,
2291 &vop_getattr_desc,
2292 &vop_setattr_desc,
2293 &vop_read_desc,
2294 &vop_write_desc,
2295 &vop_ioctl_desc,
2296 &vop_fcntl_desc,
2297 &vop_poll_desc,
2298 &vop_kqfilter_desc,
2299 &vop_revoke_desc,
2300 &vop_mmap_desc,
2301 &vop_fsync_desc,
2302 &vop_seek_desc,
2303 &vop_remove_desc,
2304 &vop_link_desc,
2305 &vop_rename_desc,
2306 &vop_mkdir_desc,
2307 &vop_rmdir_desc,
2308 &vop_symlink_desc,
2309 &vop_readdir_desc,
2310 &vop_readlink_desc,
2311 &vop_abortop_desc,
2312 &vop_inactive_desc,
2313 &vop_reclaim_desc,
2314 &vop_lock_desc,
2315 &vop_unlock_desc,
2316 &vop_bmap_desc,
2317 &vop_strategy_desc,
2318 &vop_print_desc,
2319 &vop_islocked_desc,
2320 &vop_pathconf_desc,
2321 &vop_advlock_desc,
2322 &vop_blkatoff_desc,
2323 &vop_valloc_desc,
2324 &vop_balloc_desc,
2325 &vop_reallocblks_desc,
2326 &vop_vfree_desc,
2327 &vop_truncate_desc,
2328 &vop_update_desc,
2329 &vop_lease_desc,
2330 &vop_whiteout_desc,
2331 &vop_getpages_desc,
2332 &vop_putpages_desc,
2333 &vop_closeextattr_desc,
2334 &vop_getextattr_desc,
2335 &vop_listextattr_desc,
2336 &vop_openextattr_desc,
2337 &vop_deleteextattr_desc,
2338 &vop_setextattr_desc,
2339 NULL
2340 };
2341
Cache object: 272809f8f30c7a35ecc0cf1a1eed881d
|