]>
Commit | Line | Data |
---|---|---|
1c79356b | 1 | /* |
5d5c5d0d A |
2 | * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. |
3 | * | |
6601e61a | 4 | * @APPLE_LICENSE_HEADER_START@ |
1c79356b | 5 | * |
6601e61a A |
6 | * The contents of this file constitute Original Code as defined in and |
7 | * are subject to the Apple Public Source License Version 1.1 (the | |
8 | * "License"). You may not use this file except in compliance with the | |
9 | * License. Please obtain a copy of the License at | |
10 | * http://www.apple.com/publicsource and read it before using this file. | |
8f6c56a5 | 11 | * |
6601e61a A |
12 | * This Original Code and all software distributed under the License are |
13 | * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER | |
8f6c56a5 A |
14 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
15 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, | |
6601e61a A |
16 | * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the |
17 | * License for the specific language governing rights and limitations | |
18 | * under the License. | |
8f6c56a5 | 19 | * |
6601e61a | 20 | * @APPLE_LICENSE_HEADER_END@ |
1c79356b A |
21 | */ |
22 | /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ | |
23 | /* | |
24 | * Copyright (c) 1992, 1993 | |
25 | * The Regents of the University of California. All rights reserved. | |
26 | * | |
27 | * This code is derived from software contributed to Berkeley by | |
28 | * John Heidemann of the UCLA Ficus project. | |
29 | * | |
30 | * Redistribution and use in source and binary forms, with or without | |
31 | * modification, are permitted provided that the following conditions | |
32 | * are met: | |
33 | * 1. Redistributions of source code must retain the above copyright | |
34 | * notice, this list of conditions and the following disclaimer. | |
35 | * 2. Redistributions in binary form must reproduce the above copyright | |
36 | * notice, this list of conditions and the following disclaimer in the | |
37 | * documentation and/or other materials provided with the distribution. | |
38 | * 3. All advertising materials mentioning features or use of this software | |
39 | * must display the following acknowledgement: | |
40 | * This product includes software developed by the University of | |
41 | * California, Berkeley and its contributors. | |
42 | * 4. Neither the name of the University nor the names of its contributors | |
43 | * may be used to endorse or promote products derived from this software | |
44 | * without specific prior written permission. | |
45 | * | |
46 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
47 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
48 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
49 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
50 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
51 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
52 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
53 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
54 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
55 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
56 | * SUCH DAMAGE. | |
57 | * | |
58 | * @(#)null_vnops.c 8.6 (Berkeley) 5/27/95 | |
59 | * | |
60 | * Ancestors: | |
61 | * @(#)lofs_vnops.c 1.2 (Berkeley) 6/18/92 | |
62 | * ...and... | |
63 | * @(#)null_vnodeops.c 1.20 92/07/07 UCLA Ficus project | |
64 | */ | |
65 | ||
66 | /* | |
67 | * Null Layer | |
68 | * | |
69 | * (See mount_null(8) for more information.) | |
70 | * | |
71 | * The null layer duplicates a portion of the file system | |
72 | * name space under a new name. In this respect, it is | |
73 | * similar to the loopback file system. It differs from | |
74 | * the loopback fs in two respects: it is implemented using | |
75 | * a stackable layers techniques, and it's "null-node"s stack above | |
76 | * all lower-layer vnodes, not just over directory vnodes. | |
77 | * | |
78 | * The null layer has two purposes. First, it serves as a demonstration | |
79 | * of layering by proving a layer which does nothing. (It actually | |
80 | * does everything the loopback file system does, which is slightly | |
81 | * more than nothing.) Second, the null layer can serve as a prototype | |
82 | * layer. Since it provides all necessary layer framework, | |
83 | * new file system layers can be created very easily be starting | |
84 | * with a null layer. | |
85 | * | |
86 | * The remainder of this man page examines the null layer as a basis | |
87 | * for constructing new layers. | |
88 | * | |
89 | * | |
90 | * INSTANTIATING NEW NULL LAYERS | |
91 | * | |
92 | * New null layers are created with mount_null(8). | |
93 | * Mount_null(8) takes two arguments, the pathname | |
94 | * of the lower vfs (target-pn) and the pathname where the null | |
95 | * layer will appear in the namespace (alias-pn). After | |
96 | * the null layer is put into place, the contents | |
97 | * of target-pn subtree will be aliased under alias-pn. | |
98 | * | |
99 | * | |
100 | * OPERATION OF A NULL LAYER | |
101 | * | |
102 | * The null layer is the minimum file system layer, | |
103 | * simply bypassing all possible operations to the lower layer | |
104 | * for processing there. The majority of its activity centers | |
105 | * on the bypass routine, though which nearly all vnode operations | |
106 | * pass. | |
107 | * | |
108 | * The bypass routine accepts arbitrary vnode operations for | |
109 | * handling by the lower layer. It begins by examing vnode | |
110 | * operation arguments and replacing any null-nodes by their | |
111 | * lower-layer equivlants. It then invokes the operation | |
112 | * on the lower layer. Finally, it replaces the null-nodes | |
113 | * in the arguments and, if a vnode is return by the operation, | |
114 | * stacks a null-node on top of the returned vnode. | |
115 | * | |
91447636 A |
116 | * Although bypass handles most operations, vnop_getattr, vnop_lock, |
117 | * vnop_unlock, vnop_inactive, vnop_reclaim, and vnop_print are not | |
1c79356b | 118 | * bypassed. Vop_getattr must change the fsid being returned. |
91447636 | 119 | * Vop_lock and vnop_unlock must handle any locking for the |
1c79356b | 120 | * current vnode as well as pass the lock request down. |
91447636 | 121 | * Vop_inactive and vnop_reclaim are not bypassed so that |
1c79356b A |
122 | * they can handle freeing null-layer specific data. Vop_print |
123 | * is not bypassed to avoid excessive debugging information. | |
124 | * Also, certain vnode operations change the locking state within | |
125 | * the operation (create, mknod, remove, link, rename, mkdir, rmdir, | |
126 | * and symlink). Ideally these operations should not change the | |
127 | * lock state, but should be changed to let the caller of the | |
128 | * function unlock them. Otherwise all intermediate vnode layers | |
129 | * (such as union, umapfs, etc) must catch these functions to do | |
130 | * the necessary locking at their layer. | |
131 | * | |
132 | * | |
133 | * INSTANTIATING VNODE STACKS | |
134 | * | |
135 | * Mounting associates the null layer with a lower layer, | |
136 | * effect stacking two VFSes. Vnode stacks are instead | |
137 | * created on demand as files are accessed. | |
138 | * | |
139 | * The initial mount creates a single vnode stack for the | |
140 | * root of the new null layer. All other vnode stacks | |
141 | * are created as a result of vnode operations on | |
142 | * this or other null vnode stacks. | |
143 | * | |
144 | * New vnode stacks come into existance as a result of | |
145 | * an operation which returns a vnode. | |
146 | * The bypass routine stacks a null-node above the new | |
147 | * vnode before returning it to the caller. | |
148 | * | |
149 | * For example, imagine mounting a null layer with | |
150 | * "mount_null /usr/include /dev/layer/null". | |
151 | * Changing directory to /dev/layer/null will assign | |
152 | * the root null-node (which was created when the null layer was mounted). | |
91447636 | 153 | * Now consider opening "sys". A vnop_lookup would be |
1c79356b A |
154 | * done on the root null-node. This operation would bypass through |
155 | * to the lower layer which would return a vnode representing | |
156 | * the UFS "sys". Null_bypass then builds a null-node | |
157 | * aliasing the UFS "sys" and returns this to the caller. | |
158 | * Later operations on the null-node "sys" will repeat this | |
159 | * process when constructing other vnode stacks. | |
160 | * | |
161 | * | |
162 | * CREATING OTHER FILE SYSTEM LAYERS | |
163 | * | |
164 | * One of the easiest ways to construct new file system layers is to make | |
165 | * a copy of the null layer, rename all files and variables, and | |
166 | * then begin modifing the copy. Sed can be used to easily rename | |
167 | * all variables. | |
168 | * | |
169 | * The umap layer is an example of a layer descended from the | |
170 | * null layer. | |
171 | * | |
172 | * | |
173 | * INVOKING OPERATIONS ON LOWER LAYERS | |
174 | * | |
175 | * There are two techniques to invoke operations on a lower layer | |
176 | * when the operation cannot be completely bypassed. Each method | |
177 | * is appropriate in different situations. In both cases, | |
178 | * it is the responsibility of the aliasing layer to make | |
179 | * the operation arguments "correct" for the lower layer | |
180 | * by mapping an vnode arguments to the lower layer. | |
181 | * | |
182 | * The first approach is to call the aliasing layer's bypass routine. | |
183 | * This method is most suitable when you wish to invoke the operation | |
184 | * currently being hanldled on the lower layer. It has the advantage | |
185 | * that the bypass routine already must do argument mapping. | |
186 | * An example of this is null_getattrs in the null layer. | |
187 | * | |
188 | * A second approach is to directly invoked vnode operations on | |
189 | * the lower layer with the VOP_OPERATIONNAME interface. | |
190 | * The advantage of this method is that it is easy to invoke | |
191 | * arbitrary operations on the lower layer. The disadvantage | |
192 | * is that vnodes arguments must be manualy mapped. | |
193 | * | |
194 | */ | |
195 | ||
196 | #include <sys/param.h> | |
197 | #include <sys/systm.h> | |
198 | #include <sys/proc.h> | |
91447636 | 199 | #include <sys/kauth.h> |
1c79356b A |
200 | #include <sys/time.h> |
201 | #include <sys/types.h> | |
202 | #include <sys/vnode.h> | |
91447636 | 203 | #include <sys/mount_internal.h> |
1c79356b A |
204 | #include <sys/namei.h> |
205 | #include <sys/malloc.h> | |
206 | #include <sys/buf.h> | |
207 | #include <miscfs/nullfs/null.h> | |
208 | ||
209 | ||
210 | int null_bug_bypass = 0; /* for debugging: enables bypass printf'ing */ | |
211 | ||
212 | /* | |
213 | * This is the 10-Apr-92 bypass routine. | |
214 | * This version has been optimized for speed, throwing away some | |
215 | * safety checks. It should still always work, but it's not as | |
216 | * robust to programmer errors. | |
217 | * Define SAFETY to include some error checking code. | |
218 | * | |
219 | * In general, we map all vnodes going down and unmap them on the way back. | |
220 | * As an exception to this, vnodes can be marked "unmapped" by setting | |
221 | * the Nth bit in operation's vdesc_flags. | |
222 | * | |
91447636 | 223 | * Also, some BSD vnode operations have the side effect of node_put'ing |
1c79356b A |
224 | * their arguments. With stacking, the reference counts are held |
225 | * by the upper node, not the lower one, so we must handle these | |
226 | * side-effects here. This is not of concern in Sun-derived systems | |
227 | * since there are no such side-effects. | |
228 | * | |
229 | * This makes the following assumptions: | |
230 | * - only one returned vpp | |
91447636 | 231 | * - no INOUT vpp's (Sun's vnop_open has one of these) |
1c79356b A |
232 | * - the vnode operation vector of the first vnode should be used |
233 | * to determine what implementation of the op should be invoked | |
234 | * - all mapped vnodes are of our vnode-type (NEEDSWORK: | |
235 | * problems on rmdir'ing mount points and renaming?) | |
236 | */ | |
237 | int | |
238 | null_bypass(ap) | |
91447636 | 239 | struct vnop_generic_args /* { |
1c79356b A |
240 | struct vnodeop_desc *a_desc; |
241 | <other random data follows, presumably> | |
242 | } */ *ap; | |
243 | { | |
244 | extern int (**null_vnodeop_p)(void *); /* not extern, really "forward" */ | |
245 | register struct vnode **this_vp_p; | |
246 | int error; | |
247 | struct vnode *old_vps[VDESC_MAX_VPS]; | |
248 | struct vnode **vps_p[VDESC_MAX_VPS]; | |
249 | struct vnode ***vppp; | |
250 | struct vnodeop_desc *descp = ap->a_desc; | |
251 | int reles, i; | |
252 | ||
253 | if (null_bug_bypass) | |
254 | printf ("null_bypass: %s\n", descp->vdesc_name); | |
255 | ||
256 | #ifdef SAFETY | |
257 | /* | |
258 | * We require at least one vp. | |
259 | */ | |
260 | if (descp->vdesc_vp_offsets == NULL || | |
261 | descp->vdesc_vp_offsets[0] == VDESC_NO_OFFSET) | |
262 | panic ("null_bypass: no vp's in map.\n"); | |
263 | #endif | |
264 | ||
265 | /* | |
266 | * Map the vnodes going in. | |
267 | * Later, we'll invoke the operation based on | |
268 | * the first mapped vnode's operation vector. | |
269 | */ | |
270 | reles = descp->vdesc_flags; | |
271 | for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) { | |
272 | if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET) | |
273 | break; /* bail out at end of list */ | |
274 | vps_p[i] = this_vp_p = | |
275 | VOPARG_OFFSETTO(struct vnode**,descp->vdesc_vp_offsets[i],ap); | |
276 | /* | |
277 | * We're not guaranteed that any but the first vnode | |
278 | * are of our type. Check for and don't map any | |
279 | * that aren't. (We must always map first vp or vclean fails.) | |
280 | */ | |
281 | if (i && (*this_vp_p == NULL || | |
282 | (*this_vp_p)->v_op != null_vnodeop_p)) { | |
283 | old_vps[i] = NULL; | |
284 | } else { | |
285 | old_vps[i] = *this_vp_p; | |
286 | *(vps_p[i]) = NULLVPTOLOWERVP(*this_vp_p); | |
287 | /* | |
288 | * XXX - Several operations have the side effect | |
91447636 | 289 | * of vnode_put'ing their vp's. We must account for |
1c79356b A |
290 | * that. (This should go away in the future.) |
291 | */ | |
292 | if (reles & 1) | |
91447636 | 293 | vnode_get(*this_vp_p); |
1c79356b A |
294 | } |
295 | ||
296 | } | |
297 | ||
298 | /* | |
299 | * Call the operation on the lower layer | |
300 | * with the modified argument structure. | |
301 | */ | |
302 | error = VCALL(*(vps_p[0]), descp->vdesc_offset, ap); | |
303 | ||
304 | /* | |
305 | * Maintain the illusion of call-by-value | |
306 | * by restoring vnodes in the argument structure | |
307 | * to their original value. | |
308 | */ | |
309 | reles = descp->vdesc_flags; | |
310 | for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) { | |
311 | if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET) | |
312 | break; /* bail out at end of list */ | |
313 | if (old_vps[i]) { | |
314 | *(vps_p[i]) = old_vps[i]; | |
315 | if (reles & 1) | |
91447636 | 316 | vnode_put(*(vps_p[i])); |
1c79356b A |
317 | } |
318 | } | |
319 | ||
320 | /* | |
321 | * Map the possible out-going vpp | |
322 | * (Assumes that the lower layer always returns | |
91447636 | 323 | * a vnode_get'ed vpp unless it gets an error.) |
1c79356b A |
324 | */ |
325 | if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET && | |
326 | !(descp->vdesc_flags & VDESC_NOMAP_VPP) && | |
327 | !error) { | |
328 | /* | |
329 | * XXX - even though some ops have vpp returned vp's, | |
91447636 | 330 | * several ops actually vnode_put this before returning. |
1c79356b A |
331 | * We must avoid these ops. |
332 | * (This should go away when these ops are regularized.) | |
333 | */ | |
334 | if (descp->vdesc_flags & VDESC_VPP_WILLRELE) | |
335 | goto out; | |
336 | vppp = VOPARG_OFFSETTO(struct vnode***, | |
337 | descp->vdesc_vpp_offset,ap); | |
338 | error = null_node_create(old_vps[0]->v_mount, **vppp, *vppp); | |
339 | } | |
340 | ||
341 | out: | |
342 | return (error); | |
343 | } | |
344 | ||
345 | /* | |
346 | * We have to carry on the locking protocol on the null layer vnodes | |
347 | * as we progress through the tree. We also have to enforce read-only | |
348 | * if this layer is mounted read-only. | |
349 | */ | |
350 | null_lookup(ap) | |
91447636 | 351 | struct vnop_lookup_args /* { |
1c79356b A |
352 | struct vnode * a_dvp; |
353 | struct vnode ** a_vpp; | |
354 | struct componentname * a_cnp; | |
91447636 | 355 | vfs_context_t a_context; |
1c79356b A |
356 | } */ *ap; |
357 | { | |
358 | struct componentname *cnp = ap->a_cnp; | |
359 | struct proc *p = cnp->cn_proc; | |
360 | int flags = cnp->cn_flags; | |
1c79356b A |
361 | struct vnode *dvp, *vp; |
362 | int error; | |
363 | ||
1c79356b | 364 | error = null_bypass(ap); |
91447636 | 365 | |
1c79356b A |
366 | /* |
367 | * We must do the same locking and unlocking at this layer as | |
368 | * is done in the layers below us. We could figure this out | |
369 | * based on the error return and the LASTCN, LOCKPARENT, and | |
370 | * LOCKLEAF flags. However, it is more expidient to just find | |
371 | * out the state of the lower level vnodes and set ours to the | |
372 | * same state. | |
373 | */ | |
374 | dvp = ap->a_dvp; | |
375 | vp = *ap->a_vpp; | |
376 | if (dvp == vp) | |
377 | return (error); | |
1c79356b A |
378 | return (error); |
379 | } | |
380 | ||
381 | /* | |
91447636 | 382 | * Setattr call. |
1c79356b A |
383 | */ |
384 | int | |
91447636 A |
385 | null_setattr( |
386 | struct vnop_setattr_args /* { | |
1c79356b A |
387 | struct vnodeop_desc *a_desc; |
388 | struct vnode *a_vp; | |
91447636 A |
389 | struct vnode_attr *a_vap; |
390 | kauth_cred_t a_cred; | |
1c79356b | 391 | struct proc *a_p; |
91447636 | 392 | } */ *ap) |
1c79356b A |
393 | { |
394 | struct vnode *vp = ap->a_vp; | |
91447636 A |
395 | struct vnode_attr *vap = ap->a_vap; |
396 | ||
397 | if (VATTR_IS_ACTIVE(vap, va_data_size)) { | |
1c79356b A |
398 | switch (vp->v_type) { |
399 | case VDIR: | |
400 | return (EISDIR); | |
401 | case VCHR: | |
402 | case VBLK: | |
403 | case VSOCK: | |
404 | case VFIFO: | |
405 | return (0); | |
406 | case VREG: | |
407 | case VLNK: | |
408 | default: | |
1c79356b A |
409 | } |
410 | } | |
411 | return (null_bypass(ap)); | |
412 | } | |
413 | ||
414 | /* | |
415 | * We handle getattr only to change the fsid. | |
416 | */ | |
417 | int | |
418 | null_getattr(ap) | |
91447636 | 419 | struct vnop_getattr_args /* { |
1c79356b | 420 | struct vnode *a_vp; |
91447636 A |
421 | struct vnode_attr *a_vap; |
422 | vfs_context_t a_context; | |
1c79356b A |
423 | } */ *ap; |
424 | { | |
425 | int error; | |
426 | ||
427 | if (error = null_bypass(ap)) | |
428 | return (error); | |
429 | /* Requires that arguments be restored. */ | |
91447636 | 430 | VATTR_RETURN(ap->a_vap, va_fsid, ap->a_vp->v_mount->mnt_vfsstat.f_fsid.val[0]); |
1c79356b A |
431 | return (0); |
432 | } | |
433 | ||
434 | int | |
435 | null_access(ap) | |
91447636 | 436 | struct vnop_access_args /* { |
1c79356b | 437 | struct vnode *a_vp; |
91447636 A |
438 | int a_action; |
439 | vfs_context_t a_context; | |
1c79356b A |
440 | } */ *ap; |
441 | { | |
1c79356b A |
442 | return (null_bypass(ap)); |
443 | } | |
444 | ||
445 | int | |
446 | null_inactive(ap) | |
91447636 | 447 | struct vnop_inactive_args /* { |
1c79356b | 448 | struct vnode *a_vp; |
91447636 | 449 | vfs_context_t a_context; |
1c79356b A |
450 | } */ *ap; |
451 | { | |
452 | /* | |
453 | * Do nothing (and _don't_ bypass). | |
91447636 | 454 | * Wait to vnode_put lowervp until reclaim, |
1c79356b A |
455 | * so that until then our null_node is in the |
456 | * cache and reusable. | |
457 | * | |
458 | * NEEDSWORK: Someday, consider inactive'ing | |
459 | * the lowervp and then trying to reactivate it | |
460 | * with capabilities (v_id) | |
461 | * like they do in the name lookup cache code. | |
462 | * That's too much work for now. | |
463 | */ | |
1c79356b A |
464 | return (0); |
465 | } | |
466 | ||
467 | int | |
468 | null_reclaim(ap) | |
91447636 | 469 | struct vnop_reclaim_args /* { |
1c79356b | 470 | struct vnode *a_vp; |
91447636 | 471 | vfs_context_t a_context; |
1c79356b A |
472 | } */ *ap; |
473 | { | |
474 | struct vnode *vp = ap->a_vp; | |
475 | struct null_node *xp = VTONULL(vp); | |
476 | struct vnode *lowervp = xp->null_lowervp; | |
477 | ||
478 | /* | |
91447636 | 479 | * Note: in vnop_reclaim, vp->v_op == dead_vnodeop_p, |
1c79356b A |
480 | * so we can't call VOPs on ourself. |
481 | */ | |
482 | /* After this assignment, this node will not be re-used. */ | |
483 | xp->null_lowervp = NULL; | |
484 | LIST_REMOVE(xp, null_hash); | |
485 | FREE(vp->v_data, M_TEMP); | |
486 | vp->v_data = NULL; | |
91447636 | 487 | vnode_put (lowervp); |
1c79356b A |
488 | return (0); |
489 | } | |
490 | ||
491 | /* | |
91447636 | 492 | * XXX - vnop_strategy must be hand coded because it has no |
1c79356b A |
493 | * vnode in its arguments. |
494 | * This goes away with a merged VM/buffer cache. | |
495 | */ | |
496 | int | |
497 | null_strategy(ap) | |
91447636 | 498 | struct vnop_strategy_args /* { |
1c79356b A |
499 | struct buf *a_bp; |
500 | } */ *ap; | |
501 | { | |
502 | struct buf *bp = ap->a_bp; | |
503 | int error; | |
504 | struct vnode *savedvp; | |
505 | ||
91447636 A |
506 | savedvp = vnode(bp); |
507 | buf_setvnode(bp, NULLVPTOLOWERVP(savedvp)); | |
1c79356b | 508 | |
91447636 | 509 | error = VNOP_STRATEGY(bp); |
1c79356b | 510 | |
91447636 | 511 | buf_setvnode(bp, savedvp); |
1c79356b A |
512 | |
513 | return (error); | |
514 | } | |
515 | ||
516 | /* | |
91447636 | 517 | * XXX - like vnop_strategy, vnop_bwrite must be hand coded because it has no |
1c79356b A |
518 | * vnode in its arguments. |
519 | * This goes away with a merged VM/buffer cache. | |
520 | */ | |
521 | int | |
522 | null_bwrite(ap) | |
91447636 | 523 | struct vnop_bwrite_args /* { |
1c79356b A |
524 | struct buf *a_bp; |
525 | } */ *ap; | |
526 | { | |
527 | struct buf *bp = ap->a_bp; | |
528 | int error; | |
529 | struct vnode *savedvp; | |
530 | ||
91447636 A |
531 | savedvp = buf_vnode(bp); |
532 | buf_setvnode(bp, NULLVPTOLOWERVP(savedvp)); | |
1c79356b | 533 | |
91447636 | 534 | error = VNOP_BWRITE(bp); |
1c79356b | 535 | |
91447636 | 536 | buf_setvnode(bp, savedvp); |
1c79356b A |
537 | |
538 | return (error); | |
539 | } | |
540 | ||
541 | /* | |
542 | * Global vfs data structures | |
543 | */ | |
544 | ||
545 | #define VOPFUNC int (*)(void *) | |
546 | ||
547 | int (**null_vnodeop_p)(void *); | |
548 | struct vnodeopv_entry_desc null_vnodeop_entries[] = { | |
91447636 A |
549 | { &vnop_default_desc, (VOPFUNC)null_bypass }, |
550 | ||
551 | { &vnop_lookup_desc, (VOPFUNC)null_lookup }, | |
552 | { &vnop_setattr_desc, (VOPFUNC)null_setattr }, | |
553 | { &vnop_getattr_desc, (VOPFUNC)null_getattr }, | |
554 | { &vnop_access_desc, (VOPFUNC)null_access }, | |
555 | { &vnop_inactive_desc, (VOPFUNC)null_inactive }, | |
556 | { &vnop_reclaim_desc, (VOPFUNC)null_reclaim }, | |
557 | ||
558 | { &vnop_strategy_desc, (VOPFUNC)null_strategy }, | |
559 | { &vnop_bwrite_desc, (VOPFUNC)null_bwrite }, | |
1c79356b A |
560 | |
561 | { (struct vnodeop_desc*)NULL, (int(*)())NULL } | |
562 | }; | |
563 | struct vnodeopv_desc null_vnodeop_opv_desc = | |
564 | { &null_vnodeop_p, null_vnodeop_entries }; |