1 /*
2 * Warning: This file is generated automatically.
3 * (Modifications made here may easily be lost!)
4 *
5 * Created from the file:
6 * OpenBSD: vnode_if.src,v 1.29 2005/07/14 09:04:59 pedro Exp
7 * by the script:
8 * MirOS: src/sys/kern/vnode_if.sh,v 1.2 2005/07/07 13:39:41 tg Exp
9 */
10
11 /*
12 * Copyright (c) 1992, 1993
13 * The Regents of the University of California. All rights reserved.
14 *
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions
17 * are met:
18 * 1. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 * 2. Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in the
22 * documentation and/or other materials provided with the distribution.
23 * 3. Neither the name of the University nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
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
VOP_ISLOCKED(vp)73 int VOP_ISLOCKED(vp)
74 struct vnode *vp;
75 {
76 struct vop_islocked_args a;
77 a.a_desc = VDESC(vop_islocked);
78 a.a_vp = vp;
79 return (VCALL(vp, VOFFSET(vop_islocked), &a));
80 }
81
82 int vop_lookup_vp_offsets[] = {
83 VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp),
84 VDESC_NO_OFFSET
85 };
86 struct vnodeop_desc vop_lookup_desc = {
87 0,
88 "vop_lookup",
89 0,
90 vop_lookup_vp_offsets,
91 VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp),
92 VDESC_NO_OFFSET,
93 VDESC_NO_OFFSET,
94 VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp),
95 NULL,
96 };
97
VOP_LOOKUP(dvp,vpp,cnp)98 int VOP_LOOKUP(dvp, vpp, cnp)
99 struct vnode *dvp;
100 struct vnode **vpp;
101 struct componentname *cnp;
102 {
103 struct vop_lookup_args a;
104 a.a_desc = VDESC(vop_lookup);
105 a.a_dvp = dvp;
106 a.a_vpp = vpp;
107 a.a_cnp = cnp;
108 return (VCALL(dvp, VOFFSET(vop_lookup), &a));
109 }
110
111 int vop_create_vp_offsets[] = {
112 VOPARG_OFFSETOF(struct vop_create_args,a_dvp),
113 VDESC_NO_OFFSET
114 };
115 struct vnodeop_desc vop_create_desc = {
116 0,
117 "vop_create",
118 0 | VDESC_VP0_WILLPUT,
119 vop_create_vp_offsets,
120 VOPARG_OFFSETOF(struct vop_create_args, a_vpp),
121 VDESC_NO_OFFSET,
122 VDESC_NO_OFFSET,
123 VOPARG_OFFSETOF(struct vop_create_args, a_cnp),
124 NULL,
125 };
126
VOP_CREATE(dvp,vpp,cnp,vap)127 int VOP_CREATE(dvp, vpp, cnp, vap)
128 struct vnode *dvp;
129 struct vnode **vpp;
130 struct componentname *cnp;
131 struct vattr *vap;
132 {
133 struct vop_create_args a;
134 a.a_desc = VDESC(vop_create);
135 a.a_dvp = dvp;
136 #ifdef VFSDEBUG
137 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
138 panic("vop_create: dvp");
139 #endif
140 a.a_vpp = vpp;
141 a.a_cnp = cnp;
142 a.a_vap = vap;
143 return (VCALL(dvp, VOFFSET(vop_create), &a));
144 }
145
146 int vop_mknod_vp_offsets[] = {
147 VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp),
148 VDESC_NO_OFFSET
149 };
150 struct vnodeop_desc vop_mknod_desc = {
151 0,
152 "vop_mknod",
153 0 | VDESC_VP0_WILLPUT | VDESC_VPP_WILLRELE,
154 vop_mknod_vp_offsets,
155 VOPARG_OFFSETOF(struct vop_mknod_args, a_vpp),
156 VDESC_NO_OFFSET,
157 VDESC_NO_OFFSET,
158 VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp),
159 NULL,
160 };
161
VOP_MKNOD(dvp,vpp,cnp,vap)162 int VOP_MKNOD(dvp, vpp, cnp, vap)
163 struct vnode *dvp;
164 struct vnode **vpp;
165 struct componentname *cnp;
166 struct vattr *vap;
167 {
168 struct vop_mknod_args a;
169 a.a_desc = VDESC(vop_mknod);
170 a.a_dvp = dvp;
171 #ifdef VFSDEBUG
172 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
173 panic("vop_mknod: dvp");
174 #endif
175 a.a_vpp = vpp;
176 a.a_cnp = cnp;
177 a.a_vap = vap;
178 return (VCALL(dvp, VOFFSET(vop_mknod), &a));
179 }
180
181 int vop_open_vp_offsets[] = {
182 VOPARG_OFFSETOF(struct vop_open_args,a_vp),
183 VDESC_NO_OFFSET
184 };
185 struct vnodeop_desc vop_open_desc = {
186 0,
187 "vop_open",
188 0,
189 vop_open_vp_offsets,
190 VDESC_NO_OFFSET,
191 VOPARG_OFFSETOF(struct vop_open_args, a_cred),
192 VOPARG_OFFSETOF(struct vop_open_args, a_p),
193 VDESC_NO_OFFSET,
194 NULL,
195 };
196
VOP_OPEN(vp,mode,cred,p)197 int VOP_OPEN(vp, mode, cred, p)
198 struct vnode *vp;
199 int mode;
200 struct ucred *cred;
201 struct proc *p;
202 {
203 struct vop_open_args a;
204 a.a_desc = VDESC(vop_open);
205 a.a_vp = vp;
206 a.a_mode = mode;
207 a.a_cred = cred;
208 a.a_p = p;
209 return (VCALL(vp, VOFFSET(vop_open), &a));
210 }
211
212 int vop_close_vp_offsets[] = {
213 VOPARG_OFFSETOF(struct vop_close_args,a_vp),
214 VDESC_NO_OFFSET
215 };
216 struct vnodeop_desc vop_close_desc = {
217 0,
218 "vop_close",
219 0,
220 vop_close_vp_offsets,
221 VDESC_NO_OFFSET,
222 VOPARG_OFFSETOF(struct vop_close_args, a_cred),
223 VOPARG_OFFSETOF(struct vop_close_args, a_p),
224 VDESC_NO_OFFSET,
225 NULL,
226 };
227
VOP_CLOSE(vp,fflag,cred,p)228 int VOP_CLOSE(vp, fflag, cred, p)
229 struct vnode *vp;
230 int fflag;
231 struct ucred *cred;
232 struct proc *p;
233 {
234 struct vop_close_args a;
235 a.a_desc = VDESC(vop_close);
236 a.a_vp = vp;
237 #ifdef VFSDEBUG
238 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
239 panic("vop_close: vp");
240 #endif
241 a.a_fflag = fflag;
242 a.a_cred = cred;
243 a.a_p = p;
244 return (VCALL(vp, VOFFSET(vop_close), &a));
245 }
246
247 int vop_access_vp_offsets[] = {
248 VOPARG_OFFSETOF(struct vop_access_args,a_vp),
249 VDESC_NO_OFFSET
250 };
251 struct vnodeop_desc vop_access_desc = {
252 0,
253 "vop_access",
254 0,
255 vop_access_vp_offsets,
256 VDESC_NO_OFFSET,
257 VOPARG_OFFSETOF(struct vop_access_args, a_cred),
258 VOPARG_OFFSETOF(struct vop_access_args, a_p),
259 VDESC_NO_OFFSET,
260 NULL,
261 };
262
VOP_ACCESS(vp,mode,cred,p)263 int VOP_ACCESS(vp, mode, cred, p)
264 struct vnode *vp;
265 int mode;
266 struct ucred *cred;
267 struct proc *p;
268 {
269 struct vop_access_args a;
270 a.a_desc = VDESC(vop_access);
271 a.a_vp = vp;
272 #ifdef VFSDEBUG
273 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
274 panic("vop_access: vp");
275 #endif
276 a.a_mode = mode;
277 a.a_cred = cred;
278 a.a_p = p;
279 return (VCALL(vp, VOFFSET(vop_access), &a));
280 }
281
282 int vop_getattr_vp_offsets[] = {
283 VOPARG_OFFSETOF(struct vop_getattr_args,a_vp),
284 VDESC_NO_OFFSET
285 };
286 struct vnodeop_desc vop_getattr_desc = {
287 0,
288 "vop_getattr",
289 0,
290 vop_getattr_vp_offsets,
291 VDESC_NO_OFFSET,
292 VOPARG_OFFSETOF(struct vop_getattr_args, a_cred),
293 VOPARG_OFFSETOF(struct vop_getattr_args, a_p),
294 VDESC_NO_OFFSET,
295 NULL,
296 };
297
VOP_GETATTR(vp,vap,cred,p)298 int VOP_GETATTR(vp, vap, cred, p)
299 struct vnode *vp;
300 struct vattr *vap;
301 struct ucred *cred;
302 struct proc *p;
303 {
304 struct vop_getattr_args a;
305 a.a_desc = VDESC(vop_getattr);
306 a.a_vp = vp;
307 a.a_vap = vap;
308 a.a_cred = cred;
309 a.a_p = p;
310 return (VCALL(vp, VOFFSET(vop_getattr), &a));
311 }
312
313 int vop_setattr_vp_offsets[] = {
314 VOPARG_OFFSETOF(struct vop_setattr_args,a_vp),
315 VDESC_NO_OFFSET
316 };
317 struct vnodeop_desc vop_setattr_desc = {
318 0,
319 "vop_setattr",
320 0,
321 vop_setattr_vp_offsets,
322 VDESC_NO_OFFSET,
323 VOPARG_OFFSETOF(struct vop_setattr_args, a_cred),
324 VOPARG_OFFSETOF(struct vop_setattr_args, a_p),
325 VDESC_NO_OFFSET,
326 NULL,
327 };
328
VOP_SETATTR(vp,vap,cred,p)329 int VOP_SETATTR(vp, vap, cred, p)
330 struct vnode *vp;
331 struct vattr *vap;
332 struct ucred *cred;
333 struct proc *p;
334 {
335 struct vop_setattr_args a;
336 a.a_desc = VDESC(vop_setattr);
337 a.a_vp = vp;
338 #ifdef VFSDEBUG
339 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
340 panic("vop_setattr: vp");
341 #endif
342 a.a_vap = vap;
343 a.a_cred = cred;
344 a.a_p = p;
345 return (VCALL(vp, VOFFSET(vop_setattr), &a));
346 }
347
348 int vop_read_vp_offsets[] = {
349 VOPARG_OFFSETOF(struct vop_read_args,a_vp),
350 VDESC_NO_OFFSET
351 };
352 struct vnodeop_desc vop_read_desc = {
353 0,
354 "vop_read",
355 0,
356 vop_read_vp_offsets,
357 VDESC_NO_OFFSET,
358 VOPARG_OFFSETOF(struct vop_read_args, a_cred),
359 VDESC_NO_OFFSET,
360 VDESC_NO_OFFSET,
361 NULL,
362 };
363
VOP_READ(vp,uio,ioflag,cred)364 int VOP_READ(vp, uio, ioflag, cred)
365 struct vnode *vp;
366 struct uio *uio;
367 int ioflag;
368 struct ucred *cred;
369 {
370 struct vop_read_args a;
371 a.a_desc = VDESC(vop_read);
372 a.a_vp = vp;
373 #ifdef VFSDEBUG
374 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
375 panic("vop_read: vp");
376 #endif
377 a.a_uio = uio;
378 a.a_ioflag = ioflag;
379 a.a_cred = cred;
380 return (VCALL(vp, VOFFSET(vop_read), &a));
381 }
382
383 int vop_write_vp_offsets[] = {
384 VOPARG_OFFSETOF(struct vop_write_args,a_vp),
385 VDESC_NO_OFFSET
386 };
387 struct vnodeop_desc vop_write_desc = {
388 0,
389 "vop_write",
390 0,
391 vop_write_vp_offsets,
392 VDESC_NO_OFFSET,
393 VOPARG_OFFSETOF(struct vop_write_args, a_cred),
394 VDESC_NO_OFFSET,
395 VDESC_NO_OFFSET,
396 NULL,
397 };
398
VOP_WRITE(vp,uio,ioflag,cred)399 int VOP_WRITE(vp, uio, ioflag, cred)
400 struct vnode *vp;
401 struct uio *uio;
402 int ioflag;
403 struct ucred *cred;
404 {
405 struct vop_write_args a;
406 a.a_desc = VDESC(vop_write);
407 a.a_vp = vp;
408 #ifdef VFSDEBUG
409 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
410 panic("vop_write: vp");
411 #endif
412 a.a_uio = uio;
413 a.a_ioflag = ioflag;
414 a.a_cred = cred;
415 return (VCALL(vp, VOFFSET(vop_write), &a));
416 }
417
418 int vop_lease_vp_offsets[] = {
419 VOPARG_OFFSETOF(struct vop_lease_args,a_vp),
420 VDESC_NO_OFFSET
421 };
422 struct vnodeop_desc vop_lease_desc = {
423 0,
424 "vop_lease",
425 0,
426 vop_lease_vp_offsets,
427 VDESC_NO_OFFSET,
428 VOPARG_OFFSETOF(struct vop_lease_args, a_cred),
429 VOPARG_OFFSETOF(struct vop_lease_args, a_p),
430 VDESC_NO_OFFSET,
431 NULL,
432 };
433
VOP_LEASE(vp,p,cred,flag)434 int VOP_LEASE(vp, p, cred, flag)
435 struct vnode *vp;
436 struct proc *p;
437 struct ucred *cred;
438 int flag;
439 {
440 struct vop_lease_args a;
441 a.a_desc = VDESC(vop_lease);
442 a.a_vp = vp;
443 a.a_p = p;
444 a.a_cred = cred;
445 a.a_flag = flag;
446 return (VCALL(vp, VOFFSET(vop_lease), &a));
447 }
448
449 int vop_ioctl_vp_offsets[] = {
450 VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp),
451 VDESC_NO_OFFSET
452 };
453 struct vnodeop_desc vop_ioctl_desc = {
454 0,
455 "vop_ioctl",
456 0,
457 vop_ioctl_vp_offsets,
458 VDESC_NO_OFFSET,
459 VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred),
460 VOPARG_OFFSETOF(struct vop_ioctl_args, a_p),
461 VDESC_NO_OFFSET,
462 NULL,
463 };
464
VOP_IOCTL(vp,command,data,fflag,cred,p)465 int VOP_IOCTL(vp, command, data, fflag, cred, p)
466 struct vnode *vp;
467 u_long command;
468 void *data;
469 int fflag;
470 struct ucred *cred;
471 struct proc *p;
472 {
473 struct vop_ioctl_args a;
474 a.a_desc = VDESC(vop_ioctl);
475 a.a_vp = vp;
476 a.a_command = command;
477 a.a_data = data;
478 a.a_fflag = fflag;
479 a.a_cred = cred;
480 a.a_p = p;
481 return (VCALL(vp, VOFFSET(vop_ioctl), &a));
482 }
483
484 int vop_poll_vp_offsets[] = {
485 VOPARG_OFFSETOF(struct vop_poll_args,a_vp),
486 VDESC_NO_OFFSET
487 };
488 struct vnodeop_desc vop_poll_desc = {
489 0,
490 "vop_poll",
491 0,
492 vop_poll_vp_offsets,
493 VDESC_NO_OFFSET,
494 VDESC_NO_OFFSET,
495 VOPARG_OFFSETOF(struct vop_poll_args, a_p),
496 VDESC_NO_OFFSET,
497 NULL,
498 };
499
VOP_POLL(vp,events,p)500 int VOP_POLL(vp, events, p)
501 struct vnode *vp;
502 int events;
503 struct proc *p;
504 {
505 struct vop_poll_args a;
506 a.a_desc = VDESC(vop_poll);
507 a.a_vp = vp;
508 a.a_events = events;
509 a.a_p = p;
510 return (VCALL(vp, VOFFSET(vop_poll), &a));
511 }
512
513 int vop_kqfilter_vp_offsets[] = {
514 VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp),
515 VDESC_NO_OFFSET
516 };
517 struct vnodeop_desc vop_kqfilter_desc = {
518 0,
519 "vop_kqfilter",
520 0,
521 vop_kqfilter_vp_offsets,
522 VDESC_NO_OFFSET,
523 VDESC_NO_OFFSET,
524 VDESC_NO_OFFSET,
525 VDESC_NO_OFFSET,
526 NULL,
527 };
528
VOP_KQFILTER(vp,kn)529 int VOP_KQFILTER(vp, kn)
530 struct vnode *vp;
531 struct knote *kn;
532 {
533 struct vop_kqfilter_args a;
534 a.a_desc = VDESC(vop_kqfilter);
535 a.a_vp = vp;
536 a.a_kn = kn;
537 return (VCALL(vp, VOFFSET(vop_kqfilter), &a));
538 }
539
540 int vop_revoke_vp_offsets[] = {
541 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp),
542 VDESC_NO_OFFSET
543 };
544 struct vnodeop_desc vop_revoke_desc = {
545 0,
546 "vop_revoke",
547 0,
548 vop_revoke_vp_offsets,
549 VDESC_NO_OFFSET,
550 VDESC_NO_OFFSET,
551 VDESC_NO_OFFSET,
552 VDESC_NO_OFFSET,
553 NULL,
554 };
555
VOP_REVOKE(vp,flags)556 int VOP_REVOKE(vp, flags)
557 struct vnode *vp;
558 int flags;
559 {
560 struct vop_revoke_args a;
561 a.a_desc = VDESC(vop_revoke);
562 a.a_vp = vp;
563 a.a_flags = flags;
564 return (VCALL(vp, VOFFSET(vop_revoke), &a));
565 }
566
567 int vop_fsync_vp_offsets[] = {
568 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp),
569 VDESC_NO_OFFSET
570 };
571 struct vnodeop_desc vop_fsync_desc = {
572 0,
573 "vop_fsync",
574 0,
575 vop_fsync_vp_offsets,
576 VDESC_NO_OFFSET,
577 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred),
578 VOPARG_OFFSETOF(struct vop_fsync_args, a_p),
579 VDESC_NO_OFFSET,
580 NULL,
581 };
582
VOP_FSYNC(vp,cred,waitfor,p)583 int VOP_FSYNC(vp, cred, waitfor, p)
584 struct vnode *vp;
585 struct ucred *cred;
586 int waitfor;
587 struct proc *p;
588 {
589 struct vop_fsync_args a;
590 a.a_desc = VDESC(vop_fsync);
591 a.a_vp = vp;
592 #ifdef VFSDEBUG
593 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
594 panic("vop_fsync: vp");
595 #endif
596 a.a_cred = cred;
597 a.a_waitfor = waitfor;
598 a.a_p = p;
599 return (VCALL(vp, VOFFSET(vop_fsync), &a));
600 }
601
602 int vop_remove_vp_offsets[] = {
603 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp),
604 VOPARG_OFFSETOF(struct vop_remove_args,a_vp),
605 VDESC_NO_OFFSET
606 };
607 struct vnodeop_desc vop_remove_desc = {
608 0,
609 "vop_remove",
610 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
611 vop_remove_vp_offsets,
612 VDESC_NO_OFFSET,
613 VDESC_NO_OFFSET,
614 VDESC_NO_OFFSET,
615 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp),
616 NULL,
617 };
618
VOP_REMOVE(dvp,vp,cnp)619 int VOP_REMOVE(dvp, vp, cnp)
620 struct vnode *dvp;
621 struct vnode *vp;
622 struct componentname *cnp;
623 {
624 struct vop_remove_args a;
625 a.a_desc = VDESC(vop_remove);
626 a.a_dvp = dvp;
627 #ifdef VFSDEBUG
628 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
629 panic("vop_remove: dvp");
630 #endif
631 a.a_vp = vp;
632 #ifdef VFSDEBUG
633 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
634 panic("vop_remove: vp");
635 #endif
636 a.a_cnp = cnp;
637 return (VCALL(dvp, VOFFSET(vop_remove), &a));
638 }
639
640 int vop_link_vp_offsets[] = {
641 VOPARG_OFFSETOF(struct vop_link_args,a_dvp),
642 VOPARG_OFFSETOF(struct vop_link_args,a_vp),
643 VDESC_NO_OFFSET
644 };
645 struct vnodeop_desc vop_link_desc = {
646 0,
647 "vop_link",
648 0 | VDESC_VP0_WILLPUT,
649 vop_link_vp_offsets,
650 VDESC_NO_OFFSET,
651 VDESC_NO_OFFSET,
652 VDESC_NO_OFFSET,
653 VOPARG_OFFSETOF(struct vop_link_args, a_cnp),
654 NULL,
655 };
656
VOP_LINK(dvp,vp,cnp)657 int VOP_LINK(dvp, vp, cnp)
658 struct vnode *dvp;
659 struct vnode *vp;
660 struct componentname *cnp;
661 {
662 struct vop_link_args a;
663 a.a_desc = VDESC(vop_link);
664 a.a_dvp = dvp;
665 #ifdef VFSDEBUG
666 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
667 panic("vop_link: dvp");
668 #endif
669 a.a_vp = vp;
670 a.a_cnp = cnp;
671 return (VCALL(dvp, VOFFSET(vop_link), &a));
672 }
673
674 int vop_rename_vp_offsets[] = {
675 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp),
676 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp),
677 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp),
678 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp),
679 VDESC_NO_OFFSET
680 };
681 struct vnodeop_desc vop_rename_desc = {
682 0,
683 "vop_rename",
684 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLRELE,
685 vop_rename_vp_offsets,
686 VDESC_NO_OFFSET,
687 VDESC_NO_OFFSET,
688 VDESC_NO_OFFSET,
689 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp),
690 NULL,
691 };
692
VOP_RENAME(fdvp,fvp,fcnp,tdvp,tvp,tcnp)693 int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
694 struct vnode *fdvp;
695 struct vnode *fvp;
696 struct componentname *fcnp;
697 struct vnode *tdvp;
698 struct vnode *tvp;
699 struct componentname *tcnp;
700 {
701 struct vop_rename_args a;
702 a.a_desc = VDESC(vop_rename);
703 a.a_fdvp = fdvp;
704 a.a_fvp = fvp;
705 a.a_fcnp = fcnp;
706 a.a_tdvp = tdvp;
707 #ifdef VFSDEBUG
708 if ((tdvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(tdvp))
709 panic("vop_rename: tdvp");
710 #endif
711 a.a_tvp = tvp;
712 a.a_tcnp = tcnp;
713 return (VCALL(fdvp, VOFFSET(vop_rename), &a));
714 }
715
716 int vop_mkdir_vp_offsets[] = {
717 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp),
718 VDESC_NO_OFFSET
719 };
720 struct vnodeop_desc vop_mkdir_desc = {
721 0,
722 "vop_mkdir",
723 0 | VDESC_VP0_WILLPUT,
724 vop_mkdir_vp_offsets,
725 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp),
726 VDESC_NO_OFFSET,
727 VDESC_NO_OFFSET,
728 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp),
729 NULL,
730 };
731
VOP_MKDIR(dvp,vpp,cnp,vap)732 int VOP_MKDIR(dvp, vpp, cnp, vap)
733 struct vnode *dvp;
734 struct vnode **vpp;
735 struct componentname *cnp;
736 struct vattr *vap;
737 {
738 struct vop_mkdir_args a;
739 a.a_desc = VDESC(vop_mkdir);
740 a.a_dvp = dvp;
741 #ifdef VFSDEBUG
742 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
743 panic("vop_mkdir: dvp");
744 #endif
745 a.a_vpp = vpp;
746 a.a_cnp = cnp;
747 a.a_vap = vap;
748 return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
749 }
750
751 int vop_rmdir_vp_offsets[] = {
752 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp),
753 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp),
754 VDESC_NO_OFFSET
755 };
756 struct vnodeop_desc vop_rmdir_desc = {
757 0,
758 "vop_rmdir",
759 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
760 vop_rmdir_vp_offsets,
761 VDESC_NO_OFFSET,
762 VDESC_NO_OFFSET,
763 VDESC_NO_OFFSET,
764 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp),
765 NULL,
766 };
767
VOP_RMDIR(dvp,vp,cnp)768 int VOP_RMDIR(dvp, vp, cnp)
769 struct vnode *dvp;
770 struct vnode *vp;
771 struct componentname *cnp;
772 {
773 struct vop_rmdir_args a;
774 a.a_desc = VDESC(vop_rmdir);
775 a.a_dvp = dvp;
776 #ifdef VFSDEBUG
777 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
778 panic("vop_rmdir: dvp");
779 #endif
780 a.a_vp = vp;
781 #ifdef VFSDEBUG
782 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
783 panic("vop_rmdir: vp");
784 #endif
785 a.a_cnp = cnp;
786 return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
787 }
788
789 int vop_symlink_vp_offsets[] = {
790 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp),
791 VDESC_NO_OFFSET
792 };
793 struct vnodeop_desc vop_symlink_desc = {
794 0,
795 "vop_symlink",
796 0 | VDESC_VP0_WILLPUT | VDESC_VPP_WILLRELE,
797 vop_symlink_vp_offsets,
798 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp),
799 VDESC_NO_OFFSET,
800 VDESC_NO_OFFSET,
801 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp),
802 NULL,
803 };
804
VOP_SYMLINK(dvp,vpp,cnp,vap,target)805 int VOP_SYMLINK(dvp, vpp, cnp, vap, target)
806 struct vnode *dvp;
807 struct vnode **vpp;
808 struct componentname *cnp;
809 struct vattr *vap;
810 char *target;
811 {
812 struct vop_symlink_args a;
813 a.a_desc = VDESC(vop_symlink);
814 a.a_dvp = dvp;
815 #ifdef VFSDEBUG
816 if ((dvp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(dvp))
817 panic("vop_symlink: dvp");
818 #endif
819 a.a_vpp = vpp;
820 a.a_cnp = cnp;
821 a.a_vap = vap;
822 a.a_target = target;
823 return (VCALL(dvp, VOFFSET(vop_symlink), &a));
824 }
825
826 int vop_readdir_vp_offsets[] = {
827 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp),
828 VDESC_NO_OFFSET
829 };
830 struct vnodeop_desc vop_readdir_desc = {
831 0,
832 "vop_readdir",
833 0,
834 vop_readdir_vp_offsets,
835 VDESC_NO_OFFSET,
836 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred),
837 VDESC_NO_OFFSET,
838 VDESC_NO_OFFSET,
839 NULL,
840 };
841
VOP_READDIR(vp,uio,cred,eofflag,ncookies,cookies)842 int VOP_READDIR(vp, uio, cred, eofflag, ncookies, cookies)
843 struct vnode *vp;
844 struct uio *uio;
845 struct ucred *cred;
846 int *eofflag;
847 int *ncookies;
848 u_long **cookies;
849 {
850 struct vop_readdir_args a;
851 a.a_desc = VDESC(vop_readdir);
852 a.a_vp = vp;
853 #ifdef VFSDEBUG
854 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
855 panic("vop_readdir: vp");
856 #endif
857 a.a_uio = uio;
858 a.a_cred = cred;
859 a.a_eofflag = eofflag;
860 a.a_ncookies = ncookies;
861 a.a_cookies = cookies;
862 return (VCALL(vp, VOFFSET(vop_readdir), &a));
863 }
864
865 int vop_readlink_vp_offsets[] = {
866 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp),
867 VDESC_NO_OFFSET
868 };
869 struct vnodeop_desc vop_readlink_desc = {
870 0,
871 "vop_readlink",
872 0,
873 vop_readlink_vp_offsets,
874 VDESC_NO_OFFSET,
875 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred),
876 VDESC_NO_OFFSET,
877 VDESC_NO_OFFSET,
878 NULL,
879 };
880
VOP_READLINK(vp,uio,cred)881 int VOP_READLINK(vp, uio, cred)
882 struct vnode *vp;
883 struct uio *uio;
884 struct ucred *cred;
885 {
886 struct vop_readlink_args a;
887 a.a_desc = VDESC(vop_readlink);
888 a.a_vp = vp;
889 #ifdef VFSDEBUG
890 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
891 panic("vop_readlink: vp");
892 #endif
893 a.a_uio = uio;
894 a.a_cred = cred;
895 return (VCALL(vp, VOFFSET(vop_readlink), &a));
896 }
897
898 int vop_abortop_vp_offsets[] = {
899 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp),
900 VDESC_NO_OFFSET
901 };
902 struct vnodeop_desc vop_abortop_desc = {
903 0,
904 "vop_abortop",
905 0,
906 vop_abortop_vp_offsets,
907 VDESC_NO_OFFSET,
908 VDESC_NO_OFFSET,
909 VDESC_NO_OFFSET,
910 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp),
911 NULL,
912 };
913
VOP_ABORTOP(dvp,cnp)914 int VOP_ABORTOP(dvp, cnp)
915 struct vnode *dvp;
916 struct componentname *cnp;
917 {
918 struct vop_abortop_args a;
919 a.a_desc = VDESC(vop_abortop);
920 a.a_dvp = dvp;
921 a.a_cnp = cnp;
922 return (VCALL(dvp, VOFFSET(vop_abortop), &a));
923 }
924
925 int vop_inactive_vp_offsets[] = {
926 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp),
927 VDESC_NO_OFFSET
928 };
929 struct vnodeop_desc vop_inactive_desc = {
930 0,
931 "vop_inactive",
932 0 | VDESC_VP0_WILLUNLOCK,
933 vop_inactive_vp_offsets,
934 VDESC_NO_OFFSET,
935 VDESC_NO_OFFSET,
936 VOPARG_OFFSETOF(struct vop_inactive_args, a_p),
937 VDESC_NO_OFFSET,
938 NULL,
939 };
940
VOP_INACTIVE(vp,p)941 int VOP_INACTIVE(vp, p)
942 struct vnode *vp;
943 struct proc *p;
944 {
945 struct vop_inactive_args a;
946 a.a_desc = VDESC(vop_inactive);
947 a.a_vp = vp;
948 #ifdef VFSDEBUG
949 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
950 panic("vop_inactive: vp");
951 #endif
952 a.a_p = p;
953 return (VCALL(vp, VOFFSET(vop_inactive), &a));
954 }
955
956 int vop_reclaim_vp_offsets[] = {
957 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp),
958 VDESC_NO_OFFSET
959 };
960 struct vnodeop_desc vop_reclaim_desc = {
961 0,
962 "vop_reclaim",
963 0,
964 vop_reclaim_vp_offsets,
965 VDESC_NO_OFFSET,
966 VDESC_NO_OFFSET,
967 VOPARG_OFFSETOF(struct vop_reclaim_args, a_p),
968 VDESC_NO_OFFSET,
969 NULL,
970 };
971
VOP_RECLAIM(vp,p)972 int VOP_RECLAIM(vp, p)
973 struct vnode *vp;
974 struct proc *p;
975 {
976 struct vop_reclaim_args a;
977 a.a_desc = VDESC(vop_reclaim);
978 a.a_vp = vp;
979 a.a_p = p;
980 return (VCALL(vp, VOFFSET(vop_reclaim), &a));
981 }
982
983 int vop_lock_vp_offsets[] = {
984 VOPARG_OFFSETOF(struct vop_lock_args,a_vp),
985 VDESC_NO_OFFSET
986 };
987 struct vnodeop_desc vop_lock_desc = {
988 0,
989 "vop_lock",
990 0,
991 vop_lock_vp_offsets,
992 VDESC_NO_OFFSET,
993 VDESC_NO_OFFSET,
994 VOPARG_OFFSETOF(struct vop_lock_args, a_p),
995 VDESC_NO_OFFSET,
996 NULL,
997 };
998
VOP_LOCK(vp,flags,p)999 int VOP_LOCK(vp, flags, p)
1000 struct vnode *vp;
1001 int flags;
1002 struct proc *p;
1003 {
1004 struct vop_lock_args a;
1005 a.a_desc = VDESC(vop_lock);
1006 a.a_vp = vp;
1007 a.a_flags = flags;
1008 a.a_p = p;
1009 return (VCALL(vp, VOFFSET(vop_lock), &a));
1010 }
1011
1012 int vop_unlock_vp_offsets[] = {
1013 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp),
1014 VDESC_NO_OFFSET
1015 };
1016 struct vnodeop_desc vop_unlock_desc = {
1017 0,
1018 "vop_unlock",
1019 0,
1020 vop_unlock_vp_offsets,
1021 VDESC_NO_OFFSET,
1022 VDESC_NO_OFFSET,
1023 VOPARG_OFFSETOF(struct vop_unlock_args, a_p),
1024 VDESC_NO_OFFSET,
1025 NULL,
1026 };
1027
VOP_UNLOCK(vp,flags,p)1028 int VOP_UNLOCK(vp, flags, p)
1029 struct vnode *vp;
1030 int flags;
1031 struct proc *p;
1032 {
1033 struct vop_unlock_args a;
1034 a.a_desc = VDESC(vop_unlock);
1035 a.a_vp = vp;
1036 a.a_flags = flags;
1037 a.a_p = p;
1038 return (VCALL(vp, VOFFSET(vop_unlock), &a));
1039 }
1040
1041 int vop_bmap_vp_offsets[] = {
1042 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp),
1043 VDESC_NO_OFFSET
1044 };
1045 struct vnodeop_desc vop_bmap_desc = {
1046 0,
1047 "vop_bmap",
1048 0,
1049 vop_bmap_vp_offsets,
1050 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp),
1051 VDESC_NO_OFFSET,
1052 VDESC_NO_OFFSET,
1053 VDESC_NO_OFFSET,
1054 NULL,
1055 };
1056
VOP_BMAP(vp,bn,vpp,bnp,runp)1057 int VOP_BMAP(vp, bn, vpp, bnp, runp)
1058 struct vnode *vp;
1059 daddr_t bn;
1060 struct vnode **vpp;
1061 daddr_t *bnp;
1062 int *runp;
1063 {
1064 struct vop_bmap_args a;
1065 a.a_desc = VDESC(vop_bmap);
1066 a.a_vp = vp;
1067 #ifdef VFSDEBUG
1068 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
1069 panic("vop_bmap: vp");
1070 #endif
1071 a.a_bn = bn;
1072 a.a_vpp = vpp;
1073 a.a_bnp = bnp;
1074 a.a_runp = runp;
1075 return (VCALL(vp, VOFFSET(vop_bmap), &a));
1076 }
1077
1078 int vop_print_vp_offsets[] = {
1079 VOPARG_OFFSETOF(struct vop_print_args,a_vp),
1080 VDESC_NO_OFFSET
1081 };
1082 struct vnodeop_desc vop_print_desc = {
1083 0,
1084 "vop_print",
1085 0,
1086 vop_print_vp_offsets,
1087 VDESC_NO_OFFSET,
1088 VDESC_NO_OFFSET,
1089 VDESC_NO_OFFSET,
1090 VDESC_NO_OFFSET,
1091 NULL,
1092 };
1093
VOP_PRINT(vp)1094 int VOP_PRINT(vp)
1095 struct vnode *vp;
1096 {
1097 struct vop_print_args a;
1098 a.a_desc = VDESC(vop_print);
1099 a.a_vp = vp;
1100 return (VCALL(vp, VOFFSET(vop_print), &a));
1101 }
1102
1103 int vop_pathconf_vp_offsets[] = {
1104 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp),
1105 VDESC_NO_OFFSET
1106 };
1107 struct vnodeop_desc vop_pathconf_desc = {
1108 0,
1109 "vop_pathconf",
1110 0,
1111 vop_pathconf_vp_offsets,
1112 VDESC_NO_OFFSET,
1113 VDESC_NO_OFFSET,
1114 VDESC_NO_OFFSET,
1115 VDESC_NO_OFFSET,
1116 NULL,
1117 };
1118
VOP_PATHCONF(vp,name,retval)1119 int VOP_PATHCONF(vp, name, retval)
1120 struct vnode *vp;
1121 int name;
1122 register_t *retval;
1123 {
1124 struct vop_pathconf_args a;
1125 a.a_desc = VDESC(vop_pathconf);
1126 a.a_vp = vp;
1127 #ifdef VFSDEBUG
1128 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
1129 panic("vop_pathconf: vp");
1130 #endif
1131 a.a_name = name;
1132 a.a_retval = retval;
1133 return (VCALL(vp, VOFFSET(vop_pathconf), &a));
1134 }
1135
1136 int vop_advlock_vp_offsets[] = {
1137 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp),
1138 VDESC_NO_OFFSET
1139 };
1140 struct vnodeop_desc vop_advlock_desc = {
1141 0,
1142 "vop_advlock",
1143 0,
1144 vop_advlock_vp_offsets,
1145 VDESC_NO_OFFSET,
1146 VDESC_NO_OFFSET,
1147 VDESC_NO_OFFSET,
1148 VDESC_NO_OFFSET,
1149 NULL,
1150 };
1151
VOP_ADVLOCK(vp,id,op,fl,flags)1152 int VOP_ADVLOCK(vp, id, op, fl, flags)
1153 struct vnode *vp;
1154 void *id;
1155 int op;
1156 struct flock *fl;
1157 int flags;
1158 {
1159 struct vop_advlock_args a;
1160 a.a_desc = VDESC(vop_advlock);
1161 a.a_vp = vp;
1162 a.a_id = id;
1163 a.a_op = op;
1164 a.a_fl = fl;
1165 a.a_flags = flags;
1166 return (VCALL(vp, VOFFSET(vop_advlock), &a));
1167 }
1168
1169 int vop_reallocblks_vp_offsets[] = {
1170 VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp),
1171 VDESC_NO_OFFSET
1172 };
1173 struct vnodeop_desc vop_reallocblks_desc = {
1174 0,
1175 "vop_reallocblks",
1176 0,
1177 vop_reallocblks_vp_offsets,
1178 VDESC_NO_OFFSET,
1179 VDESC_NO_OFFSET,
1180 VDESC_NO_OFFSET,
1181 VDESC_NO_OFFSET,
1182 NULL,
1183 };
1184
VOP_REALLOCBLKS(vp,buflist)1185 int VOP_REALLOCBLKS(vp, buflist)
1186 struct vnode *vp;
1187 struct cluster_save *buflist;
1188 {
1189 struct vop_reallocblks_args a;
1190 a.a_desc = VDESC(vop_reallocblks);
1191 a.a_vp = vp;
1192 #ifdef VFSDEBUG
1193 if ((vp->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp))
1194 panic("vop_reallocblks: vp");
1195 #endif
1196 a.a_buflist = buflist;
1197 return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
1198 }
1199
1200 /* Special cases: */
1201
1202 int vop_strategy_vp_offsets[] = {
1203 VDESC_NO_OFFSET
1204 };
1205 struct vnodeop_desc vop_strategy_desc = {
1206 0,
1207 "vop_strategy",
1208 0,
1209 vop_strategy_vp_offsets,
1210 VDESC_NO_OFFSET,
1211 VDESC_NO_OFFSET,
1212 VDESC_NO_OFFSET,
1213 VDESC_NO_OFFSET,
1214 NULL,
1215 };
1216
VOP_STRATEGY(bp)1217 int VOP_STRATEGY(bp)
1218 struct buf *bp;
1219 {
1220 struct vop_strategy_args a;
1221 a.a_desc = VDESC(vop_strategy);
1222 a.a_bp = bp;
1223 return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a));
1224 }
1225
1226 int vop_bwrite_vp_offsets[] = {
1227 VDESC_NO_OFFSET
1228 };
1229 struct vnodeop_desc vop_bwrite_desc = {
1230 0,
1231 "vop_bwrite",
1232 0,
1233 vop_bwrite_vp_offsets,
1234 VDESC_NO_OFFSET,
1235 VDESC_NO_OFFSET,
1236 VDESC_NO_OFFSET,
1237 VDESC_NO_OFFSET,
1238 NULL,
1239 };
1240
VOP_BWRITE(bp)1241 int VOP_BWRITE(bp)
1242 struct buf *bp;
1243 {
1244 struct vop_bwrite_args a;
1245 a.a_desc = VDESC(vop_bwrite);
1246 a.a_bp = bp;
1247 return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
1248 }
1249
1250 /* End of special cases. */
1251
1252 struct vnodeop_desc *vfs_op_descs[] = {
1253 &vop_default_desc, /* MUST BE FIRST */
1254 &vop_strategy_desc, /* XXX: SPECIAL CASE */
1255 &vop_bwrite_desc, /* XXX: SPECIAL CASE */
1256
1257 &vop_islocked_desc,
1258 &vop_lookup_desc,
1259 &vop_create_desc,
1260 &vop_mknod_desc,
1261 &vop_open_desc,
1262 &vop_close_desc,
1263 &vop_access_desc,
1264 &vop_getattr_desc,
1265 &vop_setattr_desc,
1266 &vop_read_desc,
1267 &vop_write_desc,
1268 &vop_lease_desc,
1269 &vop_ioctl_desc,
1270 &vop_poll_desc,
1271 &vop_kqfilter_desc,
1272 &vop_revoke_desc,
1273 &vop_fsync_desc,
1274 &vop_remove_desc,
1275 &vop_link_desc,
1276 &vop_rename_desc,
1277 &vop_mkdir_desc,
1278 &vop_rmdir_desc,
1279 &vop_symlink_desc,
1280 &vop_readdir_desc,
1281 &vop_readlink_desc,
1282 &vop_abortop_desc,
1283 &vop_inactive_desc,
1284 &vop_reclaim_desc,
1285 &vop_lock_desc,
1286 &vop_unlock_desc,
1287 &vop_bmap_desc,
1288 &vop_print_desc,
1289 &vop_pathconf_desc,
1290 &vop_advlock_desc,
1291 &vop_reallocblks_desc,
1292 NULL
1293 };
1294
1295