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