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