Annotation of src/sys/sys/vnode_if.h, Revision 1.24
1.20 wrstuden 1: /* $NetBSD$ */
1.9 thorpej 2:
1.1 cgd 3: /*
4: * Warning: This file is generated automatically.
5: * (Modifications made here may easily be lost!)
6: *
7: * Created from the file:
1.23 thorpej 8: * NetBSD: vnode_if.src,v 1.24 2000/05/13 23:43:07 perseant Exp
1.1 cgd 9: * by the script:
1.24 ! thorpej 10: * NetBSD: vnode_if.sh,v 1.21 2000/09/13 16:09:27 thorpej Exp
1.1 cgd 11: */
12:
13: /*
1.10 fvdl 14: * Copyright (c) 1992, 1993, 1994, 1995
1.1 cgd 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. All advertising materials mentioning features or use of this software
26: * must display the following acknowledgement:
27: * This product includes software developed by the University of
28: * California, Berkeley and its contributors.
29: * 4. Neither the name of the University nor the names of its contributors
30: * may be used to endorse or promote products derived from this software
31: * without specific prior written permission.
32: *
1.14 christos 33: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
1.1 cgd 34: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
35: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
37: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
39: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
41: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
42: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43: * SUCH DAMAGE.
44: */
45:
1.4 mikel 46: #ifndef _SYS_VNODE_IF_H_
47: #define _SYS_VNODE_IF_H_
1.24 ! thorpej 48:
! 49: #ifdef _KERNEL
! 50: #ifdef _LKM
! 51: /* LKMs always use non-inlined vnode ops. */
! 52: #define VNODE_OP_NOINLINE
! 53: #else
! 54: #include "opt_vnode_op_noinline.h"
! 55: #endif
! 56: #endif /* _KERNEL */
1.4 mikel 57:
1.1 cgd 58: extern struct vnodeop_desc vop_default_desc;
59:
60:
61: struct vop_lookup_args {
62: struct vnodeop_desc *a_desc;
63: struct vnode *a_dvp;
64: struct vnode **a_vpp;
65: struct componentname *a_cnp;
66: };
67: extern struct vnodeop_desc vop_lookup_desc;
1.23 thorpej 68: #ifndef VNODE_OP_NOINLINE
69: static __inline
70: #endif
71: int VOP_LOOKUP(struct vnode *, struct vnode **, struct componentname *)
72: #ifndef VNODE_OP_NOINLINE
73: __attribute__((__unused__))
74: #endif
75: ;
76: #ifndef VNODE_OP_NOINLINE
1.1 cgd 77: static __inline int VOP_LOOKUP(dvp, vpp, cnp)
78: struct vnode *dvp;
79: struct vnode **vpp;
80: struct componentname *cnp;
81: {
82: struct vop_lookup_args a;
83: a.a_desc = VDESC(vop_lookup);
84: a.a_dvp = dvp;
85: a.a_vpp = vpp;
86: a.a_cnp = cnp;
87: return (VCALL(dvp, VOFFSET(vop_lookup), &a));
88: }
1.23 thorpej 89: #endif
1.1 cgd 90:
91: struct vop_create_args {
92: struct vnodeop_desc *a_desc;
93: struct vnode *a_dvp;
94: struct vnode **a_vpp;
95: struct componentname *a_cnp;
96: struct vattr *a_vap;
97: };
98: extern struct vnodeop_desc vop_create_desc;
1.23 thorpej 99: #ifndef VNODE_OP_NOINLINE
100: static __inline
101: #endif
102: int VOP_CREATE(struct vnode *, struct vnode **, struct componentname *,
103: struct vattr *)
104: #ifndef VNODE_OP_NOINLINE
105: __attribute__((__unused__))
106: #endif
107: ;
108: #ifndef VNODE_OP_NOINLINE
1.1 cgd 109: static __inline int VOP_CREATE(dvp, vpp, cnp, vap)
110: struct vnode *dvp;
111: struct vnode **vpp;
112: struct componentname *cnp;
113: struct vattr *vap;
114: {
115: struct vop_create_args a;
116: a.a_desc = VDESC(vop_create);
117: a.a_dvp = dvp;
118: a.a_vpp = vpp;
119: a.a_cnp = cnp;
120: a.a_vap = vap;
121: return (VCALL(dvp, VOFFSET(vop_create), &a));
122: }
1.23 thorpej 123: #endif
1.1 cgd 124:
125: struct vop_mknod_args {
126: struct vnodeop_desc *a_desc;
127: struct vnode *a_dvp;
128: struct vnode **a_vpp;
129: struct componentname *a_cnp;
130: struct vattr *a_vap;
131: };
132: extern struct vnodeop_desc vop_mknod_desc;
1.23 thorpej 133: #ifndef VNODE_OP_NOINLINE
134: static __inline
135: #endif
136: int VOP_MKNOD(struct vnode *, struct vnode **, struct componentname *,
137: struct vattr *)
138: #ifndef VNODE_OP_NOINLINE
139: __attribute__((__unused__))
140: #endif
141: ;
142: #ifndef VNODE_OP_NOINLINE
1.1 cgd 143: static __inline int VOP_MKNOD(dvp, vpp, cnp, vap)
144: struct vnode *dvp;
145: struct vnode **vpp;
146: struct componentname *cnp;
147: struct vattr *vap;
148: {
149: struct vop_mknod_args a;
150: a.a_desc = VDESC(vop_mknod);
151: a.a_dvp = dvp;
152: a.a_vpp = vpp;
153: a.a_cnp = cnp;
154: a.a_vap = vap;
155: return (VCALL(dvp, VOFFSET(vop_mknod), &a));
156: }
1.23 thorpej 157: #endif
1.1 cgd 158:
159: struct vop_open_args {
160: struct vnodeop_desc *a_desc;
161: struct vnode *a_vp;
162: int a_mode;
163: struct ucred *a_cred;
164: struct proc *a_p;
165: };
166: extern struct vnodeop_desc vop_open_desc;
1.23 thorpej 167: #ifndef VNODE_OP_NOINLINE
168: static __inline
169: #endif
170: int VOP_OPEN(struct vnode *, int, struct ucred *, struct proc *)
171: #ifndef VNODE_OP_NOINLINE
172: __attribute__((__unused__))
173: #endif
174: ;
175: #ifndef VNODE_OP_NOINLINE
1.1 cgd 176: static __inline int VOP_OPEN(vp, mode, cred, p)
177: struct vnode *vp;
178: int mode;
179: struct ucred *cred;
180: struct proc *p;
181: {
182: struct vop_open_args a;
183: a.a_desc = VDESC(vop_open);
184: a.a_vp = vp;
185: a.a_mode = mode;
186: a.a_cred = cred;
187: a.a_p = p;
188: return (VCALL(vp, VOFFSET(vop_open), &a));
189: }
1.23 thorpej 190: #endif
1.1 cgd 191:
192: struct vop_close_args {
193: struct vnodeop_desc *a_desc;
194: struct vnode *a_vp;
195: int a_fflag;
196: struct ucred *a_cred;
197: struct proc *a_p;
198: };
199: extern struct vnodeop_desc vop_close_desc;
1.23 thorpej 200: #ifndef VNODE_OP_NOINLINE
201: static __inline
202: #endif
203: int VOP_CLOSE(struct vnode *, int, struct ucred *, struct proc *)
204: #ifndef VNODE_OP_NOINLINE
205: __attribute__((__unused__))
206: #endif
207: ;
208: #ifndef VNODE_OP_NOINLINE
1.1 cgd 209: static __inline int VOP_CLOSE(vp, fflag, cred, p)
210: struct vnode *vp;
211: int fflag;
212: struct ucred *cred;
213: struct proc *p;
214: {
215: struct vop_close_args a;
216: a.a_desc = VDESC(vop_close);
217: a.a_vp = vp;
218: a.a_fflag = fflag;
219: a.a_cred = cred;
220: a.a_p = p;
221: return (VCALL(vp, VOFFSET(vop_close), &a));
222: }
1.23 thorpej 223: #endif
1.1 cgd 224:
225: struct vop_access_args {
226: struct vnodeop_desc *a_desc;
227: struct vnode *a_vp;
228: int a_mode;
229: struct ucred *a_cred;
230: struct proc *a_p;
231: };
232: extern struct vnodeop_desc vop_access_desc;
1.23 thorpej 233: #ifndef VNODE_OP_NOINLINE
234: static __inline
235: #endif
236: int VOP_ACCESS(struct vnode *, int, struct ucred *, struct proc *)
237: #ifndef VNODE_OP_NOINLINE
238: __attribute__((__unused__))
239: #endif
240: ;
241: #ifndef VNODE_OP_NOINLINE
1.1 cgd 242: static __inline int VOP_ACCESS(vp, mode, cred, p)
243: struct vnode *vp;
244: int mode;
245: struct ucred *cred;
246: struct proc *p;
247: {
248: struct vop_access_args a;
249: a.a_desc = VDESC(vop_access);
250: a.a_vp = vp;
251: a.a_mode = mode;
252: a.a_cred = cred;
253: a.a_p = p;
254: return (VCALL(vp, VOFFSET(vop_access), &a));
255: }
1.23 thorpej 256: #endif
1.1 cgd 257:
258: struct vop_getattr_args {
259: struct vnodeop_desc *a_desc;
260: struct vnode *a_vp;
261: struct vattr *a_vap;
262: struct ucred *a_cred;
263: struct proc *a_p;
264: };
265: extern struct vnodeop_desc vop_getattr_desc;
1.23 thorpej 266: #ifndef VNODE_OP_NOINLINE
267: static __inline
268: #endif
269: int VOP_GETATTR(struct vnode *, struct vattr *, struct ucred *, struct proc *)
270: #ifndef VNODE_OP_NOINLINE
271: __attribute__((__unused__))
272: #endif
273: ;
274: #ifndef VNODE_OP_NOINLINE
1.1 cgd 275: static __inline int VOP_GETATTR(vp, vap, cred, p)
276: struct vnode *vp;
277: struct vattr *vap;
278: struct ucred *cred;
279: struct proc *p;
280: {
281: struct vop_getattr_args a;
282: a.a_desc = VDESC(vop_getattr);
283: a.a_vp = vp;
284: a.a_vap = vap;
285: a.a_cred = cred;
286: a.a_p = p;
287: return (VCALL(vp, VOFFSET(vop_getattr), &a));
288: }
1.23 thorpej 289: #endif
1.1 cgd 290:
291: struct vop_setattr_args {
292: struct vnodeop_desc *a_desc;
293: struct vnode *a_vp;
294: struct vattr *a_vap;
295: struct ucred *a_cred;
296: struct proc *a_p;
297: };
298: extern struct vnodeop_desc vop_setattr_desc;
1.23 thorpej 299: #ifndef VNODE_OP_NOINLINE
300: static __inline
301: #endif
302: int VOP_SETATTR(struct vnode *, struct vattr *, struct ucred *, struct proc *)
303: #ifndef VNODE_OP_NOINLINE
304: __attribute__((__unused__))
305: #endif
306: ;
307: #ifndef VNODE_OP_NOINLINE
1.1 cgd 308: static __inline int VOP_SETATTR(vp, vap, cred, p)
309: struct vnode *vp;
310: struct vattr *vap;
311: struct ucred *cred;
312: struct proc *p;
313: {
314: struct vop_setattr_args a;
315: a.a_desc = VDESC(vop_setattr);
316: a.a_vp = vp;
317: a.a_vap = vap;
318: a.a_cred = cred;
319: a.a_p = p;
320: return (VCALL(vp, VOFFSET(vop_setattr), &a));
321: }
1.23 thorpej 322: #endif
1.1 cgd 323:
324: struct vop_read_args {
325: struct vnodeop_desc *a_desc;
326: struct vnode *a_vp;
327: struct uio *a_uio;
328: int a_ioflag;
329: struct ucred *a_cred;
330: };
331: extern struct vnodeop_desc vop_read_desc;
1.23 thorpej 332: #ifndef VNODE_OP_NOINLINE
333: static __inline
334: #endif
335: int VOP_READ(struct vnode *, struct uio *, int, struct ucred *)
336: #ifndef VNODE_OP_NOINLINE
337: __attribute__((__unused__))
338: #endif
339: ;
340: #ifndef VNODE_OP_NOINLINE
1.1 cgd 341: static __inline int VOP_READ(vp, uio, ioflag, cred)
342: struct vnode *vp;
343: struct uio *uio;
344: int ioflag;
345: struct ucred *cred;
346: {
347: struct vop_read_args a;
348: a.a_desc = VDESC(vop_read);
349: a.a_vp = vp;
350: a.a_uio = uio;
351: a.a_ioflag = ioflag;
352: a.a_cred = cred;
353: return (VCALL(vp, VOFFSET(vop_read), &a));
354: }
1.23 thorpej 355: #endif
1.1 cgd 356:
357: struct vop_write_args {
358: struct vnodeop_desc *a_desc;
359: struct vnode *a_vp;
360: struct uio *a_uio;
361: int a_ioflag;
362: struct ucred *a_cred;
363: };
364: extern struct vnodeop_desc vop_write_desc;
1.23 thorpej 365: #ifndef VNODE_OP_NOINLINE
366: static __inline
367: #endif
368: int VOP_WRITE(struct vnode *, struct uio *, int, struct ucred *)
369: #ifndef VNODE_OP_NOINLINE
370: __attribute__((__unused__))
371: #endif
372: ;
373: #ifndef VNODE_OP_NOINLINE
1.1 cgd 374: static __inline int VOP_WRITE(vp, uio, ioflag, cred)
375: struct vnode *vp;
376: struct uio *uio;
377: int ioflag;
378: struct ucred *cred;
379: {
380: struct vop_write_args a;
381: a.a_desc = VDESC(vop_write);
382: a.a_vp = vp;
383: a.a_uio = uio;
384: a.a_ioflag = ioflag;
385: a.a_cred = cred;
386: return (VCALL(vp, VOFFSET(vop_write), &a));
387: }
1.23 thorpej 388: #endif
1.1 cgd 389:
390: struct vop_ioctl_args {
391: struct vnodeop_desc *a_desc;
392: struct vnode *a_vp;
393: u_long a_command;
394: caddr_t a_data;
395: int a_fflag;
396: struct ucred *a_cred;
397: struct proc *a_p;
398: };
399: extern struct vnodeop_desc vop_ioctl_desc;
1.23 thorpej 400: #ifndef VNODE_OP_NOINLINE
401: static __inline
402: #endif
403: int VOP_IOCTL(struct vnode *, u_long, caddr_t, int, struct ucred *,
404: struct proc *)
405: #ifndef VNODE_OP_NOINLINE
406: __attribute__((__unused__))
407: #endif
408: ;
409: #ifndef VNODE_OP_NOINLINE
1.1 cgd 410: static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p)
411: struct vnode *vp;
412: u_long command;
413: caddr_t data;
414: int fflag;
415: struct ucred *cred;
416: struct proc *p;
417: {
418: struct vop_ioctl_args a;
419: a.a_desc = VDESC(vop_ioctl);
420: a.a_vp = vp;
421: a.a_command = command;
422: a.a_data = data;
423: a.a_fflag = fflag;
424: a.a_cred = cred;
425: a.a_p = p;
426: return (VCALL(vp, VOFFSET(vop_ioctl), &a));
1.18 wrstuden 427: }
1.23 thorpej 428: #endif
1.18 wrstuden 429:
430: struct vop_fcntl_args {
431: struct vnodeop_desc *a_desc;
432: struct vnode *a_vp;
433: u_int a_command;
434: caddr_t a_data;
435: int a_fflag;
436: struct ucred *a_cred;
437: struct proc *a_p;
438: };
439: extern struct vnodeop_desc vop_fcntl_desc;
1.23 thorpej 440: #ifndef VNODE_OP_NOINLINE
441: static __inline
442: #endif
443: int VOP_FCNTL(struct vnode *, u_int, caddr_t, int, struct ucred *,
444: struct proc *)
445: #ifndef VNODE_OP_NOINLINE
446: __attribute__((__unused__))
447: #endif
448: ;
449: #ifndef VNODE_OP_NOINLINE
1.18 wrstuden 450: static __inline int VOP_FCNTL(vp, command, data, fflag, cred, p)
451: struct vnode *vp;
452: u_int command;
453: caddr_t data;
454: int fflag;
455: struct ucred *cred;
456: struct proc *p;
457: {
458: struct vop_fcntl_args a;
459: a.a_desc = VDESC(vop_fcntl);
460: a.a_vp = vp;
461: a.a_command = command;
462: a.a_data = data;
463: a.a_fflag = fflag;
464: a.a_cred = cred;
465: a.a_p = p;
466: return (VCALL(vp, VOFFSET(vop_fcntl), &a));
1.1 cgd 467: }
1.23 thorpej 468: #endif
1.1 cgd 469:
1.3 mycroft 470: struct vop_poll_args {
1.1 cgd 471: struct vnodeop_desc *a_desc;
472: struct vnode *a_vp;
1.3 mycroft 473: int a_events;
1.1 cgd 474: struct proc *a_p;
475: };
1.3 mycroft 476: extern struct vnodeop_desc vop_poll_desc;
1.23 thorpej 477: #ifndef VNODE_OP_NOINLINE
478: static __inline
479: #endif
480: int VOP_POLL(struct vnode *, int, struct proc *)
481: #ifndef VNODE_OP_NOINLINE
482: __attribute__((__unused__))
483: #endif
484: ;
485: #ifndef VNODE_OP_NOINLINE
1.3 mycroft 486: static __inline int VOP_POLL(vp, events, p)
1.1 cgd 487: struct vnode *vp;
1.3 mycroft 488: int events;
1.1 cgd 489: struct proc *p;
490: {
1.3 mycroft 491: struct vop_poll_args a;
492: a.a_desc = VDESC(vop_poll);
1.1 cgd 493: a.a_vp = vp;
1.3 mycroft 494: a.a_events = events;
1.1 cgd 495: a.a_p = p;
1.3 mycroft 496: return (VCALL(vp, VOFFSET(vop_poll), &a));
1.1 cgd 497: }
1.23 thorpej 498: #endif
1.1 cgd 499:
1.10 fvdl 500: struct vop_revoke_args {
501: struct vnodeop_desc *a_desc;
502: struct vnode *a_vp;
503: int a_flags;
504: };
505: extern struct vnodeop_desc vop_revoke_desc;
1.23 thorpej 506: #ifndef VNODE_OP_NOINLINE
507: static __inline
508: #endif
509: int VOP_REVOKE(struct vnode *, int)
510: #ifndef VNODE_OP_NOINLINE
511: __attribute__((__unused__))
512: #endif
513: ;
514: #ifndef VNODE_OP_NOINLINE
1.10 fvdl 515: static __inline int VOP_REVOKE(vp, flags)
516: struct vnode *vp;
517: int flags;
518: {
519: struct vop_revoke_args a;
520: a.a_desc = VDESC(vop_revoke);
521: a.a_vp = vp;
522: a.a_flags = flags;
523: return (VCALL(vp, VOFFSET(vop_revoke), &a));
524: }
1.23 thorpej 525: #endif
1.10 fvdl 526:
1.1 cgd 527: struct vop_mmap_args {
528: struct vnodeop_desc *a_desc;
529: struct vnode *a_vp;
530: int a_fflags;
531: struct ucred *a_cred;
532: struct proc *a_p;
533: };
534: extern struct vnodeop_desc vop_mmap_desc;
1.23 thorpej 535: #ifndef VNODE_OP_NOINLINE
536: static __inline
537: #endif
538: int VOP_MMAP(struct vnode *, int, struct ucred *, struct proc *)
539: #ifndef VNODE_OP_NOINLINE
540: __attribute__((__unused__))
541: #endif
542: ;
543: #ifndef VNODE_OP_NOINLINE
1.1 cgd 544: static __inline int VOP_MMAP(vp, fflags, cred, p)
545: struct vnode *vp;
546: int fflags;
547: struct ucred *cred;
548: struct proc *p;
549: {
550: struct vop_mmap_args a;
551: a.a_desc = VDESC(vop_mmap);
552: a.a_vp = vp;
553: a.a_fflags = fflags;
554: a.a_cred = cred;
555: a.a_p = p;
556: return (VCALL(vp, VOFFSET(vop_mmap), &a));
557: }
1.23 thorpej 558: #endif
1.1 cgd 559:
560: struct vop_fsync_args {
561: struct vnodeop_desc *a_desc;
562: struct vnode *a_vp;
563: struct ucred *a_cred;
1.12 kleink 564: int a_flags;
1.1 cgd 565: struct proc *a_p;
566: };
567: extern struct vnodeop_desc vop_fsync_desc;
1.23 thorpej 568: #ifndef VNODE_OP_NOINLINE
569: static __inline
570: #endif
571: int VOP_FSYNC(struct vnode *, struct ucred *, int, struct proc *)
572: #ifndef VNODE_OP_NOINLINE
573: __attribute__((__unused__))
574: #endif
575: ;
576: #ifndef VNODE_OP_NOINLINE
1.12 kleink 577: static __inline int VOP_FSYNC(vp, cred, flags, p)
1.1 cgd 578: struct vnode *vp;
579: struct ucred *cred;
1.12 kleink 580: int flags;
1.1 cgd 581: struct proc *p;
582: {
583: struct vop_fsync_args a;
584: a.a_desc = VDESC(vop_fsync);
585: a.a_vp = vp;
586: a.a_cred = cred;
1.12 kleink 587: a.a_flags = flags;
1.1 cgd 588: a.a_p = p;
589: return (VCALL(vp, VOFFSET(vop_fsync), &a));
590: }
1.23 thorpej 591: #endif
1.1 cgd 592:
593: struct vop_seek_args {
594: struct vnodeop_desc *a_desc;
595: struct vnode *a_vp;
596: off_t a_oldoff;
597: off_t a_newoff;
598: struct ucred *a_cred;
599: };
600: extern struct vnodeop_desc vop_seek_desc;
1.23 thorpej 601: #ifndef VNODE_OP_NOINLINE
602: static __inline
603: #endif
604: int VOP_SEEK(struct vnode *, off_t, off_t, struct ucred *)
605: #ifndef VNODE_OP_NOINLINE
606: __attribute__((__unused__))
607: #endif
608: ;
609: #ifndef VNODE_OP_NOINLINE
1.1 cgd 610: static __inline int VOP_SEEK(vp, oldoff, newoff, cred)
611: struct vnode *vp;
612: off_t oldoff;
613: off_t newoff;
614: struct ucred *cred;
615: {
616: struct vop_seek_args a;
617: a.a_desc = VDESC(vop_seek);
618: a.a_vp = vp;
619: a.a_oldoff = oldoff;
620: a.a_newoff = newoff;
621: a.a_cred = cred;
622: return (VCALL(vp, VOFFSET(vop_seek), &a));
623: }
1.23 thorpej 624: #endif
1.1 cgd 625:
626: struct vop_remove_args {
627: struct vnodeop_desc *a_desc;
628: struct vnode *a_dvp;
629: struct vnode *a_vp;
630: struct componentname *a_cnp;
631: };
632: extern struct vnodeop_desc vop_remove_desc;
1.23 thorpej 633: #ifndef VNODE_OP_NOINLINE
634: static __inline
635: #endif
636: int VOP_REMOVE(struct vnode *, struct vnode *, struct componentname *)
637: #ifndef VNODE_OP_NOINLINE
638: __attribute__((__unused__))
639: #endif
640: ;
641: #ifndef VNODE_OP_NOINLINE
1.1 cgd 642: static __inline int VOP_REMOVE(dvp, vp, cnp)
643: struct vnode *dvp;
644: struct vnode *vp;
645: struct componentname *cnp;
646: {
647: struct vop_remove_args a;
648: a.a_desc = VDESC(vop_remove);
649: a.a_dvp = dvp;
650: a.a_vp = vp;
651: a.a_cnp = cnp;
652: return (VCALL(dvp, VOFFSET(vop_remove), &a));
653: }
1.23 thorpej 654: #endif
1.1 cgd 655:
656: struct vop_link_args {
657: struct vnodeop_desc *a_desc;
658: struct vnode *a_dvp;
659: struct vnode *a_vp;
660: struct componentname *a_cnp;
661: };
662: extern struct vnodeop_desc vop_link_desc;
1.23 thorpej 663: #ifndef VNODE_OP_NOINLINE
664: static __inline
665: #endif
666: int VOP_LINK(struct vnode *, struct vnode *, struct componentname *)
667: #ifndef VNODE_OP_NOINLINE
668: __attribute__((__unused__))
669: #endif
670: ;
671: #ifndef VNODE_OP_NOINLINE
1.1 cgd 672: static __inline int VOP_LINK(dvp, vp, cnp)
673: struct vnode *dvp;
674: struct vnode *vp;
675: struct componentname *cnp;
676: {
677: struct vop_link_args a;
678: a.a_desc = VDESC(vop_link);
679: a.a_dvp = dvp;
680: a.a_vp = vp;
681: a.a_cnp = cnp;
682: return (VCALL(dvp, VOFFSET(vop_link), &a));
683: }
1.23 thorpej 684: #endif
1.1 cgd 685:
686: struct vop_rename_args {
687: struct vnodeop_desc *a_desc;
688: struct vnode *a_fdvp;
689: struct vnode *a_fvp;
690: struct componentname *a_fcnp;
691: struct vnode *a_tdvp;
692: struct vnode *a_tvp;
693: struct componentname *a_tcnp;
694: };
695: extern struct vnodeop_desc vop_rename_desc;
1.23 thorpej 696: #ifndef VNODE_OP_NOINLINE
697: static __inline
698: #endif
699: int VOP_RENAME(struct vnode *, struct vnode *, struct componentname *,
700: struct vnode *, struct vnode *, struct componentname *)
701: #ifndef VNODE_OP_NOINLINE
702: __attribute__((__unused__))
703: #endif
704: ;
705: #ifndef VNODE_OP_NOINLINE
1.1 cgd 706: static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
707: struct vnode *fdvp;
708: struct vnode *fvp;
709: struct componentname *fcnp;
710: struct vnode *tdvp;
711: struct vnode *tvp;
712: struct componentname *tcnp;
713: {
714: struct vop_rename_args a;
715: a.a_desc = VDESC(vop_rename);
716: a.a_fdvp = fdvp;
717: a.a_fvp = fvp;
718: a.a_fcnp = fcnp;
719: a.a_tdvp = tdvp;
720: a.a_tvp = tvp;
721: a.a_tcnp = tcnp;
722: return (VCALL(fdvp, VOFFSET(vop_rename), &a));
723: }
1.23 thorpej 724: #endif
1.1 cgd 725:
726: struct vop_mkdir_args {
727: struct vnodeop_desc *a_desc;
728: struct vnode *a_dvp;
729: struct vnode **a_vpp;
730: struct componentname *a_cnp;
731: struct vattr *a_vap;
732: };
733: extern struct vnodeop_desc vop_mkdir_desc;
1.23 thorpej 734: #ifndef VNODE_OP_NOINLINE
735: static __inline
736: #endif
737: int VOP_MKDIR(struct vnode *, struct vnode **, struct componentname *,
738: struct vattr *)
739: #ifndef VNODE_OP_NOINLINE
740: __attribute__((__unused__))
741: #endif
742: ;
743: #ifndef VNODE_OP_NOINLINE
1.1 cgd 744: static __inline int VOP_MKDIR(dvp, vpp, cnp, vap)
745: struct vnode *dvp;
746: struct vnode **vpp;
747: struct componentname *cnp;
748: struct vattr *vap;
749: {
750: struct vop_mkdir_args a;
751: a.a_desc = VDESC(vop_mkdir);
752: a.a_dvp = dvp;
753: a.a_vpp = vpp;
754: a.a_cnp = cnp;
755: a.a_vap = vap;
756: return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
757: }
1.23 thorpej 758: #endif
1.1 cgd 759:
760: struct vop_rmdir_args {
761: struct vnodeop_desc *a_desc;
762: struct vnode *a_dvp;
763: struct vnode *a_vp;
764: struct componentname *a_cnp;
765: };
766: extern struct vnodeop_desc vop_rmdir_desc;
1.23 thorpej 767: #ifndef VNODE_OP_NOINLINE
768: static __inline
769: #endif
770: int VOP_RMDIR(struct vnode *, struct vnode *, struct componentname *)
771: #ifndef VNODE_OP_NOINLINE
772: __attribute__((__unused__))
773: #endif
774: ;
775: #ifndef VNODE_OP_NOINLINE
1.1 cgd 776: static __inline int VOP_RMDIR(dvp, vp, cnp)
777: struct vnode *dvp;
778: struct vnode *vp;
779: struct componentname *cnp;
780: {
781: struct vop_rmdir_args a;
782: a.a_desc = VDESC(vop_rmdir);
783: a.a_dvp = dvp;
784: a.a_vp = vp;
785: a.a_cnp = cnp;
786: return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
787: }
1.23 thorpej 788: #endif
1.1 cgd 789:
790: struct vop_symlink_args {
791: struct vnodeop_desc *a_desc;
792: struct vnode *a_dvp;
793: struct vnode **a_vpp;
794: struct componentname *a_cnp;
795: struct vattr *a_vap;
796: char *a_target;
797: };
798: extern struct vnodeop_desc vop_symlink_desc;
1.23 thorpej 799: #ifndef VNODE_OP_NOINLINE
800: static __inline
801: #endif
802: int VOP_SYMLINK(struct vnode *, struct vnode **, struct componentname *,
803: struct vattr *, char *)
804: #ifndef VNODE_OP_NOINLINE
805: __attribute__((__unused__))
806: #endif
807: ;
808: #ifndef VNODE_OP_NOINLINE
1.1 cgd 809: static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target)
810: struct vnode *dvp;
811: struct vnode **vpp;
812: struct componentname *cnp;
813: struct vattr *vap;
814: char *target;
815: {
816: struct vop_symlink_args a;
817: a.a_desc = VDESC(vop_symlink);
818: a.a_dvp = dvp;
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: }
1.23 thorpej 825: #endif
1.1 cgd 826:
827: struct vop_readdir_args {
828: struct vnodeop_desc *a_desc;
829: struct vnode *a_vp;
830: struct uio *a_uio;
831: struct ucred *a_cred;
832: int *a_eofflag;
1.10 fvdl 833: off_t **a_cookies;
834: int *a_ncookies;
1.1 cgd 835: };
836: extern struct vnodeop_desc vop_readdir_desc;
1.23 thorpej 837: #ifndef VNODE_OP_NOINLINE
838: static __inline
839: #endif
840: int VOP_READDIR(struct vnode *, struct uio *, struct ucred *, int *,
841: off_t **, int *)
842: #ifndef VNODE_OP_NOINLINE
843: __attribute__((__unused__))
844: #endif
845: ;
846: #ifndef VNODE_OP_NOINLINE
1.1 cgd 847: static __inline int VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies)
848: struct vnode *vp;
849: struct uio *uio;
850: struct ucred *cred;
851: int *eofflag;
1.10 fvdl 852: off_t **cookies;
853: int *ncookies;
1.1 cgd 854: {
855: struct vop_readdir_args a;
856: a.a_desc = VDESC(vop_readdir);
857: a.a_vp = vp;
858: a.a_uio = uio;
859: a.a_cred = cred;
860: a.a_eofflag = eofflag;
861: a.a_cookies = cookies;
862: a.a_ncookies = ncookies;
863: return (VCALL(vp, VOFFSET(vop_readdir), &a));
864: }
1.23 thorpej 865: #endif
1.1 cgd 866:
867: struct vop_readlink_args {
868: struct vnodeop_desc *a_desc;
869: struct vnode *a_vp;
870: struct uio *a_uio;
871: struct ucred *a_cred;
872: };
873: extern struct vnodeop_desc vop_readlink_desc;
1.23 thorpej 874: #ifndef VNODE_OP_NOINLINE
875: static __inline
876: #endif
877: int VOP_READLINK(struct vnode *, struct uio *, struct ucred *)
878: #ifndef VNODE_OP_NOINLINE
879: __attribute__((__unused__))
880: #endif
881: ;
882: #ifndef VNODE_OP_NOINLINE
1.1 cgd 883: static __inline int VOP_READLINK(vp, uio, cred)
884: struct vnode *vp;
885: struct uio *uio;
886: struct ucred *cred;
887: {
888: struct vop_readlink_args a;
889: a.a_desc = VDESC(vop_readlink);
890: a.a_vp = vp;
891: a.a_uio = uio;
892: a.a_cred = cred;
893: return (VCALL(vp, VOFFSET(vop_readlink), &a));
894: }
1.23 thorpej 895: #endif
1.1 cgd 896:
897: struct vop_abortop_args {
898: struct vnodeop_desc *a_desc;
899: struct vnode *a_dvp;
900: struct componentname *a_cnp;
901: };
902: extern struct vnodeop_desc vop_abortop_desc;
1.23 thorpej 903: #ifndef VNODE_OP_NOINLINE
904: static __inline
905: #endif
906: int VOP_ABORTOP(struct vnode *, struct componentname *)
907: #ifndef VNODE_OP_NOINLINE
908: __attribute__((__unused__))
909: #endif
910: ;
911: #ifndef VNODE_OP_NOINLINE
1.1 cgd 912: static __inline int VOP_ABORTOP(dvp, cnp)
913: struct vnode *dvp;
914: struct componentname *cnp;
915: {
916: struct vop_abortop_args a;
917: a.a_desc = VDESC(vop_abortop);
918: a.a_dvp = dvp;
919: a.a_cnp = cnp;
920: return (VCALL(dvp, VOFFSET(vop_abortop), &a));
921: }
1.23 thorpej 922: #endif
1.1 cgd 923:
924: struct vop_inactive_args {
925: struct vnodeop_desc *a_desc;
926: struct vnode *a_vp;
1.10 fvdl 927: struct proc *a_p;
1.1 cgd 928: };
929: extern struct vnodeop_desc vop_inactive_desc;
1.23 thorpej 930: #ifndef VNODE_OP_NOINLINE
931: static __inline
932: #endif
933: int VOP_INACTIVE(struct vnode *, struct proc *)
934: #ifndef VNODE_OP_NOINLINE
935: __attribute__((__unused__))
936: #endif
937: ;
938: #ifndef VNODE_OP_NOINLINE
1.10 fvdl 939: static __inline int VOP_INACTIVE(vp, p)
1.1 cgd 940: struct vnode *vp;
1.10 fvdl 941: struct proc *p;
1.1 cgd 942: {
943: struct vop_inactive_args a;
944: a.a_desc = VDESC(vop_inactive);
945: a.a_vp = vp;
1.10 fvdl 946: a.a_p = p;
1.1 cgd 947: return (VCALL(vp, VOFFSET(vop_inactive), &a));
948: }
1.23 thorpej 949: #endif
1.1 cgd 950:
951: struct vop_reclaim_args {
952: struct vnodeop_desc *a_desc;
953: struct vnode *a_vp;
1.10 fvdl 954: struct proc *a_p;
1.1 cgd 955: };
956: extern struct vnodeop_desc vop_reclaim_desc;
1.23 thorpej 957: #ifndef VNODE_OP_NOINLINE
958: static __inline
959: #endif
960: int VOP_RECLAIM(struct vnode *, struct proc *)
961: #ifndef VNODE_OP_NOINLINE
962: __attribute__((__unused__))
963: #endif
964: ;
965: #ifndef VNODE_OP_NOINLINE
1.10 fvdl 966: static __inline int VOP_RECLAIM(vp, p)
1.1 cgd 967: struct vnode *vp;
1.10 fvdl 968: struct proc *p;
1.1 cgd 969: {
970: struct vop_reclaim_args a;
971: a.a_desc = VDESC(vop_reclaim);
972: a.a_vp = vp;
1.10 fvdl 973: a.a_p = p;
1.1 cgd 974: return (VCALL(vp, VOFFSET(vop_reclaim), &a));
975: }
1.23 thorpej 976: #endif
1.1 cgd 977:
978: struct vop_lock_args {
979: struct vnodeop_desc *a_desc;
980: struct vnode *a_vp;
1.10 fvdl 981: int a_flags;
1.1 cgd 982: };
983: extern struct vnodeop_desc vop_lock_desc;
1.23 thorpej 984: #ifndef VNODE_OP_NOINLINE
985: static __inline
986: #endif
987: int VOP_LOCK(struct vnode *, int)
988: #ifndef VNODE_OP_NOINLINE
989: __attribute__((__unused__))
990: #endif
991: ;
992: #ifndef VNODE_OP_NOINLINE
1.10 fvdl 993: static __inline int VOP_LOCK(vp, flags)
1.1 cgd 994: struct vnode *vp;
1.10 fvdl 995: int flags;
1.1 cgd 996: {
997: struct vop_lock_args a;
998: a.a_desc = VDESC(vop_lock);
999: a.a_vp = vp;
1.10 fvdl 1000: a.a_flags = flags;
1.1 cgd 1001: return (VCALL(vp, VOFFSET(vop_lock), &a));
1002: }
1.23 thorpej 1003: #endif
1.1 cgd 1004:
1005: struct vop_unlock_args {
1006: struct vnodeop_desc *a_desc;
1007: struct vnode *a_vp;
1.10 fvdl 1008: int a_flags;
1.1 cgd 1009: };
1010: extern struct vnodeop_desc vop_unlock_desc;
1.23 thorpej 1011: #ifndef VNODE_OP_NOINLINE
1012: static __inline
1013: #endif
1014: int VOP_UNLOCK(struct vnode *, int)
1015: #ifndef VNODE_OP_NOINLINE
1016: __attribute__((__unused__))
1017: #endif
1018: ;
1019: #ifndef VNODE_OP_NOINLINE
1.10 fvdl 1020: static __inline int VOP_UNLOCK(vp, flags)
1.1 cgd 1021: struct vnode *vp;
1.10 fvdl 1022: int flags;
1.1 cgd 1023: {
1024: struct vop_unlock_args a;
1025: a.a_desc = VDESC(vop_unlock);
1026: a.a_vp = vp;
1.10 fvdl 1027: a.a_flags = flags;
1.1 cgd 1028: return (VCALL(vp, VOFFSET(vop_unlock), &a));
1029: }
1.23 thorpej 1030: #endif
1.1 cgd 1031:
1032: struct vop_bmap_args {
1033: struct vnodeop_desc *a_desc;
1034: struct vnode *a_vp;
1035: daddr_t a_bn;
1036: struct vnode **a_vpp;
1037: daddr_t *a_bnp;
1038: int *a_runp;
1039: };
1040: extern struct vnodeop_desc vop_bmap_desc;
1.23 thorpej 1041: #ifndef VNODE_OP_NOINLINE
1042: static __inline
1043: #endif
1044: int VOP_BMAP(struct vnode *, daddr_t, struct vnode **, daddr_t *, int *)
1045: #ifndef VNODE_OP_NOINLINE
1046: __attribute__((__unused__))
1047: #endif
1048: ;
1049: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1050: static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp)
1051: struct vnode *vp;
1052: daddr_t bn;
1053: struct vnode **vpp;
1054: daddr_t *bnp;
1055: int *runp;
1056: {
1057: struct vop_bmap_args a;
1058: a.a_desc = VDESC(vop_bmap);
1059: a.a_vp = vp;
1060: a.a_bn = bn;
1061: a.a_vpp = vpp;
1062: a.a_bnp = bnp;
1063: a.a_runp = runp;
1064: return (VCALL(vp, VOFFSET(vop_bmap), &a));
1065: }
1.23 thorpej 1066: #endif
1.1 cgd 1067:
1068: struct vop_print_args {
1069: struct vnodeop_desc *a_desc;
1070: struct vnode *a_vp;
1071: };
1072: extern struct vnodeop_desc vop_print_desc;
1.23 thorpej 1073: #ifndef VNODE_OP_NOINLINE
1074: static __inline
1075: #endif
1076: int VOP_PRINT(struct vnode *)
1077: #ifndef VNODE_OP_NOINLINE
1078: __attribute__((__unused__))
1079: #endif
1080: ;
1081: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1082: static __inline int VOP_PRINT(vp)
1083: struct vnode *vp;
1084: {
1085: struct vop_print_args a;
1086: a.a_desc = VDESC(vop_print);
1087: a.a_vp = vp;
1088: return (VCALL(vp, VOFFSET(vop_print), &a));
1089: }
1.23 thorpej 1090: #endif
1.1 cgd 1091:
1092: struct vop_islocked_args {
1093: struct vnodeop_desc *a_desc;
1094: struct vnode *a_vp;
1095: };
1096: extern struct vnodeop_desc vop_islocked_desc;
1.23 thorpej 1097: #ifndef VNODE_OP_NOINLINE
1098: static __inline
1099: #endif
1100: int VOP_ISLOCKED(struct vnode *)
1101: #ifndef VNODE_OP_NOINLINE
1102: __attribute__((__unused__))
1103: #endif
1104: ;
1105: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1106: static __inline int VOP_ISLOCKED(vp)
1107: struct vnode *vp;
1108: {
1109: struct vop_islocked_args a;
1110: a.a_desc = VDESC(vop_islocked);
1111: a.a_vp = vp;
1112: return (VCALL(vp, VOFFSET(vop_islocked), &a));
1113: }
1.23 thorpej 1114: #endif
1.1 cgd 1115:
1116: struct vop_pathconf_args {
1117: struct vnodeop_desc *a_desc;
1118: struct vnode *a_vp;
1119: int a_name;
1120: register_t *a_retval;
1121: };
1122: extern struct vnodeop_desc vop_pathconf_desc;
1.23 thorpej 1123: #ifndef VNODE_OP_NOINLINE
1124: static __inline
1125: #endif
1126: int VOP_PATHCONF(struct vnode *, int, register_t *)
1127: #ifndef VNODE_OP_NOINLINE
1128: __attribute__((__unused__))
1129: #endif
1130: ;
1131: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1132: static __inline int VOP_PATHCONF(vp, name, retval)
1133: struct vnode *vp;
1134: int name;
1135: register_t *retval;
1136: {
1137: struct vop_pathconf_args a;
1138: a.a_desc = VDESC(vop_pathconf);
1139: a.a_vp = vp;
1140: a.a_name = name;
1141: a.a_retval = retval;
1142: return (VCALL(vp, VOFFSET(vop_pathconf), &a));
1143: }
1.23 thorpej 1144: #endif
1.1 cgd 1145:
1146: struct vop_advlock_args {
1147: struct vnodeop_desc *a_desc;
1148: struct vnode *a_vp;
1149: caddr_t a_id;
1150: int a_op;
1151: struct flock *a_fl;
1152: int a_flags;
1153: };
1154: extern struct vnodeop_desc vop_advlock_desc;
1.23 thorpej 1155: #ifndef VNODE_OP_NOINLINE
1156: static __inline
1157: #endif
1158: int VOP_ADVLOCK(struct vnode *, caddr_t, int, struct flock *, int)
1159: #ifndef VNODE_OP_NOINLINE
1160: __attribute__((__unused__))
1161: #endif
1162: ;
1163: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1164: static __inline int VOP_ADVLOCK(vp, id, op, fl, flags)
1165: struct vnode *vp;
1166: caddr_t id;
1167: int op;
1168: struct flock *fl;
1169: int flags;
1170: {
1171: struct vop_advlock_args a;
1172: a.a_desc = VDESC(vop_advlock);
1173: a.a_vp = vp;
1174: a.a_id = id;
1175: a.a_op = op;
1176: a.a_fl = fl;
1177: a.a_flags = flags;
1178: return (VCALL(vp, VOFFSET(vop_advlock), &a));
1179: }
1.23 thorpej 1180: #endif
1.1 cgd 1181:
1182: struct vop_blkatoff_args {
1183: struct vnodeop_desc *a_desc;
1184: struct vnode *a_vp;
1185: off_t a_offset;
1186: char **a_res;
1187: struct buf **a_bpp;
1188: };
1189: extern struct vnodeop_desc vop_blkatoff_desc;
1.23 thorpej 1190: #ifndef VNODE_OP_NOINLINE
1191: static __inline
1192: #endif
1193: int VOP_BLKATOFF(struct vnode *, off_t, char **, struct buf **)
1194: #ifndef VNODE_OP_NOINLINE
1195: __attribute__((__unused__))
1196: #endif
1197: ;
1198: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1199: static __inline int VOP_BLKATOFF(vp, offset, res, bpp)
1200: struct vnode *vp;
1201: off_t offset;
1202: char **res;
1203: struct buf **bpp;
1204: {
1205: struct vop_blkatoff_args a;
1206: a.a_desc = VDESC(vop_blkatoff);
1207: a.a_vp = vp;
1208: a.a_offset = offset;
1209: a.a_res = res;
1210: a.a_bpp = bpp;
1211: return (VCALL(vp, VOFFSET(vop_blkatoff), &a));
1212: }
1.23 thorpej 1213: #endif
1.1 cgd 1214:
1215: struct vop_valloc_args {
1216: struct vnodeop_desc *a_desc;
1217: struct vnode *a_pvp;
1218: int a_mode;
1219: struct ucred *a_cred;
1220: struct vnode **a_vpp;
1221: };
1222: extern struct vnodeop_desc vop_valloc_desc;
1.23 thorpej 1223: #ifndef VNODE_OP_NOINLINE
1224: static __inline
1225: #endif
1226: int VOP_VALLOC(struct vnode *, int, struct ucred *, struct vnode **)
1227: #ifndef VNODE_OP_NOINLINE
1228: __attribute__((__unused__))
1229: #endif
1230: ;
1231: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1232: static __inline int VOP_VALLOC(pvp, mode, cred, vpp)
1233: struct vnode *pvp;
1234: int mode;
1235: struct ucred *cred;
1236: struct vnode **vpp;
1237: {
1238: struct vop_valloc_args a;
1239: a.a_desc = VDESC(vop_valloc);
1240: a.a_pvp = pvp;
1241: a.a_mode = mode;
1242: a.a_cred = cred;
1243: a.a_vpp = vpp;
1244: return (VCALL(pvp, VOFFSET(vop_valloc), &a));
1.20 wrstuden 1245: }
1.23 thorpej 1246: #endif
1.20 wrstuden 1247:
1248: struct vop_balloc_args {
1249: struct vnodeop_desc *a_desc;
1250: struct vnode *a_vp;
1251: off_t a_startoffset;
1252: int a_size;
1253: struct ucred *a_cred;
1254: int a_flags;
1255: struct buf **a_bpp;
1256: };
1257: extern struct vnodeop_desc vop_balloc_desc;
1.23 thorpej 1258: #ifndef VNODE_OP_NOINLINE
1259: static __inline
1260: #endif
1261: int VOP_BALLOC(struct vnode *, off_t, int, struct ucred *, int, struct buf **)
1262: #ifndef VNODE_OP_NOINLINE
1263: __attribute__((__unused__))
1264: #endif
1265: ;
1266: #ifndef VNODE_OP_NOINLINE
1.20 wrstuden 1267: static __inline int VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
1268: struct vnode *vp;
1269: off_t startoffset;
1270: int size;
1271: struct ucred *cred;
1272: int flags;
1273: struct buf **bpp;
1274: {
1275: struct vop_balloc_args a;
1276: a.a_desc = VDESC(vop_balloc);
1277: a.a_vp = vp;
1278: a.a_startoffset = startoffset;
1279: a.a_size = size;
1280: a.a_cred = cred;
1281: a.a_flags = flags;
1282: a.a_bpp = bpp;
1283: return (VCALL(vp, VOFFSET(vop_balloc), &a));
1.1 cgd 1284: }
1.23 thorpej 1285: #endif
1.1 cgd 1286:
1287: struct vop_reallocblks_args {
1288: struct vnodeop_desc *a_desc;
1289: struct vnode *a_vp;
1290: struct cluster_save *a_buflist;
1291: };
1292: extern struct vnodeop_desc vop_reallocblks_desc;
1.23 thorpej 1293: #ifndef VNODE_OP_NOINLINE
1294: static __inline
1295: #endif
1296: int VOP_REALLOCBLKS(struct vnode *, struct cluster_save *)
1297: #ifndef VNODE_OP_NOINLINE
1298: __attribute__((__unused__))
1299: #endif
1300: ;
1301: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1302: static __inline int VOP_REALLOCBLKS(vp, buflist)
1303: struct vnode *vp;
1304: struct cluster_save *buflist;
1305: {
1306: struct vop_reallocblks_args a;
1307: a.a_desc = VDESC(vop_reallocblks);
1308: a.a_vp = vp;
1309: a.a_buflist = buflist;
1310: return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
1311: }
1.23 thorpej 1312: #endif
1.1 cgd 1313:
1314: struct vop_vfree_args {
1315: struct vnodeop_desc *a_desc;
1316: struct vnode *a_pvp;
1317: ino_t a_ino;
1318: int a_mode;
1319: };
1320: extern struct vnodeop_desc vop_vfree_desc;
1.23 thorpej 1321: #ifndef VNODE_OP_NOINLINE
1322: static __inline
1323: #endif
1324: int VOP_VFREE(struct vnode *, ino_t, int)
1325: #ifndef VNODE_OP_NOINLINE
1326: __attribute__((__unused__))
1327: #endif
1328: ;
1329: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1330: static __inline int VOP_VFREE(pvp, ino, mode)
1331: struct vnode *pvp;
1332: ino_t ino;
1333: int mode;
1334: {
1335: struct vop_vfree_args a;
1336: a.a_desc = VDESC(vop_vfree);
1337: a.a_pvp = pvp;
1338: a.a_ino = ino;
1339: a.a_mode = mode;
1340: return (VCALL(pvp, VOFFSET(vop_vfree), &a));
1341: }
1.23 thorpej 1342: #endif
1.1 cgd 1343:
1344: struct vop_truncate_args {
1345: struct vnodeop_desc *a_desc;
1346: struct vnode *a_vp;
1347: off_t a_length;
1348: int a_flags;
1349: struct ucred *a_cred;
1350: struct proc *a_p;
1351: };
1352: extern struct vnodeop_desc vop_truncate_desc;
1.23 thorpej 1353: #ifndef VNODE_OP_NOINLINE
1354: static __inline
1355: #endif
1356: int VOP_TRUNCATE(struct vnode *, off_t, int, struct ucred *, struct proc *)
1357: #ifndef VNODE_OP_NOINLINE
1358: __attribute__((__unused__))
1359: #endif
1360: ;
1361: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1362: static __inline int VOP_TRUNCATE(vp, length, flags, cred, p)
1363: struct vnode *vp;
1364: off_t length;
1365: int flags;
1366: struct ucred *cred;
1367: struct proc *p;
1368: {
1369: struct vop_truncate_args a;
1370: a.a_desc = VDESC(vop_truncate);
1371: a.a_vp = vp;
1372: a.a_length = length;
1373: a.a_flags = flags;
1374: a.a_cred = cred;
1375: a.a_p = p;
1376: return (VCALL(vp, VOFFSET(vop_truncate), &a));
1377: }
1.23 thorpej 1378: #endif
1.1 cgd 1379:
1380: struct vop_update_args {
1381: struct vnodeop_desc *a_desc;
1382: struct vnode *a_vp;
1.2 mycroft 1383: struct timespec *a_access;
1384: struct timespec *a_modify;
1.22 perseant 1385: int a_flags;
1.1 cgd 1386: };
1387: extern struct vnodeop_desc vop_update_desc;
1.23 thorpej 1388: #ifndef VNODE_OP_NOINLINE
1389: static __inline
1390: #endif
1391: int VOP_UPDATE(struct vnode *, struct timespec *, struct timespec *, int)
1392: #ifndef VNODE_OP_NOINLINE
1393: __attribute__((__unused__))
1394: #endif
1395: ;
1396: #ifndef VNODE_OP_NOINLINE
1.22 perseant 1397: static __inline int VOP_UPDATE(vp, access, modify, flags)
1.1 cgd 1398: struct vnode *vp;
1.2 mycroft 1399: struct timespec *access;
1400: struct timespec *modify;
1.22 perseant 1401: int flags;
1.1 cgd 1402: {
1403: struct vop_update_args a;
1404: a.a_desc = VDESC(vop_update);
1405: a.a_vp = vp;
1406: a.a_access = access;
1407: a.a_modify = modify;
1.22 perseant 1408: a.a_flags = flags;
1.1 cgd 1409: return (VCALL(vp, VOFFSET(vop_update), &a));
1410: }
1.23 thorpej 1411: #endif
1.1 cgd 1412:
1413: struct vop_lease_args {
1414: struct vnodeop_desc *a_desc;
1415: struct vnode *a_vp;
1416: struct proc *a_p;
1417: struct ucred *a_cred;
1418: int a_flag;
1419: };
1420: extern struct vnodeop_desc vop_lease_desc;
1.23 thorpej 1421: #ifndef VNODE_OP_NOINLINE
1422: static __inline
1423: #endif
1424: int VOP_LEASE(struct vnode *, struct proc *, struct ucred *, int)
1425: #ifndef VNODE_OP_NOINLINE
1426: __attribute__((__unused__))
1427: #endif
1428: ;
1429: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1430: static __inline int VOP_LEASE(vp, p, cred, flag)
1431: struct vnode *vp;
1432: struct proc *p;
1433: struct ucred *cred;
1434: int flag;
1435: {
1436: struct vop_lease_args a;
1437: a.a_desc = VDESC(vop_lease);
1438: a.a_vp = vp;
1439: a.a_p = p;
1440: a.a_cred = cred;
1441: a.a_flag = flag;
1442: return (VCALL(vp, VOFFSET(vop_lease), &a));
1443: }
1.23 thorpej 1444: #endif
1.1 cgd 1445:
1446: struct vop_whiteout_args {
1447: struct vnodeop_desc *a_desc;
1448: struct vnode *a_dvp;
1449: struct componentname *a_cnp;
1450: int a_flags;
1451: };
1452: extern struct vnodeop_desc vop_whiteout_desc;
1.23 thorpej 1453: #ifndef VNODE_OP_NOINLINE
1454: static __inline
1455: #endif
1456: int VOP_WHITEOUT(struct vnode *, struct componentname *, int)
1457: #ifndef VNODE_OP_NOINLINE
1458: __attribute__((__unused__))
1459: #endif
1460: ;
1461: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1462: static __inline int VOP_WHITEOUT(dvp, cnp, flags)
1463: struct vnode *dvp;
1464: struct componentname *cnp;
1465: int flags;
1466: {
1467: struct vop_whiteout_args a;
1468: a.a_desc = VDESC(vop_whiteout);
1469: a.a_dvp = dvp;
1470: a.a_cnp = cnp;
1471: a.a_flags = flags;
1472: return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
1473: }
1.23 thorpej 1474: #endif
1.1 cgd 1475:
1476: /* Special cases: */
1477: #include <sys/buf.h>
1478:
1479: struct vop_strategy_args {
1480: struct vnodeop_desc *a_desc;
1481: struct buf *a_bp;
1482: };
1483: extern struct vnodeop_desc vop_strategy_desc;
1.23 thorpej 1484: #ifndef VNODE_OP_NOINLINE
1485: static __inline
1486: #endif
1487: int VOP_STRATEGY(struct buf *)
1488: #ifndef VNODE_OP_NOINLINE
1489: __attribute__((__unused__))
1490: #endif
1491: ;
1492: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1493: static __inline int VOP_STRATEGY(bp)
1494: struct buf *bp;
1495: {
1496: struct vop_strategy_args a;
1497: a.a_desc = VDESC(vop_strategy);
1498: a.a_bp = bp;
1499: return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a));
1500: }
1.23 thorpej 1501: #endif
1.1 cgd 1502:
1503: struct vop_bwrite_args {
1504: struct vnodeop_desc *a_desc;
1505: struct buf *a_bp;
1506: };
1507: extern struct vnodeop_desc vop_bwrite_desc;
1.23 thorpej 1508: #ifndef VNODE_OP_NOINLINE
1509: static __inline
1510: #endif
1511: int VOP_BWRITE(struct buf *)
1512: #ifndef VNODE_OP_NOINLINE
1513: __attribute__((__unused__))
1514: #endif
1515: ;
1516: #ifndef VNODE_OP_NOINLINE
1.1 cgd 1517: static __inline int VOP_BWRITE(bp)
1518: struct buf *bp;
1519: {
1520: struct vop_bwrite_args a;
1521: a.a_desc = VDESC(vop_bwrite);
1522: a.a_bp = bp;
1523: return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
1524: }
1.23 thorpej 1525: #endif
1.1 cgd 1526:
1527: /* End of special cases. */
1.4 mikel 1528:
1529: #endif /* !_SYS_VNODE_IF_H_ */
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to vnode_if.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / sys