This source file includes following definitions.
- VOP_ISLOCKED
- VOP_LOOKUP
- VOP_CREATE
- VOP_MKNOD
- VOP_OPEN
- VOP_CLOSE
- VOP_ACCESS
- VOP_GETATTR
- VOP_SETATTR
- VOP_READ
- VOP_WRITE
- VOP_IOCTL
- VOP_POLL
- VOP_KQFILTER
- VOP_REVOKE
- VOP_FSYNC
- VOP_REMOVE
- VOP_LINK
- VOP_RENAME
- VOP_MKDIR
- VOP_RMDIR
- VOP_SYMLINK
- VOP_READDIR
- VOP_READLINK
- VOP_ABORTOP
- VOP_INACTIVE
- VOP_RECLAIM
- VOP_LOCK
- VOP_UNLOCK
- VOP_BMAP
- VOP_PRINT
- VOP_PATHCONF
- VOP_ADVLOCK
- VOP_REALLOCBLKS
- VOP_STRATEGY
- VOP_BWRITE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40 #include <sys/param.h>
41 #include <sys/mount.h>
42 #include <sys/vnode.h>
43
44 struct vnodeop_desc vop_default_desc = {
45 0,
46 "default",
47 0,
48 NULL,
49 VDESC_NO_OFFSET,
50 VDESC_NO_OFFSET,
51 VDESC_NO_OFFSET,
52 VDESC_NO_OFFSET,
53 NULL,
54 };
55
56
57 int vop_islocked_vp_offsets[] = {
58 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp),
59 VDESC_NO_OFFSET
60 };
61 struct vnodeop_desc vop_islocked_desc = {
62 0,
63 "vop_islocked",
64 0,
65 vop_islocked_vp_offsets,
66 VDESC_NO_OFFSET,
67 VDESC_NO_OFFSET,
68 VDESC_NO_OFFSET,
69 VDESC_NO_OFFSET,
70 NULL,
71 };
72
73 int VOP_ISLOCKED(struct vnode *vp)
74 {
75 struct vop_islocked_args a;
76 a.a_desc = VDESC(vop_islocked);
77 a.a_vp = vp;
78 return (VCALL(vp, VOFFSET(vop_islocked), &a));
79 }
80
81 int vop_lookup_vp_offsets[] = {
82 VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp),
83 VDESC_NO_OFFSET
84 };
85 struct vnodeop_desc vop_lookup_desc = {
86 0,
87 "vop_lookup",
88 0,
89 vop_lookup_vp_offsets,
90 VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp),
91 VDESC_NO_OFFSET,
92 VDESC_NO_OFFSET,
93 VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp),
94 NULL,
95 };
96
97 int VOP_LOOKUP(struct vnode *dvp, struct vnode **vpp,
98 struct componentname *cnp)
99 {
100 struct vop_lookup_args a;
101 a.a_desc = VDESC(vop_lookup);
102 a.a_dvp = dvp;
103 a.a_vpp = vpp;
104 a.a_cnp = cnp;
105 return (VCALL(dvp, VOFFSET(vop_lookup), &a));
106 }
107
108 int vop_create_vp_offsets[] = {
109 VOPARG_OFFSETOF(struct vop_create_args,a_dvp),
110 VDESC_NO_OFFSET
111 };
112 struct vnodeop_desc vop_create_desc = {
113 0,
114 "vop_create",
115 0 | VDESC_VP0_WILLPUT,
116 vop_create_vp_offsets,
117 VOPARG_OFFSETOF(struct vop_create_args, a_vpp),
118 VDESC_NO_OFFSET,
119 VDESC_NO_OFFSET,
120 VOPARG_OFFSETOF(struct vop_create_args, a_cnp),
121 NULL,
122 };
123
124 int VOP_CREATE(struct vnode *dvp, struct vnode **vpp,
125 struct componentname *cnp, struct vattr *vap)
126 {
127 struct vop_create_args a;
128 a.a_desc = VDESC(vop_create);
129 a.a_dvp = dvp;
130 #ifdef VFSDEBUG
131 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
132 panic("vop_create: dvp");
133 #endif
134 a.a_vpp = vpp;
135 a.a_cnp = cnp;
136 a.a_vap = vap;
137 return (VCALL(dvp, VOFFSET(vop_create), &a));
138 }
139
140 int vop_mknod_vp_offsets[] = {
141 VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp),
142 VDESC_NO_OFFSET
143 };
144 struct vnodeop_desc vop_mknod_desc = {
145 0,
146 "vop_mknod",
147 0 | VDESC_VP0_WILLPUT | VDESC_VPP_WILLRELE,
148 vop_mknod_vp_offsets,
149 VOPARG_OFFSETOF(struct vop_mknod_args, a_vpp),
150 VDESC_NO_OFFSET,
151 VDESC_NO_OFFSET,
152 VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp),
153 NULL,
154 };
155
156 int VOP_MKNOD(struct vnode *dvp, struct vnode **vpp,
157 struct componentname *cnp, struct vattr *vap)
158 {
159 struct vop_mknod_args a;
160 a.a_desc = VDESC(vop_mknod);
161 a.a_dvp = dvp;
162 #ifdef VFSDEBUG
163 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
164 panic("vop_mknod: dvp");
165 #endif
166 a.a_vpp = vpp;
167 a.a_cnp = cnp;
168 a.a_vap = vap;
169 return (VCALL(dvp, VOFFSET(vop_mknod), &a));
170 }
171
172 int vop_open_vp_offsets[] = {
173 VOPARG_OFFSETOF(struct vop_open_args,a_vp),
174 VDESC_NO_OFFSET
175 };
176 struct vnodeop_desc vop_open_desc = {
177 0,
178 "vop_open",
179 0,
180 vop_open_vp_offsets,
181 VDESC_NO_OFFSET,
182 VOPARG_OFFSETOF(struct vop_open_args, a_cred),
183 VOPARG_OFFSETOF(struct vop_open_args, a_p),
184 VDESC_NO_OFFSET,
185 NULL,
186 };
187
188 int VOP_OPEN(struct vnode *vp, int mode, struct ucred *cred, struct proc *p)
189 {
190 struct vop_open_args a;
191 a.a_desc = VDESC(vop_open);
192 a.a_vp = vp;
193 a.a_mode = mode;
194 a.a_cred = cred;
195 a.a_p = p;
196 return (VCALL(vp, VOFFSET(vop_open), &a));
197 }
198
199 int vop_close_vp_offsets[] = {
200 VOPARG_OFFSETOF(struct vop_close_args,a_vp),
201 VDESC_NO_OFFSET
202 };
203 struct vnodeop_desc vop_close_desc = {
204 0,
205 "vop_close",
206 0,
207 vop_close_vp_offsets,
208 VDESC_NO_OFFSET,
209 VOPARG_OFFSETOF(struct vop_close_args, a_cred),
210 VOPARG_OFFSETOF(struct vop_close_args, a_p),
211 VDESC_NO_OFFSET,
212 NULL,
213 };
214
215 int VOP_CLOSE(struct vnode *vp, int fflag, struct ucred *cred, struct proc *p)
216 {
217 struct vop_close_args a;
218 a.a_desc = VDESC(vop_close);
219 a.a_vp = vp;
220 #ifdef VFSDEBUG
221 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
222 panic("vop_close: vp");
223 #endif
224 a.a_fflag = fflag;
225 a.a_cred = cred;
226 a.a_p = p;
227 return (VCALL(vp, VOFFSET(vop_close), &a));
228 }
229
230 int vop_access_vp_offsets[] = {
231 VOPARG_OFFSETOF(struct vop_access_args,a_vp),
232 VDESC_NO_OFFSET
233 };
234 struct vnodeop_desc vop_access_desc = {
235 0,
236 "vop_access",
237 0,
238 vop_access_vp_offsets,
239 VDESC_NO_OFFSET,
240 VOPARG_OFFSETOF(struct vop_access_args, a_cred),
241 VOPARG_OFFSETOF(struct vop_access_args, a_p),
242 VDESC_NO_OFFSET,
243 NULL,
244 };
245
246 int VOP_ACCESS(struct vnode *vp, int mode, struct ucred *cred, struct proc *p)
247 {
248 struct vop_access_args a;
249 a.a_desc = VDESC(vop_access);
250 a.a_vp = vp;
251 #ifdef VFSDEBUG
252 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
253 panic("vop_access: vp");
254 #endif
255 a.a_mode = mode;
256 a.a_cred = cred;
257 a.a_p = p;
258 return (VCALL(vp, VOFFSET(vop_access), &a));
259 }
260
261 int vop_getattr_vp_offsets[] = {
262 VOPARG_OFFSETOF(struct vop_getattr_args,a_vp),
263 VDESC_NO_OFFSET
264 };
265 struct vnodeop_desc vop_getattr_desc = {
266 0,
267 "vop_getattr",
268 0,
269 vop_getattr_vp_offsets,
270 VDESC_NO_OFFSET,
271 VOPARG_OFFSETOF(struct vop_getattr_args, a_cred),
272 VOPARG_OFFSETOF(struct vop_getattr_args, a_p),
273 VDESC_NO_OFFSET,
274 NULL,
275 };
276
277 int VOP_GETATTR(struct vnode *vp, struct vattr *vap, struct ucred *cred,
278 struct proc *p)
279 {
280 struct vop_getattr_args a;
281 a.a_desc = VDESC(vop_getattr);
282 a.a_vp = vp;
283 a.a_vap = vap;
284 a.a_cred = cred;
285 a.a_p = p;
286 return (VCALL(vp, VOFFSET(vop_getattr), &a));
287 }
288
289 int vop_setattr_vp_offsets[] = {
290 VOPARG_OFFSETOF(struct vop_setattr_args,a_vp),
291 VDESC_NO_OFFSET
292 };
293 struct vnodeop_desc vop_setattr_desc = {
294 0,
295 "vop_setattr",
296 0,
297 vop_setattr_vp_offsets,
298 VDESC_NO_OFFSET,
299 VOPARG_OFFSETOF(struct vop_setattr_args, a_cred),
300 VOPARG_OFFSETOF(struct vop_setattr_args, a_p),
301 VDESC_NO_OFFSET,
302 NULL,
303 };
304
305 int VOP_SETATTR(struct vnode *vp, struct vattr *vap, struct ucred *cred,
306 struct proc *p)
307 {
308 struct vop_setattr_args a;
309 a.a_desc = VDESC(vop_setattr);
310 a.a_vp = vp;
311 #ifdef VFSDEBUG
312 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
313 panic("vop_setattr: vp");
314 #endif
315 a.a_vap = vap;
316 a.a_cred = cred;
317 a.a_p = p;
318 return (VCALL(vp, VOFFSET(vop_setattr), &a));
319 }
320
321 int vop_read_vp_offsets[] = {
322 VOPARG_OFFSETOF(struct vop_read_args,a_vp),
323 VDESC_NO_OFFSET
324 };
325 struct vnodeop_desc vop_read_desc = {
326 0,
327 "vop_read",
328 0,
329 vop_read_vp_offsets,
330 VDESC_NO_OFFSET,
331 VOPARG_OFFSETOF(struct vop_read_args, a_cred),
332 VDESC_NO_OFFSET,
333 VDESC_NO_OFFSET,
334 NULL,
335 };
336
337 int VOP_READ(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *cred)
338 {
339 struct vop_read_args a;
340 a.a_desc = VDESC(vop_read);
341 a.a_vp = vp;
342 #ifdef VFSDEBUG
343 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
344 panic("vop_read: vp");
345 #endif
346 a.a_uio = uio;
347 a.a_ioflag = ioflag;
348 a.a_cred = cred;
349 return (VCALL(vp, VOFFSET(vop_read), &a));
350 }
351
352 int vop_write_vp_offsets[] = {
353 VOPARG_OFFSETOF(struct vop_write_args,a_vp),
354 VDESC_NO_OFFSET
355 };
356 struct vnodeop_desc vop_write_desc = {
357 0,
358 "vop_write",
359 0,
360 vop_write_vp_offsets,
361 VDESC_NO_OFFSET,
362 VOPARG_OFFSETOF(struct vop_write_args, a_cred),
363 VDESC_NO_OFFSET,
364 VDESC_NO_OFFSET,
365 NULL,
366 };
367
368 int VOP_WRITE(struct vnode *vp, struct uio *uio, int ioflag,
369 struct ucred *cred)
370 {
371 struct vop_write_args a;
372 a.a_desc = VDESC(vop_write);
373 a.a_vp = vp;
374 #ifdef VFSDEBUG
375 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
376 panic("vop_write: vp");
377 #endif
378 a.a_uio = uio;
379 a.a_ioflag = ioflag;
380 a.a_cred = cred;
381 return (VCALL(vp, VOFFSET(vop_write), &a));
382 }
383
384 int vop_ioctl_vp_offsets[] = {
385 VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp),
386 VDESC_NO_OFFSET
387 };
388 struct vnodeop_desc vop_ioctl_desc = {
389 0,
390 "vop_ioctl",
391 0,
392 vop_ioctl_vp_offsets,
393 VDESC_NO_OFFSET,
394 VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred),
395 VOPARG_OFFSETOF(struct vop_ioctl_args, a_p),
396 VDESC_NO_OFFSET,
397 NULL,
398 };
399
400 int VOP_IOCTL(struct vnode *vp, u_long command, void *data, int fflag,
401 struct ucred *cred, struct proc *p)
402 {
403 struct vop_ioctl_args a;
404 a.a_desc = VDESC(vop_ioctl);
405 a.a_vp = vp;
406 a.a_command = command;
407 a.a_data = data;
408 a.a_fflag = fflag;
409 a.a_cred = cred;
410 a.a_p = p;
411 return (VCALL(vp, VOFFSET(vop_ioctl), &a));
412 }
413
414 int vop_poll_vp_offsets[] = {
415 VOPARG_OFFSETOF(struct vop_poll_args,a_vp),
416 VDESC_NO_OFFSET
417 };
418 struct vnodeop_desc vop_poll_desc = {
419 0,
420 "vop_poll",
421 0,
422 vop_poll_vp_offsets,
423 VDESC_NO_OFFSET,
424 VDESC_NO_OFFSET,
425 VOPARG_OFFSETOF(struct vop_poll_args, a_p),
426 VDESC_NO_OFFSET,
427 NULL,
428 };
429
430 int VOP_POLL(struct vnode *vp, int events, struct proc *p)
431 {
432 struct vop_poll_args a;
433 a.a_desc = VDESC(vop_poll);
434 a.a_vp = vp;
435 a.a_events = events;
436 a.a_p = p;
437 return (VCALL(vp, VOFFSET(vop_poll), &a));
438 }
439
440 int vop_kqfilter_vp_offsets[] = {
441 VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp),
442 VDESC_NO_OFFSET
443 };
444 struct vnodeop_desc vop_kqfilter_desc = {
445 0,
446 "vop_kqfilter",
447 0,
448 vop_kqfilter_vp_offsets,
449 VDESC_NO_OFFSET,
450 VDESC_NO_OFFSET,
451 VDESC_NO_OFFSET,
452 VDESC_NO_OFFSET,
453 NULL,
454 };
455
456 int VOP_KQFILTER(struct vnode *vp, struct knote *kn)
457 {
458 struct vop_kqfilter_args a;
459 a.a_desc = VDESC(vop_kqfilter);
460 a.a_vp = vp;
461 a.a_kn = kn;
462 return (VCALL(vp, VOFFSET(vop_kqfilter), &a));
463 }
464
465 int vop_revoke_vp_offsets[] = {
466 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp),
467 VDESC_NO_OFFSET
468 };
469 struct vnodeop_desc vop_revoke_desc = {
470 0,
471 "vop_revoke",
472 0,
473 vop_revoke_vp_offsets,
474 VDESC_NO_OFFSET,
475 VDESC_NO_OFFSET,
476 VDESC_NO_OFFSET,
477 VDESC_NO_OFFSET,
478 NULL,
479 };
480
481 int VOP_REVOKE(struct vnode *vp, int flags)
482 {
483 struct vop_revoke_args a;
484 a.a_desc = VDESC(vop_revoke);
485 a.a_vp = vp;
486 a.a_flags = flags;
487 return (VCALL(vp, VOFFSET(vop_revoke), &a));
488 }
489
490 int vop_fsync_vp_offsets[] = {
491 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp),
492 VDESC_NO_OFFSET
493 };
494 struct vnodeop_desc vop_fsync_desc = {
495 0,
496 "vop_fsync",
497 0,
498 vop_fsync_vp_offsets,
499 VDESC_NO_OFFSET,
500 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred),
501 VOPARG_OFFSETOF(struct vop_fsync_args, a_p),
502 VDESC_NO_OFFSET,
503 NULL,
504 };
505
506 int VOP_FSYNC(struct vnode *vp, struct ucred *cred, int waitfor,
507 struct proc *p)
508 {
509 struct vop_fsync_args a;
510 a.a_desc = VDESC(vop_fsync);
511 a.a_vp = vp;
512 #ifdef VFSDEBUG
513 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
514 panic("vop_fsync: vp");
515 #endif
516 a.a_cred = cred;
517 a.a_waitfor = waitfor;
518 a.a_p = p;
519 return (VCALL(vp, VOFFSET(vop_fsync), &a));
520 }
521
522 int vop_remove_vp_offsets[] = {
523 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp),
524 VOPARG_OFFSETOF(struct vop_remove_args,a_vp),
525 VDESC_NO_OFFSET
526 };
527 struct vnodeop_desc vop_remove_desc = {
528 0,
529 "vop_remove",
530 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
531 vop_remove_vp_offsets,
532 VDESC_NO_OFFSET,
533 VDESC_NO_OFFSET,
534 VDESC_NO_OFFSET,
535 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp),
536 NULL,
537 };
538
539 int VOP_REMOVE(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
540 {
541 struct vop_remove_args a;
542 a.a_desc = VDESC(vop_remove);
543 a.a_dvp = dvp;
544 #ifdef VFSDEBUG
545 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
546 panic("vop_remove: dvp");
547 #endif
548 a.a_vp = vp;
549 #ifdef VFSDEBUG
550 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
551 panic("vop_remove: vp");
552 #endif
553 a.a_cnp = cnp;
554 return (VCALL(dvp, VOFFSET(vop_remove), &a));
555 }
556
557 int vop_link_vp_offsets[] = {
558 VOPARG_OFFSETOF(struct vop_link_args,a_dvp),
559 VOPARG_OFFSETOF(struct vop_link_args,a_vp),
560 VDESC_NO_OFFSET
561 };
562 struct vnodeop_desc vop_link_desc = {
563 0,
564 "vop_link",
565 0 | VDESC_VP0_WILLPUT,
566 vop_link_vp_offsets,
567 VDESC_NO_OFFSET,
568 VDESC_NO_OFFSET,
569 VDESC_NO_OFFSET,
570 VOPARG_OFFSETOF(struct vop_link_args, a_cnp),
571 NULL,
572 };
573
574 int VOP_LINK(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
575 {
576 struct vop_link_args a;
577 a.a_desc = VDESC(vop_link);
578 a.a_dvp = dvp;
579 #ifdef VFSDEBUG
580 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
581 panic("vop_link: dvp");
582 #endif
583 a.a_vp = vp;
584 a.a_cnp = cnp;
585 return (VCALL(dvp, VOFFSET(vop_link), &a));
586 }
587
588 int vop_rename_vp_offsets[] = {
589 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp),
590 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp),
591 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp),
592 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp),
593 VDESC_NO_OFFSET
594 };
595 struct vnodeop_desc vop_rename_desc = {
596 0,
597 "vop_rename",
598 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLRELE,
599 vop_rename_vp_offsets,
600 VDESC_NO_OFFSET,
601 VDESC_NO_OFFSET,
602 VDESC_NO_OFFSET,
603 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp),
604 NULL,
605 };
606
607 int VOP_RENAME(struct vnode *fdvp, struct vnode *fvp,
608 struct componentname *fcnp, struct vnode *tdvp, struct vnode *tvp,
609 struct componentname *tcnp)
610 {
611 struct vop_rename_args a;
612 a.a_desc = VDESC(vop_rename);
613 a.a_fdvp = fdvp;
614 a.a_fvp = fvp;
615 a.a_fcnp = fcnp;
616 a.a_tdvp = tdvp;
617 #ifdef VFSDEBUG
618 if ((tdvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(tdvp))
619 panic("vop_rename: tdvp");
620 #endif
621 a.a_tvp = tvp;
622 a.a_tcnp = tcnp;
623 return (VCALL(fdvp, VOFFSET(vop_rename), &a));
624 }
625
626 int vop_mkdir_vp_offsets[] = {
627 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp),
628 VDESC_NO_OFFSET
629 };
630 struct vnodeop_desc vop_mkdir_desc = {
631 0,
632 "vop_mkdir",
633 0 | VDESC_VP0_WILLPUT,
634 vop_mkdir_vp_offsets,
635 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp),
636 VDESC_NO_OFFSET,
637 VDESC_NO_OFFSET,
638 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp),
639 NULL,
640 };
641
642 int VOP_MKDIR(struct vnode *dvp, struct vnode **vpp,
643 struct componentname *cnp, struct vattr *vap)
644 {
645 struct vop_mkdir_args a;
646 a.a_desc = VDESC(vop_mkdir);
647 a.a_dvp = dvp;
648 #ifdef VFSDEBUG
649 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
650 panic("vop_mkdir: dvp");
651 #endif
652 a.a_vpp = vpp;
653 a.a_cnp = cnp;
654 a.a_vap = vap;
655 return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
656 }
657
658 int vop_rmdir_vp_offsets[] = {
659 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp),
660 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp),
661 VDESC_NO_OFFSET
662 };
663 struct vnodeop_desc vop_rmdir_desc = {
664 0,
665 "vop_rmdir",
666 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
667 vop_rmdir_vp_offsets,
668 VDESC_NO_OFFSET,
669 VDESC_NO_OFFSET,
670 VDESC_NO_OFFSET,
671 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp),
672 NULL,
673 };
674
675 int VOP_RMDIR(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
676 {
677 struct vop_rmdir_args a;
678 a.a_desc = VDESC(vop_rmdir);
679 a.a_dvp = dvp;
680 #ifdef VFSDEBUG
681 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
682 panic("vop_rmdir: dvp");
683 #endif
684 a.a_vp = vp;
685 #ifdef VFSDEBUG
686 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
687 panic("vop_rmdir: vp");
688 #endif
689 a.a_cnp = cnp;
690 return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
691 }
692
693 int vop_symlink_vp_offsets[] = {
694 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp),
695 VDESC_NO_OFFSET
696 };
697 struct vnodeop_desc vop_symlink_desc = {
698 0,
699 "vop_symlink",
700 0 | VDESC_VP0_WILLPUT | VDESC_VPP_WILLRELE,
701 vop_symlink_vp_offsets,
702 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp),
703 VDESC_NO_OFFSET,
704 VDESC_NO_OFFSET,
705 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp),
706 NULL,
707 };
708
709 int VOP_SYMLINK(struct vnode *dvp, struct vnode **vpp,
710 struct componentname *cnp, struct vattr *vap, char *target)
711 {
712 struct vop_symlink_args a;
713 a.a_desc = VDESC(vop_symlink);
714 a.a_dvp = dvp;
715 #ifdef VFSDEBUG
716 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
717 panic("vop_symlink: dvp");
718 #endif
719 a.a_vpp = vpp;
720 a.a_cnp = cnp;
721 a.a_vap = vap;
722 a.a_target = target;
723 return (VCALL(dvp, VOFFSET(vop_symlink), &a));
724 }
725
726 int vop_readdir_vp_offsets[] = {
727 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp),
728 VDESC_NO_OFFSET
729 };
730 struct vnodeop_desc vop_readdir_desc = {
731 0,
732 "vop_readdir",
733 0,
734 vop_readdir_vp_offsets,
735 VDESC_NO_OFFSET,
736 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred),
737 VDESC_NO_OFFSET,
738 VDESC_NO_OFFSET,
739 NULL,
740 };
741
742 int VOP_READDIR(struct vnode *vp, struct uio *uio, struct ucred *cred,
743 int *eofflag, int *ncookies, u_long **cookies)
744 {
745 struct vop_readdir_args a;
746 a.a_desc = VDESC(vop_readdir);
747 a.a_vp = vp;
748 #ifdef VFSDEBUG
749 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
750 panic("vop_readdir: vp");
751 #endif
752 a.a_uio = uio;
753 a.a_cred = cred;
754 a.a_eofflag = eofflag;
755 a.a_ncookies = ncookies;
756 a.a_cookies = cookies;
757 return (VCALL(vp, VOFFSET(vop_readdir), &a));
758 }
759
760 int vop_readlink_vp_offsets[] = {
761 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp),
762 VDESC_NO_OFFSET
763 };
764 struct vnodeop_desc vop_readlink_desc = {
765 0,
766 "vop_readlink",
767 0,
768 vop_readlink_vp_offsets,
769 VDESC_NO_OFFSET,
770 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred),
771 VDESC_NO_OFFSET,
772 VDESC_NO_OFFSET,
773 NULL,
774 };
775
776 int VOP_READLINK(struct vnode *vp, struct uio *uio, struct ucred *cred)
777 {
778 struct vop_readlink_args a;
779 a.a_desc = VDESC(vop_readlink);
780 a.a_vp = vp;
781 #ifdef VFSDEBUG
782 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
783 panic("vop_readlink: vp");
784 #endif
785 a.a_uio = uio;
786 a.a_cred = cred;
787 return (VCALL(vp, VOFFSET(vop_readlink), &a));
788 }
789
790 int vop_abortop_vp_offsets[] = {
791 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp),
792 VDESC_NO_OFFSET
793 };
794 struct vnodeop_desc vop_abortop_desc = {
795 0,
796 "vop_abortop",
797 0,
798 vop_abortop_vp_offsets,
799 VDESC_NO_OFFSET,
800 VDESC_NO_OFFSET,
801 VDESC_NO_OFFSET,
802 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp),
803 NULL,
804 };
805
806 int VOP_ABORTOP(struct vnode *dvp, struct componentname *cnp)
807 {
808 struct vop_abortop_args a;
809 a.a_desc = VDESC(vop_abortop);
810 a.a_dvp = dvp;
811 a.a_cnp = cnp;
812 return (VCALL(dvp, VOFFSET(vop_abortop), &a));
813 }
814
815 int vop_inactive_vp_offsets[] = {
816 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp),
817 VDESC_NO_OFFSET
818 };
819 struct vnodeop_desc vop_inactive_desc = {
820 0,
821 "vop_inactive",
822 0 | VDESC_VP0_WILLUNLOCK,
823 vop_inactive_vp_offsets,
824 VDESC_NO_OFFSET,
825 VDESC_NO_OFFSET,
826 VOPARG_OFFSETOF(struct vop_inactive_args, a_p),
827 VDESC_NO_OFFSET,
828 NULL,
829 };
830
831 int VOP_INACTIVE(struct vnode *vp, struct proc *p)
832 {
833 struct vop_inactive_args a;
834 a.a_desc = VDESC(vop_inactive);
835 a.a_vp = vp;
836 #ifdef VFSDEBUG
837 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
838 panic("vop_inactive: vp");
839 #endif
840 a.a_p = p;
841 return (VCALL(vp, VOFFSET(vop_inactive), &a));
842 }
843
844 int vop_reclaim_vp_offsets[] = {
845 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp),
846 VDESC_NO_OFFSET
847 };
848 struct vnodeop_desc vop_reclaim_desc = {
849 0,
850 "vop_reclaim",
851 0,
852 vop_reclaim_vp_offsets,
853 VDESC_NO_OFFSET,
854 VDESC_NO_OFFSET,
855 VOPARG_OFFSETOF(struct vop_reclaim_args, a_p),
856 VDESC_NO_OFFSET,
857 NULL,
858 };
859
860 int VOP_RECLAIM(struct vnode *vp, struct proc *p)
861 {
862 struct vop_reclaim_args a;
863 a.a_desc = VDESC(vop_reclaim);
864 a.a_vp = vp;
865 a.a_p = p;
866 return (VCALL(vp, VOFFSET(vop_reclaim), &a));
867 }
868
869 int vop_lock_vp_offsets[] = {
870 VOPARG_OFFSETOF(struct vop_lock_args,a_vp),
871 VDESC_NO_OFFSET
872 };
873 struct vnodeop_desc vop_lock_desc = {
874 0,
875 "vop_lock",
876 0,
877 vop_lock_vp_offsets,
878 VDESC_NO_OFFSET,
879 VDESC_NO_OFFSET,
880 VOPARG_OFFSETOF(struct vop_lock_args, a_p),
881 VDESC_NO_OFFSET,
882 NULL,
883 };
884
885 int VOP_LOCK(struct vnode *vp, int flags, struct proc *p)
886 {
887 struct vop_lock_args a;
888 a.a_desc = VDESC(vop_lock);
889 a.a_vp = vp;
890 a.a_flags = flags;
891 a.a_p = p;
892 return (VCALL(vp, VOFFSET(vop_lock), &a));
893 }
894
895 int vop_unlock_vp_offsets[] = {
896 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp),
897 VDESC_NO_OFFSET
898 };
899 struct vnodeop_desc vop_unlock_desc = {
900 0,
901 "vop_unlock",
902 0,
903 vop_unlock_vp_offsets,
904 VDESC_NO_OFFSET,
905 VDESC_NO_OFFSET,
906 VOPARG_OFFSETOF(struct vop_unlock_args, a_p),
907 VDESC_NO_OFFSET,
908 NULL,
909 };
910
911 int VOP_UNLOCK(struct vnode *vp, int flags, struct proc *p)
912 {
913 struct vop_unlock_args a;
914 a.a_desc = VDESC(vop_unlock);
915 a.a_vp = vp;
916 a.a_flags = flags;
917 a.a_p = p;
918 return (VCALL(vp, VOFFSET(vop_unlock), &a));
919 }
920
921 int vop_bmap_vp_offsets[] = {
922 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp),
923 VDESC_NO_OFFSET
924 };
925 struct vnodeop_desc vop_bmap_desc = {
926 0,
927 "vop_bmap",
928 0,
929 vop_bmap_vp_offsets,
930 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp),
931 VDESC_NO_OFFSET,
932 VDESC_NO_OFFSET,
933 VDESC_NO_OFFSET,
934 NULL,
935 };
936
937 int VOP_BMAP(struct vnode *vp, daddr64_t bn, struct vnode **vpp,
938 daddr64_t *bnp, int *runp)
939 {
940 struct vop_bmap_args a;
941 a.a_desc = VDESC(vop_bmap);
942 a.a_vp = vp;
943 #ifdef VFSDEBUG
944 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
945 panic("vop_bmap: vp");
946 #endif
947 a.a_bn = bn;
948 a.a_vpp = vpp;
949 a.a_bnp = bnp;
950 a.a_runp = runp;
951 return (VCALL(vp, VOFFSET(vop_bmap), &a));
952 }
953
954 int vop_print_vp_offsets[] = {
955 VOPARG_OFFSETOF(struct vop_print_args,a_vp),
956 VDESC_NO_OFFSET
957 };
958 struct vnodeop_desc vop_print_desc = {
959 0,
960 "vop_print",
961 0,
962 vop_print_vp_offsets,
963 VDESC_NO_OFFSET,
964 VDESC_NO_OFFSET,
965 VDESC_NO_OFFSET,
966 VDESC_NO_OFFSET,
967 NULL,
968 };
969
970 int VOP_PRINT(struct vnode *vp)
971 {
972 struct vop_print_args a;
973 a.a_desc = VDESC(vop_print);
974 a.a_vp = vp;
975 return (VCALL(vp, VOFFSET(vop_print), &a));
976 }
977
978 int vop_pathconf_vp_offsets[] = {
979 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp),
980 VDESC_NO_OFFSET
981 };
982 struct vnodeop_desc vop_pathconf_desc = {
983 0,
984 "vop_pathconf",
985 0,
986 vop_pathconf_vp_offsets,
987 VDESC_NO_OFFSET,
988 VDESC_NO_OFFSET,
989 VDESC_NO_OFFSET,
990 VDESC_NO_OFFSET,
991 NULL,
992 };
993
994 int VOP_PATHCONF(struct vnode *vp, int name, register_t *retval)
995 {
996 struct vop_pathconf_args a;
997 a.a_desc = VDESC(vop_pathconf);
998 a.a_vp = vp;
999 #ifdef VFSDEBUG
1000 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
1001 panic("vop_pathconf: vp");
1002 #endif
1003 a.a_name = name;
1004 a.a_retval = retval;
1005 return (VCALL(vp, VOFFSET(vop_pathconf), &a));
1006 }
1007
1008 int vop_advlock_vp_offsets[] = {
1009 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp),
1010 VDESC_NO_OFFSET
1011 };
1012 struct vnodeop_desc vop_advlock_desc = {
1013 0,
1014 "vop_advlock",
1015 0,
1016 vop_advlock_vp_offsets,
1017 VDESC_NO_OFFSET,
1018 VDESC_NO_OFFSET,
1019 VDESC_NO_OFFSET,
1020 VDESC_NO_OFFSET,
1021 NULL,
1022 };
1023
1024 int VOP_ADVLOCK(struct vnode *vp, void *id, int op, struct flock *fl, int flags)
1025 {
1026 struct vop_advlock_args a;
1027 a.a_desc = VDESC(vop_advlock);
1028 a.a_vp = vp;
1029 a.a_id = id;
1030 a.a_op = op;
1031 a.a_fl = fl;
1032 a.a_flags = flags;
1033 return (VCALL(vp, VOFFSET(vop_advlock), &a));
1034 }
1035
1036 int vop_reallocblks_vp_offsets[] = {
1037 VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp),
1038 VDESC_NO_OFFSET
1039 };
1040 struct vnodeop_desc vop_reallocblks_desc = {
1041 0,
1042 "vop_reallocblks",
1043 0,
1044 vop_reallocblks_vp_offsets,
1045 VDESC_NO_OFFSET,
1046 VDESC_NO_OFFSET,
1047 VDESC_NO_OFFSET,
1048 VDESC_NO_OFFSET,
1049 NULL,
1050 };
1051
1052 int VOP_REALLOCBLKS(struct vnode *vp, struct cluster_save *buflist)
1053 {
1054 struct vop_reallocblks_args a;
1055 a.a_desc = VDESC(vop_reallocblks);
1056 a.a_vp = vp;
1057 #ifdef VFSDEBUG
1058 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
1059 panic("vop_reallocblks: vp");
1060 #endif
1061 a.a_buflist = buflist;
1062 return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
1063 }
1064
1065
1066
1067 int vop_strategy_vp_offsets[] = {
1068 VDESC_NO_OFFSET
1069 };
1070 struct vnodeop_desc vop_strategy_desc = {
1071 0,
1072 "vop_strategy",
1073 0,
1074 vop_strategy_vp_offsets,
1075 VDESC_NO_OFFSET,
1076 VDESC_NO_OFFSET,
1077 VDESC_NO_OFFSET,
1078 VDESC_NO_OFFSET,
1079 NULL,
1080 };
1081
1082 int VOP_STRATEGY(struct buf *bp)
1083 {
1084 struct vop_strategy_args a;
1085 a.a_desc = VDESC(vop_strategy);
1086 a.a_bp = bp;
1087 return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a));
1088 }
1089
1090 int vop_bwrite_vp_offsets[] = {
1091 VDESC_NO_OFFSET
1092 };
1093 struct vnodeop_desc vop_bwrite_desc = {
1094 0,
1095 "vop_bwrite",
1096 0,
1097 vop_bwrite_vp_offsets,
1098 VDESC_NO_OFFSET,
1099 VDESC_NO_OFFSET,
1100 VDESC_NO_OFFSET,
1101 VDESC_NO_OFFSET,
1102 NULL,
1103 };
1104
1105 int VOP_BWRITE(struct buf *bp)
1106 {
1107 struct vop_bwrite_args a;
1108 a.a_desc = VDESC(vop_bwrite);
1109 a.a_bp = bp;
1110 return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
1111 }
1112
1113
1114
1115 struct vnodeop_desc *vfs_op_descs[] = {
1116 &vop_default_desc,
1117 &vop_strategy_desc,
1118 &vop_bwrite_desc,
1119
1120 &vop_islocked_desc,
1121 &vop_lookup_desc,
1122 &vop_create_desc,
1123 &vop_mknod_desc,
1124 &vop_open_desc,
1125 &vop_close_desc,
1126 &vop_access_desc,
1127 &vop_getattr_desc,
1128 &vop_setattr_desc,
1129 &vop_read_desc,
1130 &vop_write_desc,
1131 &vop_ioctl_desc,
1132 &vop_poll_desc,
1133 &vop_kqfilter_desc,
1134 &vop_revoke_desc,
1135 &vop_fsync_desc,
1136 &vop_remove_desc,
1137 &vop_link_desc,
1138 &vop_rename_desc,
1139 &vop_mkdir_desc,
1140 &vop_rmdir_desc,
1141 &vop_symlink_desc,
1142 &vop_readdir_desc,
1143 &vop_readlink_desc,
1144 &vop_abortop_desc,
1145 &vop_inactive_desc,
1146 &vop_reclaim_desc,
1147 &vop_lock_desc,
1148 &vop_unlock_desc,
1149 &vop_bmap_desc,
1150 &vop_print_desc,
1151 &vop_pathconf_desc,
1152 &vop_advlock_desc,
1153 &vop_reallocblks_desc,
1154 NULL
1155 };
1156