Commit | Line | Data |
---|---|---|
c153d43e JSP |
1 | /* |
2 | * Copyright (c) 1992 The Regents of the University of California | |
3 | * Copyright (c) 1990, 1992 Jan-Simon Pendry | |
4 | * All rights reserved. | |
5 | * | |
6 | * This code is derived from software donated to Berkeley by | |
7 | * Jan-Simon Pendry. | |
8 | * | |
9 | * %sccs.include.redist.c% | |
10 | * | |
45ee8885 | 11 | * @(#)lofs_vnops.c 7.3 (Berkeley) %G% |
c153d43e JSP |
12 | * |
13 | * $Id: lofs_vnops.c,v 1.11 1992/05/30 10:05:43 jsp Exp jsp $ | |
14 | */ | |
15 | ||
16 | /* | |
17 | * Loopback Filesystem | |
18 | */ | |
19 | ||
20 | #include <sys/param.h> | |
21 | #include <sys/systm.h> | |
22 | #include <sys/proc.h> | |
23 | #include <sys/time.h> | |
24 | #include <sys/types.h> | |
25 | #include <sys/vnode.h> | |
26 | #include <sys/mount.h> | |
27 | #include <sys/namei.h> | |
28 | #include <sys/malloc.h> | |
29 | #include <sys/buf.h> | |
6681df29 | 30 | #include <miscfs/lofs/lofs.h> |
c153d43e JSP |
31 | |
32 | /* | |
33 | * Basic strategy: as usual, do as little work as possible. | |
34 | * Nothing is ever locked in the lofs'ed filesystem, all | |
35 | * locks are held in the underlying filesystems. | |
36 | */ | |
37 | ||
38 | /* | |
39 | * Save a vnode and replace with | |
40 | * the lofs'ed one | |
41 | */ | |
42 | #define PUSHREF(v, nd) \ | |
43 | { \ | |
44 | struct { struct vnode *vnp; } v; \ | |
45 | v.vnp = (nd); \ | |
46 | (nd) = LOFSVP(v.vnp) | |
47 | ||
48 | /* | |
49 | * Undo the PUSHREF | |
50 | */ | |
51 | #define POP(v, nd) \ | |
52 | \ | |
53 | (nd) = v.vnp; \ | |
54 | } | |
55 | ||
56 | ||
57 | /* | |
58 | * vp is the current namei directory | |
59 | * ndp is the name to locate in that directory... | |
60 | */ | |
6681df29 KM |
61 | lofs_lookup(ap) |
62 | struct vop_lookup_args /* { | |
63 | struct vnode * a_dvp; | |
64 | struct vnode ** a_vpp; | |
65 | struct componentname * a_cnp; | |
66 | } */ *ap; | |
c153d43e | 67 | { |
50e716ac | 68 | struct vnode *dvp = ap->a_dvp; |
c153d43e JSP |
69 | struct vnode *newvp; |
70 | struct vnode *targetdvp; | |
71 | int error; | |
72 | int flag = ap->a_cnp->cn_nameiop /*& OPMASK*/; | |
73 | ||
74 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac JSP |
75 | printf("lofs_lookup(ap->a_dvp = %x->%x, \"%s\", op = %d)\n", |
76 | dvp, LOFSVP(dvp), ap->a_cnp->cn_nameptr, flag); | |
c153d43e JSP |
77 | #endif |
78 | ||
79 | /* | |
80 | * (ap->a_dvp) was locked when passed in, and it will be replaced | |
81 | * with the target vnode, BUT that will already have been | |
82 | * locked when (ap->a_dvp) was locked [see lofs_lock]. all that | |
83 | * must be done here is to keep track of reference counts. | |
84 | */ | |
50e716ac JSP |
85 | targetdvp = LOFSVP(dvp); |
86 | /*VREF(targetdvp);*/ | |
c153d43e JSP |
87 | #ifdef LOFS_DIAGNOSTIC |
88 | vprint("lofs VOP_LOOKUP", targetdvp); | |
89 | #endif | |
90 | ||
91 | /* | |
92 | * Call lookup on the looped vnode | |
93 | */ | |
50e716ac JSP |
94 | error = VOP_LOOKUP(targetdvp, &newvp, ap->a_cnp); |
95 | /*vrele(targetdvp);*/ | |
c153d43e JSP |
96 | |
97 | if (error) { | |
98 | *ap->a_vpp = NULLVP; | |
99 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 100 | printf("lofs_lookup(%x->%x) = %d\n", dvp, LOFSVP(dvp), error); |
c153d43e JSP |
101 | #endif |
102 | return (error); | |
103 | } | |
104 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 105 | printf("lofs_lookup(%x->%x) = OK\n", dvp, LOFSVP(dvp)); |
c153d43e JSP |
106 | #endif |
107 | ||
50e716ac | 108 | *ap->a_vpp = newvp; |
c153d43e JSP |
109 | |
110 | /* | |
111 | * If we just found a directory then make | |
112 | * a loopback node for it and return the loopback | |
113 | * instead of the real vnode. Otherwise simply | |
114 | * return the aliased directory and vnode. | |
115 | */ | |
116 | if (newvp && newvp->v_type == VDIR && flag == LOOKUP) { | |
117 | #ifdef LOFS_DIAGNOSTIC | |
118 | printf("lofs_lookup: found VDIR\n"); | |
119 | #endif | |
120 | /* | |
121 | * At this point, newvp is the vnode to be looped. | |
122 | * Activate a loopback and return the looped vnode. | |
123 | */ | |
50e716ac | 124 | return (make_lofs(dvp->v_mount, ap->a_vpp)); |
c153d43e JSP |
125 | } |
126 | ||
127 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 128 | printf("lofs_lookup: not VDIR\n"); |
c153d43e JSP |
129 | #endif |
130 | ||
131 | return (0); | |
132 | } | |
133 | ||
134 | /* | |
135 | * this = ni_dvp | |
136 | * ni_dvp references the locked directory. | |
137 | * ni_vp is NULL. | |
138 | */ | |
6681df29 KM |
139 | lofs_mknod(ap) |
140 | struct vop_mknod_args /* { | |
141 | struct vnode *a_dvp; | |
142 | struct vnode **a_vpp; | |
143 | struct componentname *a_cnp; | |
144 | struct vattr *a_vap; | |
145 | } */ *ap; | |
c153d43e | 146 | { |
c153d43e JSP |
147 | int error; |
148 | ||
149 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 150 | printf("lofs_mknod(vp = %x->%x)\n", ap->a_dvp, LOFSVP(ap->a_dvp)); |
c153d43e JSP |
151 | #endif |
152 | ||
153 | PUSHREF(xdvp, ap->a_dvp); | |
154 | VREF(ap->a_dvp); | |
155 | ||
156 | error = VOP_MKNOD(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap); | |
157 | ||
158 | POP(xdvp, ap->a_dvp); | |
159 | vrele(ap->a_dvp); | |
160 | ||
161 | return (error); | |
162 | } | |
163 | ||
164 | /* | |
165 | * this = ni_dvp; | |
166 | * ni_dvp references the locked directory | |
167 | * ni_vp is NULL. | |
168 | */ | |
6681df29 KM |
169 | lofs_create(ap) |
170 | struct vop_create_args /* { | |
171 | struct vnode *a_dvp; | |
172 | struct vnode **a_vpp; | |
173 | struct componentname *a_cnp; | |
174 | struct vattr *a_vap; | |
175 | } */ *ap; | |
c153d43e | 176 | { |
c153d43e JSP |
177 | int error; |
178 | ||
179 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 180 | printf("lofs_create(ap->a_dvp = %x->%x)\n", ap->a_dvp, LOFSVP(ap->a_dvp)); |
c153d43e JSP |
181 | #endif |
182 | ||
183 | PUSHREF(xdvp, ap->a_dvp); | |
184 | VREF(ap->a_dvp); | |
185 | ||
186 | error = VOP_CREATE(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap); | |
187 | ||
188 | POP(xdvp, ap->a_dvp); | |
189 | vrele(ap->a_dvp); | |
190 | ||
191 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 192 | printf("lofs_create(ap->a_dvp = %x->%x)\n", ap->a_dvp, LOFSVP(ap->a_dvp)); |
c153d43e JSP |
193 | #endif |
194 | ||
195 | return (error); | |
196 | } | |
197 | ||
6681df29 KM |
198 | lofs_open(ap) |
199 | struct vop_open_args /* { | |
200 | struct vnode *a_vp; | |
201 | int a_mode; | |
202 | struct ucred *a_cred; | |
203 | struct proc *a_p; | |
204 | } */ *ap; | |
c153d43e | 205 | { |
6681df29 | 206 | |
c153d43e | 207 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 208 | printf("lofs_open(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
209 | #endif |
210 | ||
211 | return VOP_OPEN(LOFSVP(ap->a_vp), ap->a_mode, ap->a_cred, ap->a_p); | |
212 | } | |
213 | ||
6681df29 KM |
214 | lofs_close(ap) |
215 | struct vop_close_args /* { | |
216 | struct vnode *a_vp; | |
217 | int a_fflag; | |
218 | struct ucred *a_cred; | |
219 | struct proc *a_p; | |
220 | } */ *ap; | |
c153d43e | 221 | { |
6681df29 | 222 | |
c153d43e | 223 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 224 | printf("lofs_close(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
225 | #endif |
226 | ||
227 | return VOP_CLOSE(LOFSVP(ap->a_vp), ap->a_fflag, ap->a_cred, ap->a_p); | |
228 | } | |
229 | ||
6681df29 KM |
230 | lofs_access(ap) |
231 | struct vop_access_args /* { | |
232 | struct vnode *a_vp; | |
233 | int a_mode; | |
234 | struct ucred *a_cred; | |
235 | struct proc *a_p; | |
236 | } */ *ap; | |
c153d43e | 237 | { |
6681df29 | 238 | |
c153d43e | 239 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 240 | printf("lofs_access(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
241 | #endif |
242 | ||
243 | return VOP_ACCESS(LOFSVP(ap->a_vp), ap->a_mode, ap->a_cred, ap->a_p); | |
244 | } | |
245 | ||
6681df29 KM |
246 | lofs_getattr(ap) |
247 | struct vop_getattr_args /* { | |
248 | struct vnode *a_vp; | |
249 | struct vattr *a_vap; | |
250 | struct ucred *a_cred; | |
251 | struct proc *a_p; | |
252 | } */ *ap; | |
c153d43e | 253 | { |
c153d43e JSP |
254 | int error; |
255 | ||
256 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 257 | printf("lofs_getattr(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
258 | #endif |
259 | ||
260 | /* | |
261 | * Get the stats from the underlying filesystem | |
262 | */ | |
263 | error = VOP_GETATTR(LOFSVP(ap->a_vp), ap->a_vap, ap->a_cred, ap->a_p); | |
264 | if (error) | |
265 | return (error); | |
266 | /* | |
267 | * and replace the fsid field with the loopback number | |
268 | * to preserve the namespace. | |
269 | */ | |
270 | ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0]; | |
271 | return (0); | |
272 | } | |
273 | ||
6681df29 KM |
274 | lofs_setattr(ap) |
275 | struct vop_setattr_args /* { | |
276 | struct vnode *a_vp; | |
277 | struct vattr *a_vap; | |
278 | struct ucred *a_cred; | |
279 | struct proc *a_p; | |
280 | } */ *ap; | |
c153d43e | 281 | { |
6681df29 | 282 | |
c153d43e | 283 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 284 | printf("lofs_setattr(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
285 | #endif |
286 | ||
287 | return VOP_SETATTR(LOFSVP(ap->a_vp), ap->a_vap, ap->a_cred, ap->a_p); | |
288 | } | |
289 | ||
6681df29 KM |
290 | lofs_read(ap) |
291 | struct vop_read_args /* { | |
292 | struct vnode *a_vp; | |
293 | struct uio *a_uio; | |
294 | int a_ioflag; | |
295 | struct ucred *a_cred; | |
296 | } */ *ap; | |
c153d43e | 297 | { |
6681df29 | 298 | |
c153d43e | 299 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 300 | printf("lofs_read(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
301 | #endif |
302 | ||
303 | return VOP_READ(LOFSVP(ap->a_vp), ap->a_uio, ap->a_ioflag, ap->a_cred); | |
304 | } | |
305 | ||
6681df29 KM |
306 | lofs_write(ap) |
307 | struct vop_write_args /* { | |
308 | struct vnode *a_vp; | |
309 | struct uio *a_uio; | |
310 | int a_ioflag; | |
311 | struct ucred *a_cred; | |
312 | } */ *ap; | |
c153d43e | 313 | { |
6681df29 | 314 | |
c153d43e | 315 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 316 | printf("lofs_write(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
317 | #endif |
318 | ||
319 | return VOP_WRITE(LOFSVP(ap->a_vp), ap->a_uio, ap->a_ioflag, ap->a_cred); | |
320 | } | |
321 | ||
6681df29 KM |
322 | lofs_ioctl(ap) |
323 | struct vop_ioctl_args /* { | |
324 | struct vnode *a_vp; | |
325 | int a_command; | |
326 | caddr_t a_data; | |
327 | int a_fflag; | |
328 | struct ucred *a_cred; | |
329 | struct proc *a_p; | |
330 | } */ *ap; | |
c153d43e | 331 | { |
6681df29 | 332 | |
c153d43e | 333 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 334 | printf("lofs_ioctl(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
335 | #endif |
336 | ||
337 | return VOP_IOCTL(LOFSVP(ap->a_vp), ap->a_command, ap->a_data, ap->a_fflag, ap->a_cred, ap->a_p); | |
338 | } | |
339 | ||
6681df29 KM |
340 | lofs_select(ap) |
341 | struct vop_select_args /* { | |
342 | struct vnode *a_vp; | |
343 | int a_which; | |
344 | int a_fflags; | |
345 | struct ucred *a_cred; | |
346 | struct proc *a_p; | |
347 | } */ *ap; | |
c153d43e | 348 | { |
6681df29 | 349 | |
c153d43e | 350 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 351 | printf("lofs_select(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
352 | #endif |
353 | ||
354 | return VOP_SELECT(LOFSVP(ap->a_vp), ap->a_which, ap->a_fflags, ap->a_cred, ap->a_p); | |
355 | } | |
356 | ||
6681df29 KM |
357 | lofs_mmap(ap) |
358 | struct vop_mmap_args /* { | |
359 | struct vnode *a_vp; | |
360 | int a_fflags; | |
361 | struct ucred *a_cred; | |
362 | struct proc *a_p; | |
363 | } */ *ap; | |
c153d43e | 364 | { |
6681df29 | 365 | |
c153d43e | 366 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 367 | printf("lofs_mmap(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
368 | #endif |
369 | ||
370 | return VOP_MMAP(LOFSVP(ap->a_vp), ap->a_fflags, ap->a_cred, ap->a_p); | |
371 | } | |
372 | ||
6681df29 KM |
373 | lofs_fsync(ap) |
374 | struct vop_fsync_args /* { | |
375 | struct vnode *a_vp; | |
376 | struct ucred *a_cred; | |
377 | int a_waitfor; | |
378 | struct proc *a_p; | |
379 | } */ *ap; | |
c153d43e | 380 | { |
6681df29 | 381 | |
c153d43e | 382 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 383 | printf("lofs_fsync(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
384 | #endif |
385 | ||
e28b0770 | 386 | return VOP_FSYNC(LOFSVP(ap->a_vp), ap->a_cred, ap->a_waitfor, ap->a_p); |
c153d43e JSP |
387 | } |
388 | ||
6681df29 KM |
389 | lofs_seek(ap) |
390 | struct vop_seek_args /* { | |
391 | struct vnode *a_vp; | |
392 | off_t a_oldoff; | |
393 | off_t a_newoff; | |
394 | struct ucred *a_cred; | |
395 | } */ *ap; | |
c153d43e | 396 | { |
6681df29 | 397 | |
c153d43e | 398 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 399 | printf("lofs_seek(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
400 | #endif |
401 | ||
402 | return VOP_SEEK(LOFSVP(ap->a_vp), ap->a_oldoff, ap->a_newoff, ap->a_cred); | |
403 | } | |
404 | ||
6681df29 KM |
405 | lofs_remove(ap) |
406 | struct vop_remove_args /* { | |
407 | struct vnode *a_dvp; | |
408 | struct vnode *a_vp; | |
409 | struct componentname *a_cnp; | |
410 | } */ *ap; | |
c153d43e | 411 | { |
c153d43e JSP |
412 | int error; |
413 | ||
414 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 415 | printf("lofs_remove(ap->a_vp = %x->%x)\n", ap->a_dvp, LOFSVP(ap->a_dvp)); |
c153d43e JSP |
416 | #endif |
417 | ||
418 | PUSHREF(xdvp, ap->a_dvp); | |
419 | VREF(ap->a_dvp); | |
420 | PUSHREF(xvp, ap->a_vp); | |
421 | VREF(ap->a_vp); | |
422 | ||
423 | error = VOP_REMOVE(ap->a_dvp, ap->a_vp, ap->a_cnp); | |
424 | ||
425 | POP(xvp, ap->a_vp); | |
426 | vrele(ap->a_vp); | |
427 | POP(xdvp, ap->a_dvp); | |
428 | vrele(ap->a_dvp); | |
429 | ||
430 | return (error); | |
431 | } | |
432 | ||
433 | /* | |
434 | * vp is this. | |
435 | * ni_dvp is the locked parent of the target. | |
436 | * ni_vp is NULL. | |
437 | */ | |
6681df29 KM |
438 | lofs_link(ap) |
439 | struct vop_link_args /* { | |
440 | struct vnode *a_vp; | |
441 | struct vnode *a_tdvp; | |
442 | struct componentname *a_cnp; | |
443 | } */ *ap; | |
c153d43e | 444 | { |
c153d43e JSP |
445 | int error; |
446 | ||
447 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 448 | printf("lofs_link(ap->a_tdvp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
449 | #endif |
450 | ||
451 | PUSHREF(xdvp, ap->a_vp); | |
452 | VREF(ap->a_vp); | |
453 | ||
454 | error = VOP_LINK(ap->a_vp, LOFSVP(ap->a_tdvp), ap->a_cnp); | |
455 | ||
456 | POP(xdvp, ap->a_vp); | |
457 | vrele(ap->a_vp); | |
458 | ||
459 | return (error); | |
460 | } | |
461 | ||
6681df29 KM |
462 | lofs_rename(ap) |
463 | struct vop_rename_args /* { | |
464 | struct vnode *a_fdvp; | |
465 | struct vnode *a_fvp; | |
466 | struct componentname *a_fcnp; | |
467 | struct vnode *a_tdvp; | |
468 | struct vnode *a_tvp; | |
469 | struct componentname *a_tcnp; | |
470 | } */ *ap; | |
c153d43e | 471 | { |
c153d43e JSP |
472 | struct vnode *fvp, *tvp; |
473 | struct vnode *tdvp; | |
6681df29 | 474 | #ifdef notdef |
c153d43e JSP |
475 | struct vnode *fsvp, *tsvp; |
476 | #endif | |
477 | int error; | |
478 | ||
479 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac JSP |
480 | printf("lofs_rename(fdvp = %x->%x)\n", ap->a_fdvp, LOFSVP(ap->a_fdvp)); |
481 | /*printf("lofs_rename(tdvp = %x->%x)\n", tndp->ni_dvp, LOFSVP(tndp->ni_dvp));*/ | |
c153d43e JSP |
482 | #endif |
483 | ||
484 | #ifdef LOFS_DIAGNOSTIC | |
485 | printf("lofs_rename - switch source dvp\n"); | |
486 | #endif | |
487 | /* | |
488 | * Switch source directory to point to lofsed vnode | |
489 | */ | |
490 | PUSHREF(fdvp, ap->a_fdvp); | |
491 | VREF(ap->a_fdvp); | |
492 | ||
493 | #ifdef LOFS_DIAGNOSTIC | |
494 | printf("lofs_rename - switch source vp\n"); | |
495 | #endif | |
496 | /* | |
497 | * And source object if it is lofsed... | |
498 | */ | |
499 | fvp = ap->a_fvp; | |
500 | if (fvp && fvp->v_op == lofs_vnodeop_p) { | |
501 | ap->a_fvp = LOFSVP(fvp); | |
502 | VREF(ap->a_fvp); | |
503 | } else { | |
504 | fvp = 0; | |
505 | } | |
506 | ||
6681df29 | 507 | #ifdef notdef |
c153d43e JSP |
508 | #ifdef LOFS_DIAGNOSTIC |
509 | printf("lofs_rename - switch source start vp\n"); | |
510 | #endif | |
511 | /* | |
512 | * And source startdir object if it is lofsed... | |
513 | */ | |
514 | fsvp = fndp->ni_startdir; | |
515 | if (fsvp && fsvp->v_op == lofs_vnodeop_p) { | |
516 | fndp->ni_startdir = LOFSVP(fsvp); | |
517 | VREF(fndp->ni_startdir); | |
518 | } else { | |
519 | fsvp = 0; | |
520 | } | |
521 | #endif | |
522 | ||
523 | #ifdef LOFS_DIAGNOSTIC | |
524 | printf("lofs_rename - switch target dvp\n"); | |
525 | #endif | |
526 | /* | |
527 | * Switch target directory to point to lofsed vnode | |
528 | */ | |
529 | tdvp = ap->a_tdvp; | |
530 | if (tdvp && tdvp->v_op == lofs_vnodeop_p) { | |
531 | ap->a_tdvp = LOFSVP(tdvp); | |
532 | VREF(ap->a_tdvp); | |
533 | } else { | |
534 | tdvp = 0; | |
535 | } | |
536 | ||
537 | #ifdef LOFS_DIAGNOSTIC | |
538 | printf("lofs_rename - switch target vp\n"); | |
539 | #endif | |
540 | /* | |
541 | * And target object if it is lofsed... | |
542 | */ | |
543 | tvp = ap->a_tvp; | |
544 | if (tvp && tvp->v_op == lofs_vnodeop_p) { | |
545 | ap->a_tvp = LOFSVP(tvp); | |
546 | VREF(ap->a_tvp); | |
547 | } else { | |
548 | tvp = 0; | |
549 | } | |
550 | ||
6681df29 | 551 | #ifdef notdef |
c153d43e JSP |
552 | #ifdef LOFS_DIAGNOSTIC |
553 | printf("lofs_rename - switch target start vp\n"); | |
554 | #endif | |
555 | /* | |
556 | * And target startdir object if it is lofsed... | |
557 | */ | |
558 | tsvp = tndp->ni_startdir; | |
559 | if (tsvp && tsvp->v_op == lofs_vnodeop_p) { | |
560 | tndp->ni_startdir = LOFSVP(fsvp); | |
561 | VREF(tndp->ni_startdir); | |
562 | } else { | |
563 | tsvp = 0; | |
564 | } | |
565 | #endif | |
566 | ||
567 | #ifdef LOFS_DIAGNOSTIC | |
568 | printf("lofs_rename - VOP_RENAME(%x, %x, %x, %x)\n", | |
569 | ap->a_fdvp, ap->a_fvp, ap->a_tdvp, ap->a_tvp); | |
570 | vprint("ap->a_fdvp", ap->a_fdvp); | |
571 | vprint("ap->a_fvp", ap->a_fvp); | |
572 | vprint("ap->a_tdvp", ap->a_tdvp); | |
573 | if (ap->a_tvp) vprint("ap->a_tvp", ap->a_tvp); | |
574 | DELAY(16000000); | |
575 | #endif | |
576 | ||
577 | error = VOP_RENAME(ap->a_fdvp, ap->a_fvp, ap->a_fcnp, ap->a_tdvp, ap->a_tvp, ap->a_tcnp); | |
578 | ||
579 | /* | |
580 | * Put everything back... | |
581 | */ | |
582 | ||
6681df29 | 583 | #ifdef notdef |
c153d43e JSP |
584 | #ifdef LOFS_DIAGNOSTIC |
585 | printf("lofs_rename - restore target startdir\n"); | |
586 | #endif | |
587 | ||
588 | if (tsvp) { | |
589 | if (tndp->ni_startdir) | |
590 | vrele(tndp->ni_startdir); | |
591 | tndp->ni_startdir = tsvp; | |
592 | } | |
593 | #endif | |
594 | ||
595 | #ifdef LOFS_DIAGNOSTIC | |
596 | printf("lofs_rename - restore target vp\n"); | |
597 | #endif | |
598 | ||
599 | if (tvp) { | |
600 | ap->a_tvp = tvp; | |
601 | vrele(ap->a_tvp); | |
602 | } | |
603 | ||
604 | #ifdef LOFS_DIAGNOSTIC | |
605 | printf("lofs_rename - restore target dvp\n"); | |
606 | #endif | |
607 | ||
608 | if (tdvp) { | |
609 | ap->a_tdvp = tdvp; | |
610 | vrele(ap->a_tdvp); | |
611 | } | |
612 | ||
6681df29 | 613 | #ifdef notdef |
c153d43e JSP |
614 | #ifdef LOFS_DIAGNOSTIC |
615 | printf("lofs_rename - restore source startdir\n"); | |
616 | #endif | |
617 | ||
618 | if (fsvp) { | |
619 | if (fndp->ni_startdir) | |
620 | vrele(fndp->ni_startdir); | |
621 | fndp->ni_startdir = fsvp; | |
622 | } | |
623 | #endif | |
624 | ||
625 | #ifdef LOFS_DIAGNOSTIC | |
626 | printf("lofs_rename - restore source vp\n"); | |
627 | #endif | |
628 | ||
629 | ||
630 | if (fvp) { | |
631 | ap->a_fvp = fvp; | |
632 | vrele(ap->a_fvp); | |
633 | } | |
634 | ||
635 | #ifdef LOFS_DIAGNOSTIC | |
636 | printf("lofs_rename - restore source dvp\n"); | |
637 | #endif | |
638 | ||
639 | POP(fdvp, ap->a_fdvp); | |
640 | vrele(ap->a_fdvp); | |
641 | ||
642 | return (error); | |
643 | } | |
644 | ||
645 | /* | |
646 | * ni_dvp is the locked (alias) parent. | |
647 | * ni_vp is NULL. | |
648 | */ | |
6681df29 KM |
649 | lofs_mkdir(ap) |
650 | struct vop_mkdir_args /* { | |
651 | struct vnode *a_dvp; | |
652 | struct vnode **a_vpp; | |
653 | struct componentname *a_cnp; | |
654 | struct vattr *a_vap; | |
655 | } */ *ap; | |
c153d43e | 656 | { |
c153d43e | 657 | int error; |
50e716ac | 658 | struct vnode *dvp = ap->a_dvp; |
c153d43e | 659 | struct vnode *xdvp; |
50e716ac | 660 | struct vnode *newvp; |
c153d43e JSP |
661 | |
662 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 663 | printf("lofs_mkdir(vp = %x->%x)\n", dvp, LOFSVP(dvp)); |
c153d43e JSP |
664 | #endif |
665 | ||
50e716ac JSP |
666 | xdvp = dvp; |
667 | dvp = LOFSVP(xdvp); | |
d41d1395 | 668 | VREF(dvp); |
c153d43e | 669 | |
50e716ac | 670 | error = VOP_MKDIR(dvp, &newvp, ap->a_cnp, ap->a_vap); |
c153d43e JSP |
671 | |
672 | if (error) { | |
50e716ac | 673 | *ap->a_vpp = NULLVP; |
d41d1395 | 674 | vrele(xdvp); |
c153d43e JSP |
675 | return (error); |
676 | } | |
677 | ||
678 | /* | |
679 | * Make a new lofs node | |
680 | */ | |
50e716ac | 681 | /*VREF(dvp);*/ |
c153d43e | 682 | |
50e716ac | 683 | error = make_lofs(dvp->v_mount, &newvp); |
c153d43e | 684 | |
50e716ac | 685 | *ap->a_vpp = newvp; |
c153d43e JSP |
686 | |
687 | return (error); | |
688 | } | |
689 | ||
690 | /* | |
691 | * ni_dvp is the locked parent. | |
692 | * ni_vp is the entry to be removed. | |
693 | */ | |
6681df29 KM |
694 | lofs_rmdir(ap) |
695 | struct vop_rmdir_args /* { | |
696 | struct vnode *a_dvp; | |
697 | struct vnode *a_vp; | |
698 | struct componentname *a_cnp; | |
699 | } */ *ap; | |
c153d43e | 700 | { |
50e716ac JSP |
701 | struct vnode *vp = ap->a_vp; |
702 | struct vnode *dvp = ap->a_dvp; | |
c153d43e JSP |
703 | int error; |
704 | ||
705 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 706 | printf("lofs_rmdir(dvp = %x->%x)\n", dvp, LOFSVP(dvp)); |
c153d43e JSP |
707 | #endif |
708 | ||
50e716ac JSP |
709 | PUSHREF(xdvp, dvp); |
710 | VREF(dvp); | |
711 | PUSHREF(xvp, vp); | |
712 | VREF(vp); | |
c153d43e | 713 | |
50e716ac | 714 | error = VOP_RMDIR(dvp, vp, ap->a_cnp); |
c153d43e | 715 | |
50e716ac JSP |
716 | POP(xvp, vp); |
717 | vrele(vp); | |
718 | POP(xdvp, dvp); | |
719 | vrele(dvp); | |
c153d43e JSP |
720 | |
721 | return (error); | |
722 | } | |
723 | ||
724 | /* | |
725 | * ni_dvp is the locked parent. | |
726 | * ni_vp is NULL. | |
727 | */ | |
6681df29 KM |
728 | lofs_symlink(ap) |
729 | struct vop_symlink_args /* { | |
730 | struct vnode *a_dvp; | |
731 | struct vnode **a_vpp; | |
732 | struct componentname *a_cnp; | |
733 | struct vattr *a_vap; | |
734 | char *a_target; | |
735 | } */ *ap; | |
c153d43e | 736 | { |
c153d43e JSP |
737 | int error; |
738 | ||
739 | #ifdef LOFS_DIAGNOSTIC | |
740 | printf("VOP_SYMLINK(vp = %x->%x)\n", ap->a_dvp, LOFSVP(ap->a_dvp)); | |
741 | #endif | |
742 | ||
743 | PUSHREF(xdvp, ap->a_dvp); | |
744 | VREF(ap->a_dvp); | |
745 | ||
746 | error = VOP_SYMLINK(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap, ap->a_target); | |
747 | ||
748 | POP(xdvp, ap->a_dvp); | |
749 | vrele(ap->a_dvp); | |
750 | ||
751 | return (error); | |
752 | } | |
753 | ||
6681df29 KM |
754 | lofs_readdir(ap) |
755 | struct vop_readdir_args /* { | |
756 | struct vnode *a_vp; | |
757 | struct uio *a_uio; | |
758 | struct ucred *a_cred; | |
759 | } */ *ap; | |
c153d43e | 760 | { |
6681df29 | 761 | |
c153d43e | 762 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 763 | printf("lofs_readdir(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
764 | #endif |
765 | ||
e28b0770 | 766 | return VOP_READDIR(LOFSVP(ap->a_vp), ap->a_uio, ap->a_cred); |
c153d43e JSP |
767 | } |
768 | ||
6681df29 KM |
769 | lofs_readlink(ap) |
770 | struct vop_readlink_args /* { | |
771 | struct vnode *a_vp; | |
772 | struct uio *a_uio; | |
773 | struct ucred *a_cred; | |
774 | } */ *ap; | |
c153d43e | 775 | { |
6681df29 | 776 | |
c153d43e | 777 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 778 | printf("lofs_readlink(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
779 | #endif |
780 | ||
781 | return VOP_READLINK(LOFSVP(ap->a_vp), ap->a_uio, ap->a_cred); | |
782 | } | |
783 | ||
784 | /* | |
785 | * Anyone's guess... | |
786 | */ | |
6681df29 KM |
787 | lofs_abortop(ap) |
788 | struct vop_abortop_args /* { | |
789 | struct vnode *a_dvp; | |
790 | struct componentname *a_cnp; | |
791 | } */ *ap; | |
c153d43e | 792 | { |
c153d43e JSP |
793 | int error; |
794 | ||
795 | PUSHREF(xdvp, ap->a_dvp); | |
796 | ||
797 | error = VOP_ABORTOP(ap->a_dvp, ap->a_cnp); | |
798 | ||
799 | POP(xdvp, ap->a_dvp); | |
800 | ||
801 | return (error); | |
802 | } | |
803 | ||
6681df29 KM |
804 | lofs_inactive(ap) |
805 | struct vop_inactive_args /* { | |
806 | struct vnode *a_vp; | |
807 | } */ *ap; | |
c153d43e | 808 | { |
c153d43e | 809 | struct vnode *targetvp = LOFSVP(ap->a_vp); |
6681df29 | 810 | |
c153d43e | 811 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 812 | printf("lofs_inactive(ap->a_vp = %x->%x)\n", ap->a_vp, targetvp); |
c153d43e JSP |
813 | #endif |
814 | ||
815 | #ifdef DIAGNOSTIC | |
816 | { extern int prtactive; | |
817 | if (prtactive && ap->a_vp->v_usecount != 0) | |
818 | vprint("lofs_inactive: pushing active", ap->a_vp); | |
819 | } | |
820 | #endif | |
821 | ||
822 | if (targetvp) { | |
823 | vrele(targetvp); | |
824 | LOFSP(ap->a_vp)->a_lofsvp = 0; | |
825 | } | |
826 | } | |
827 | ||
6681df29 KM |
828 | lofs_reclaim(ap) |
829 | struct vop_reclaim_args /* { | |
830 | struct vnode *a_vp; | |
831 | } */ *ap; | |
c153d43e | 832 | { |
c153d43e | 833 | struct vnode *targetvp; |
6681df29 | 834 | |
c153d43e | 835 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 836 | printf("lofs_reclaim(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
837 | #endif |
838 | remque(LOFSP(ap->a_vp)); | |
839 | targetvp = LOFSVP(ap->a_vp); | |
840 | if (targetvp) { | |
841 | printf("lofs: delayed vrele of %x\n", targetvp); | |
842 | vrele(targetvp); /* XXX should never happen */ | |
843 | } | |
844 | FREE(ap->a_vp->v_data, M_TEMP); | |
845 | ap->a_vp->v_data = 0; | |
846 | return (0); | |
847 | } | |
848 | ||
6681df29 KM |
849 | lofs_lock(ap) |
850 | struct vop_lock_args /* { | |
851 | struct vnode *a_vp; | |
852 | } */ *ap; | |
c153d43e | 853 | { |
c153d43e JSP |
854 | int error; |
855 | struct vnode *targetvp = LOFSVP(ap->a_vp); | |
856 | ||
857 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 858 | printf("lofs_lock(ap->a_vp = %x->%x)\n", ap->a_vp, targetvp); |
c153d43e JSP |
859 | /*vprint("lofs_lock ap->a_vp", ap->a_vp); |
860 | if (targetvp) | |
861 | vprint("lofs_lock ->ap->a_vp", targetvp); | |
862 | else | |
863 | printf("lofs_lock ->ap->a_vp = NIL\n");*/ | |
864 | #endif | |
865 | ||
866 | if (targetvp) { | |
867 | error = VOP_LOCK(targetvp); | |
868 | if (error) | |
869 | return (error); | |
870 | } | |
871 | ||
872 | return (0); | |
873 | } | |
874 | ||
6681df29 KM |
875 | lofs_unlock(ap) |
876 | struct vop_unlock_args /* { | |
877 | struct vnode *a_vp; | |
878 | } */ *ap; | |
c153d43e | 879 | { |
c153d43e JSP |
880 | struct vnode *targetvp = LOFSVP(ap->a_vp); |
881 | ||
882 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 883 | printf("lofs_unlock(ap->a_vp = %x->%x)\n", ap->a_vp, targetvp); |
c153d43e JSP |
884 | #endif |
885 | ||
886 | if (targetvp) | |
887 | return (VOP_UNLOCK(targetvp)); | |
888 | return (0); | |
889 | } | |
890 | ||
6681df29 KM |
891 | lofs_bmap(ap) |
892 | struct vop_bmap_args /* { | |
893 | struct vnode *a_vp; | |
894 | daddr_t a_bn; | |
895 | struct vnode **a_vpp; | |
896 | daddr_t *a_bnp; | |
45ee8885 | 897 | int *a_runp; |
6681df29 | 898 | } */ *ap; |
c153d43e | 899 | { |
6681df29 | 900 | |
c153d43e | 901 | #ifdef LOFS_DIAGNOSTIC |
50e716ac | 902 | printf("lofs_bmap(ap->a_vp = %x->%x)\n", ap->a_vp, LOFSVP(ap->a_vp)); |
c153d43e JSP |
903 | #endif |
904 | ||
45ee8885 | 905 | return VOP_BMAP(LOFSVP(ap->a_vp), ap->a_bn, ap->a_vpp, ap->a_bnp, ap->a_runp); |
c153d43e JSP |
906 | } |
907 | ||
6681df29 KM |
908 | lofs_strategy(ap) |
909 | struct vop_strategy_args /* { | |
910 | struct buf *a_bp; | |
911 | } */ *ap; | |
c153d43e | 912 | { |
c153d43e JSP |
913 | int error; |
914 | ||
915 | #ifdef LOFS_DIAGNOSTIC | |
50e716ac | 916 | printf("lofs_strategy(vp = %x->%x)\n", ap->a_bp->b_vp, LOFSVP(ap->a_bp->b_vp)); |
c153d43e JSP |
917 | #endif |
918 | ||
919 | PUSHREF(vp, ap->a_bp->b_vp); | |
920 | ||
921 | error = VOP_STRATEGY(ap->a_bp); | |
922 | ||
923 | POP(vp, ap->a_bp->b_vp); | |
924 | ||
925 | return (error); | |
926 | } | |
927 | ||
6681df29 KM |
928 | lofs_print(ap) |
929 | struct vop_print_args /* { | |
930 | struct vnode *a_vp; | |
931 | } */ *ap; | |
c153d43e | 932 | { |
6681df29 | 933 | |
c153d43e JSP |
934 | struct vnode *targetvp = LOFSVP(ap->a_vp); |
935 | printf("tag VT_LOFS ref "); | |
936 | if (targetvp) | |
937 | return (VOP_PRINT(targetvp)); | |
938 | printf("NULLVP\n"); | |
939 | return (0); | |
940 | } | |
941 | ||
6681df29 KM |
942 | lofs_islocked(ap) |
943 | struct vop_islocked_args /* { | |
944 | struct vnode *a_vp; | |
945 | } */ *ap; | |
c153d43e | 946 | { |
6681df29 | 947 | |
c153d43e JSP |
948 | struct vnode *targetvp = LOFSVP(ap->a_vp); |
949 | if (targetvp) | |
950 | return (VOP_ISLOCKED(targetvp)); | |
951 | return (0); | |
952 | } | |
953 | ||
6681df29 KM |
954 | lofs_advlock(ap) |
955 | struct vop_advlock_args /* { | |
956 | struct vnode *a_vp; | |
957 | caddr_t a_id; | |
958 | int a_op; | |
959 | struct flock *a_fl; | |
960 | int a_flags; | |
961 | } */ *ap; | |
c153d43e | 962 | { |
6681df29 | 963 | |
c153d43e JSP |
964 | return VOP_ADVLOCK(LOFSVP(ap->a_vp), ap->a_id, ap->a_op, ap->a_fl, ap->a_flags); |
965 | } | |
966 | ||
967 | /* | |
968 | * LOFS directory offset lookup. | |
969 | * Currently unsupported. | |
970 | */ | |
6681df29 KM |
971 | lofs_blkatoff(ap) |
972 | struct vop_blkatoff_args /* { | |
973 | struct vnode *a_vp; | |
974 | off_t a_offset; | |
975 | char **a_res; | |
976 | struct buf **a_bpp; | |
977 | } */ *ap; | |
c153d43e JSP |
978 | { |
979 | ||
980 | return (EOPNOTSUPP); | |
981 | } | |
982 | ||
c153d43e JSP |
983 | /* |
984 | * LOFS flat namespace allocation. | |
985 | * Currently unsupported. | |
986 | */ | |
6681df29 KM |
987 | lofs_valloc(ap) |
988 | struct vop_valloc_args /* { | |
989 | struct vnode *a_pvp; | |
990 | int a_mode; | |
991 | struct ucred *a_cred; | |
992 | struct vnode **a_vpp; | |
993 | } */ *ap; | |
c153d43e JSP |
994 | { |
995 | ||
996 | return (EOPNOTSUPP); | |
997 | } | |
998 | ||
999 | /* | |
1000 | * LOFS flat namespace free. | |
1001 | * Currently unsupported. | |
1002 | */ | |
1003 | /*void*/ | |
6681df29 KM |
1004 | lofs_vfree(ap) |
1005 | struct vop_vfree_args /* { | |
1006 | struct vnode *a_pvp; | |
1007 | ino_t a_ino; | |
1008 | int a_mode; | |
1009 | } */ *ap; | |
c153d43e JSP |
1010 | { |
1011 | ||
6681df29 | 1012 | return (0); |
c153d43e JSP |
1013 | } |
1014 | ||
1015 | /* | |
1016 | * LOFS file truncation. | |
1017 | */ | |
6681df29 KM |
1018 | lofs_truncate(ap) |
1019 | struct vop_truncate_args /* { | |
1020 | struct vnode *a_vp; | |
1021 | off_t a_length; | |
1022 | int a_flags; | |
1023 | struct ucred *a_cred; | |
1024 | struct proc *a_p; | |
1025 | } */ *ap; | |
c153d43e JSP |
1026 | { |
1027 | ||
1028 | /* Use lofs_setattr */ | |
1029 | printf("lofs_truncate: need to implement!!"); | |
1030 | return (EOPNOTSUPP); | |
1031 | } | |
1032 | ||
1033 | /* | |
1034 | * LOFS update. | |
1035 | */ | |
6681df29 KM |
1036 | lofs_update(ap) |
1037 | struct vop_update_args /* { | |
1038 | struct vnode *a_vp; | |
1039 | struct timeval *a_ta; | |
1040 | struct timeval *a_tm; | |
1041 | int a_waitfor; | |
1042 | } */ *ap; | |
c153d43e JSP |
1043 | { |
1044 | ||
1045 | /* Use lofs_setattr */ | |
1046 | printf("lofs_update: need to implement!!"); | |
1047 | return (EOPNOTSUPP); | |
1048 | } | |
1049 | ||
1050 | /* | |
1051 | * LOFS bwrite | |
1052 | */ | |
6681df29 KM |
1053 | lofs_bwrite(ap) |
1054 | struct vop_bwrite_args /* { | |
1055 | struct buf *a_bp; | |
1056 | } */ *ap; | |
c153d43e | 1057 | { |
6681df29 | 1058 | |
c153d43e JSP |
1059 | return (EOPNOTSUPP); |
1060 | } | |
1061 | ||
1062 | /* | |
1063 | * Global vfs data structures for ufs | |
1064 | */ | |
1065 | int (**lofs_vnodeop_p)(); | |
1066 | struct vnodeopv_entry_desc lofs_vnodeop_entries[] = { | |
1067 | { &vop_default_desc, vn_default_error }, | |
1068 | { &vop_lookup_desc, lofs_lookup }, /* lookup */ | |
1069 | { &vop_create_desc, lofs_create }, /* create */ | |
1070 | { &vop_mknod_desc, lofs_mknod }, /* mknod */ | |
1071 | { &vop_open_desc, lofs_open }, /* open */ | |
1072 | { &vop_close_desc, lofs_close }, /* close */ | |
1073 | { &vop_access_desc, lofs_access }, /* access */ | |
1074 | { &vop_getattr_desc, lofs_getattr }, /* getattr */ | |
1075 | { &vop_setattr_desc, lofs_setattr }, /* setattr */ | |
1076 | { &vop_read_desc, lofs_read }, /* read */ | |
1077 | { &vop_write_desc, lofs_write }, /* write */ | |
1078 | { &vop_ioctl_desc, lofs_ioctl }, /* ioctl */ | |
1079 | { &vop_select_desc, lofs_select }, /* select */ | |
1080 | { &vop_mmap_desc, lofs_mmap }, /* mmap */ | |
1081 | { &vop_fsync_desc, lofs_fsync }, /* fsync */ | |
1082 | { &vop_seek_desc, lofs_seek }, /* seek */ | |
1083 | { &vop_remove_desc, lofs_remove }, /* remove */ | |
1084 | { &vop_link_desc, lofs_link }, /* link */ | |
1085 | { &vop_rename_desc, lofs_rename }, /* rename */ | |
1086 | { &vop_mkdir_desc, lofs_mkdir }, /* mkdir */ | |
1087 | { &vop_rmdir_desc, lofs_rmdir }, /* rmdir */ | |
1088 | { &vop_symlink_desc, lofs_symlink }, /* symlink */ | |
1089 | { &vop_readdir_desc, lofs_readdir }, /* readdir */ | |
1090 | { &vop_readlink_desc, lofs_readlink }, /* readlink */ | |
1091 | { &vop_abortop_desc, lofs_abortop }, /* abortop */ | |
1092 | { &vop_inactive_desc, lofs_inactive }, /* inactive */ | |
1093 | { &vop_reclaim_desc, lofs_reclaim }, /* reclaim */ | |
1094 | { &vop_lock_desc, lofs_lock }, /* lock */ | |
1095 | { &vop_unlock_desc, lofs_unlock }, /* unlock */ | |
1096 | { &vop_bmap_desc, lofs_bmap }, /* bmap */ | |
1097 | { &vop_strategy_desc, lofs_strategy }, /* strategy */ | |
1098 | { &vop_print_desc, lofs_print }, /* print */ | |
1099 | { &vop_islocked_desc, lofs_islocked }, /* islocked */ | |
1100 | { &vop_advlock_desc, lofs_advlock }, /* advlock */ | |
1101 | { &vop_blkatoff_desc, lofs_blkatoff }, /* blkatoff */ | |
c153d43e JSP |
1102 | { &vop_valloc_desc, lofs_valloc }, /* valloc */ |
1103 | { &vop_vfree_desc, lofs_vfree }, /* vfree */ | |
1104 | { &vop_truncate_desc, lofs_truncate }, /* truncate */ | |
1105 | { &vop_update_desc, lofs_update }, /* update */ | |
1106 | { &vop_bwrite_desc, lofs_bwrite }, /* bwrite */ | |
1107 | { (struct vnodeop_desc*)NULL, (int(*)())NULL } | |
1108 | }; | |
1109 | struct vnodeopv_desc lofs_vnodeop_opv_desc = | |
1110 | { &lofs_vnodeop_p, lofs_vnodeop_entries }; |