1 /* $NetBSD: layer_vfsops.c,v 1.56 2022/12/09 10:33:18 hannken Exp $ */
2
3 /*
4 * Copyright (c) 1999 National Aeronautics & Space Administration
5 * All rights reserved.
6 *
7 * This software was written by William Studenmund of the
8 * Numerical Aerospace Simulation Facility, NASA Ames Research Center.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the National Aeronautics & Space Administration
19 * nor the names of its contributors may be used to endorse or promote
20 * products derived from this software without specific prior written
21 * permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE NATIONAL AERONAUTICS & SPACE ADMINISTRATION
24 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ADMINISTRATION OR CONTRIB-
27 * UTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
28 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 * POSSIBILITY OF SUCH DAMAGE.
34 */
35
36 /*
37 * Copyright (c) 1992, 1993, 1995
38 * The Regents of the University of California. All rights reserved.
39 *
40 * This code is derived from software donated to Berkeley by
41 * Jan-Simon Pendry.
42 *
43 * Redistribution and use in source and binary forms, with or without
44 * modification, are permitted provided that the following conditions
45 * are met:
46 * 1. Redistributions of source code must retain the above copyright
47 * notice, this list of conditions and the following disclaimer.
48 * 2. Redistributions in binary form must reproduce the above copyright
49 * notice, this list of conditions and the following disclaimer in the
50 * documentation and/or other materials provided with the distribution.
51 * 3. Neither the name of the University nor the names of its contributors
52 * may be used to endorse or promote products derived from this software
53 * without specific prior written permission.
54 *
55 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
56 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
58 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
59 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
60 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
61 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
62 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
63 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
64 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
65 * SUCH DAMAGE.
66 *
67 * from: Id: lofs_vfsops.c,v 1.9 1992/05/30 10:26:24 jsp Exp
68 * from: @(#)lofs_vfsops.c 1.2 (Berkeley) 6/18/92
69 * @(#)null_vfsops.c 8.7 (Berkeley) 5/14/95
70 */
71
72 /*
73 * Generic layer VFS operations.
74 */
75
76 #include <sys/cdefs.h>
77 __KERNEL_RCSID(0, "$NetBSD: layer_vfsops.c,v 1.56 2022/12/09 10:33:18 hannken Exp $");
78
79 #include <sys/param.h>
80 #include <sys/sysctl.h>
81 #include <sys/systm.h>
82 #include <sys/vnode.h>
83 #include <sys/mount.h>
84 #include <sys/namei.h>
85 #include <sys/kauth.h>
86 #include <sys/module.h>
87
88 #include <miscfs/specfs/specdev.h>
89 #include <miscfs/genfs/genfs.h>
90 #include <miscfs/genfs/layer.h>
91 #include <miscfs/genfs/layer_extern.h>
92
93 SYSCTL_SETUP_PROTO(sysctl_vfs_layerfs_setup);
94
95 MODULE(MODULE_CLASS_MISC, layerfs, NULL);
96
97 static int
layerfs_modcmd(modcmd_t cmd,void * arg)98 layerfs_modcmd(modcmd_t cmd, void *arg)
99 {
100
101 switch (cmd) {
102 case MODULE_CMD_INIT:
103 return 0;
104 case MODULE_CMD_FINI:
105 return 0;
106 default:
107 return ENOTTY;
108 }
109 return 0;
110 }
111
112 /*
113 * VFS start. Nothing needed here - the start routine on the underlying
114 * filesystem will have been called when that filesystem was mounted.
115 */
116 int
layerfs_start(struct mount * mp,int flags)117 layerfs_start(struct mount *mp, int flags)
118 {
119
120 #ifdef notyet
121 return VFS_START(mp->mnt_lower, flags);
122 #else
123 return 0;
124 #endif
125 }
126
127 int
layerfs_root(struct mount * mp,int lktype,struct vnode ** vpp)128 layerfs_root(struct mount *mp, int lktype, struct vnode **vpp)
129 {
130 struct vnode *vp;
131
132 vp = MOUNTTOLAYERMOUNT(mp)->layerm_rootvp;
133 if (vp == NULL) {
134 *vpp = NULL;
135 return EINVAL;
136 }
137 /*
138 * Return root vnode with locked and with a reference held.
139 */
140 vref(vp);
141 vn_lock(vp, lktype | LK_RETRY);
142 *vpp = vp;
143 return 0;
144 }
145
146 int
layerfs_quotactl(struct mount * mp,struct quotactl_args * args)147 layerfs_quotactl(struct mount *mp, struct quotactl_args *args)
148 {
149 int error;
150
151 error = vfs_busy(mp);
152 if (error == 0) {
153 error = VFS_QUOTACTL(mp->mnt_lower, args);
154 vfs_unbusy(mp);
155 }
156
157 return error;
158 }
159
160 int
layerfs_statvfs(struct mount * mp,struct statvfs * sbp)161 layerfs_statvfs(struct mount *mp, struct statvfs *sbp)
162 {
163 struct statvfs *sbuf;
164 int error;
165
166 sbuf = kmem_zalloc(sizeof(*sbuf), KM_SLEEP);
167 error = vfs_busy(mp);
168 if (error == 0) {
169 error = VFS_STATVFS(mp->mnt_lower, sbuf);
170 vfs_unbusy(mp);
171 }
172 if (error) {
173 goto done;
174 }
175 /* Copy across the relevant data and fake the rest. */
176 sbp->f_flag = sbuf->f_flag;
177 sbp->f_bsize = sbuf->f_bsize;
178 sbp->f_frsize = sbuf->f_frsize;
179 sbp->f_iosize = sbuf->f_iosize;
180 sbp->f_blocks = sbuf->f_blocks;
181 sbp->f_bfree = sbuf->f_bfree;
182 sbp->f_bavail = sbuf->f_bavail;
183 sbp->f_bresvd = sbuf->f_bresvd;
184 sbp->f_files = sbuf->f_files;
185 sbp->f_ffree = sbuf->f_ffree;
186 sbp->f_favail = sbuf->f_favail;
187 sbp->f_fresvd = sbuf->f_fresvd;
188 sbp->f_namemax = sbuf->f_namemax;
189 copy_statvfs_info(sbp, mp);
190 done:
191 kmem_free(sbuf, sizeof(*sbuf));
192 return error;
193 }
194
195 int
layerfs_sync(struct mount * mp,int waitfor,kauth_cred_t cred)196 layerfs_sync(struct mount *mp, int waitfor,
197 kauth_cred_t cred)
198 {
199
200 /*
201 * XXX - Assumes no data cached at layer.
202 */
203 return 0;
204 }
205
206 int
layerfs_loadvnode(struct mount * mp,struct vnode * vp,const void * key,size_t key_len,const void ** new_key)207 layerfs_loadvnode(struct mount *mp, struct vnode *vp,
208 const void *key, size_t key_len, const void **new_key)
209 {
210 struct layer_mount *lmp = MOUNTTOLAYERMOUNT(mp);
211 struct vnode *lowervp;
212 struct layer_node *xp;
213
214 KASSERT(key_len == sizeof(struct vnode *));
215 memcpy(&lowervp, key, key_len);
216
217 xp = kmem_alloc(lmp->layerm_size, KM_SLEEP);
218
219 /* Share the interlock, vmobjlock, and klist with the lower node. */
220 vshareilock(vp, lowervp);
221 rw_obj_hold(lowervp->v_uobj.vmobjlock);
222 uvm_obj_setlock(&vp->v_uobj, lowervp->v_uobj.vmobjlock);
223 vshareklist(vp, lowervp);
224
225 vp->v_tag = lmp->layerm_tag;
226 vp->v_type = lowervp->v_type;
227 vp->v_op = lmp->layerm_vnodeop_p;
228 if (vp->v_type == VBLK || vp->v_type == VCHR)
229 spec_node_init(vp, lowervp->v_rdev);
230 vp->v_data = xp;
231 xp->layer_vnode = vp;
232 xp->layer_lowervp = lowervp;
233 xp->layer_flags = 0;
234 uvm_vnp_setsize(vp, 0);
235
236 /* Add a reference to the lower node. */
237 vref(lowervp);
238 *new_key = &xp->layer_lowervp;
239 return 0;
240 }
241
242 int
layerfs_vget(struct mount * mp,ino_t ino,int lktype,struct vnode ** vpp)243 layerfs_vget(struct mount *mp, ino_t ino, int lktype, struct vnode **vpp)
244 {
245 struct vnode *vp;
246 int error;
247
248 error = vfs_busy(mp);
249 if (error == 0) {
250 error = VFS_VGET(mp->mnt_lower, ino, lktype, &vp);
251 vfs_unbusy(mp);
252 }
253 if (error) {
254 *vpp = NULL;
255 return error;
256 }
257 VOP_UNLOCK(vp);
258 error = layer_node_create(mp, vp, vpp);
259 if (error) {
260 vrele(vp);
261 *vpp = NULL;
262 return error;
263 }
264 error = vn_lock(*vpp, lktype);
265 if (error) {
266 vrele(*vpp);
267 *vpp = NULL;
268 return error;
269 }
270 return 0;
271 }
272
273 int
layerfs_fhtovp(struct mount * mp,struct fid * fidp,int lktype,struct vnode ** vpp)274 layerfs_fhtovp(struct mount *mp, struct fid *fidp, int lktype,
275 struct vnode **vpp)
276 {
277 struct vnode *vp;
278 int error;
279
280 error = vfs_busy(mp);
281 if (error == 0) {
282 error = VFS_FHTOVP(mp->mnt_lower, fidp, lktype, &vp);
283 vfs_unbusy(mp);
284 }
285 if (error) {
286 *vpp = NULL;
287 return error;
288 }
289 VOP_UNLOCK(vp);
290 error = layer_node_create(mp, vp, vpp);
291 if (error) {
292 vput(vp);
293 *vpp = NULL;
294 return (error);
295 }
296 error = vn_lock(*vpp, lktype);
297 if (error) {
298 vrele(*vpp);
299 *vpp = NULL;
300 return error;
301 }
302 return 0;
303 }
304
305 int
layerfs_vptofh(struct vnode * vp,struct fid * fhp,size_t * fh_size)306 layerfs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
307 {
308
309 return VFS_VPTOFH(LAYERVPTOLOWERVP(vp), fhp, fh_size);
310 }
311
312 /*
313 * layerfs_snapshot - handle a snapshot through a layered file system
314 *
315 * At present, we do NOT support snapshotting through a layered file
316 * system as the ffs implementation changes v_vnlock of the snapshot
317 * vnodes to point to one common lock. As there is no way for us to
318 * absolutely pass this change up the stack, a layered file system
319 * would end up referencing the wrong lock.
320 *
321 * This routine serves as a central resource for this behavior; all
322 * layered file systems don't need to worry about the above. Also, if
323 * things get fixed, all layers get the benefit.
324 */
325 int
layerfs_snapshot(struct mount * mp,struct vnode * vp,struct timespec * ts)326 layerfs_snapshot(struct mount *mp, struct vnode *vp,
327 struct timespec *ts)
328 {
329
330 return EOPNOTSUPP;
331 }
332
333 /*
334 * layerfs_suspendctl - suspend a layered file system
335 *
336 * Here we should suspend the lower file system(s) too. At present
337 * this will deadlock as we don't know which to suspend first.
338 *
339 * This routine serves as a central resource for this behavior; all
340 * layered file systems don't need to worry about the above. Also, if
341 * things get fixed, all layers get the benefit.
342 */
343 int
layerfs_suspendctl(struct mount * mp,int cmd)344 layerfs_suspendctl(struct mount *mp, int cmd)
345 {
346
347 return genfs_suspendctl(mp, cmd);
348 }
349
350 SYSCTL_SETUP(sysctl_vfs_layerfs_setup, "sysctl vfs.layerfs subtree setup")
351 {
352 const struct sysctlnode *layerfs_node = NULL;
353
354 sysctl_createv(clog, 0, NULL, &layerfs_node,
355 #ifdef _MODULE
356 0,
357 #else
358 CTLFLAG_PERMANENT,
359 #endif
360 CTLTYPE_NODE, "layerfs",
361 SYSCTL_DESCR("Generic layered file system"),
362 NULL, 0, NULL, 0,
363 CTL_VFS, CTL_CREATE, CTL_EOL);
364
365 #ifdef LAYERFS_DIAGNOSTIC
366 sysctl_createv(clog, 0, &layerfs_node, NULL,
367 #ifndef _MODULE
368 CTLFLAG_PERMANENT |
369 #endif
370 CTLFLAG_READWRITE,
371 CTLTYPE_INT,
372 "debug",
373 SYSCTL_DESCR("Verbose debugging messages"),
374 NULL, 0, &layerfs_debug, 0,
375 CTL_CREATE, CTL_EOL);
376 #endif
377
378 /*
379 * other subtrees should really be aliases to this, but since
380 * they can't tell if layerfs has been instantiated yet, they
381 * can't do that...not easily. not yet. :-)
382 */
383 }
384
385 int
layerfs_renamelock_enter(struct mount * mp)386 layerfs_renamelock_enter(struct mount *mp)
387 {
388
389 return VFS_RENAMELOCK_ENTER(mp->mnt_lower);
390 }
391
392 void
layerfs_renamelock_exit(struct mount * mp)393 layerfs_renamelock_exit(struct mount *mp)
394 {
395
396 VFS_RENAMELOCK_EXIT(mp->mnt_lower);
397 }
398