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