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