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