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