1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 2001 Dag-Erling Coïdan Smørgrav
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer
12 * in this position and unchanged.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33
34 #include "opt_pseudofs.h"
35
36 #include <sys/param.h>
37 #include <sys/kernel.h>
38 #include <sys/systm.h>
39 #include <sys/lock.h>
40 #include <sys/malloc.h>
41 #include <sys/module.h>
42 #include <sys/mount.h>
43 #include <sys/mutex.h>
44 #include <sys/proc.h>
45 #include <sys/sbuf.h>
46 #include <sys/sysctl.h>
47 #include <sys/vnode.h>
48
49 #include <fs/pseudofs/pseudofs.h>
50 #include <fs/pseudofs/pseudofs_internal.h>
51
52 static MALLOC_DEFINE(M_PFSNODES, "pfs_nodes", "pseudofs nodes");
53
54 SYSCTL_NODE(_vfs, OID_AUTO, pfs, CTLFLAG_RW, 0,
55 "pseudofs");
56
57 #ifdef PSEUDOFS_TRACE
58 int pfs_trace;
59 SYSCTL_INT(_vfs_pfs, OID_AUTO, trace, CTLFLAG_RW, &pfs_trace, 0,
60 "enable tracing of pseudofs vnode operations");
61 #endif
62
63 #if PFS_FSNAMELEN != MFSNAMELEN
64 #error "PFS_FSNAMELEN is not equal to MFSNAMELEN"
65 #endif
66
67 /*
68 * Allocate and initialize a node
69 */
70 static struct pfs_node *
71 pfs_alloc_node_flags(struct pfs_info *pi, const char *name, pfs_type_t type, int flags)
72 {
73 struct pfs_node *pn;
74 int malloc_flags;
75
76 KASSERT(strlen(name) < PFS_NAMELEN,
77 ("%s(): node name is too long", __func__));
78 if (flags & PFS_NOWAIT)
79 malloc_flags = M_NOWAIT | M_ZERO;
80 else
81 malloc_flags = M_WAITOK | M_ZERO;
82 pn = malloc(sizeof *pn, M_PFSNODES, malloc_flags);
83 if (pn == NULL)
84 return (NULL);
85 mtx_init(&pn->pn_mutex, "pfs_node", NULL, MTX_DEF | MTX_DUPOK);
86 strlcpy(pn->pn_name, name, sizeof pn->pn_name);
87 pn->pn_type = type;
88 pn->pn_info = pi;
89 return (pn);
90 }
91
92 static struct pfs_node *
93 pfs_alloc_node(struct pfs_info *pi, const char *name, pfs_type_t type)
94 {
95 return (pfs_alloc_node_flags(pi, name, type, 0));
96 }
97
98 /*
99 * Add a node to a directory
100 */
101 static void
102 pfs_add_node(struct pfs_node *parent, struct pfs_node *pn)
103 {
104 #ifdef INVARIANTS
105 struct pfs_node *iter;
106 #endif
107
108 KASSERT(parent != NULL,
109 ("%s(): parent is NULL", __func__));
110 KASSERT(pn->pn_parent == NULL,
111 ("%s(): node already has a parent", __func__));
112 KASSERT(parent->pn_info != NULL,
113 ("%s(): parent has no pn_info", __func__));
114 KASSERT(parent->pn_type == pfstype_dir ||
115 parent->pn_type == pfstype_procdir ||
116 parent->pn_type == pfstype_root,
117 ("%s(): parent is not a directory", __func__));
118
119 #ifdef INVARIANTS
120 /* XXX no locking! */
121 if (pn->pn_type == pfstype_procdir)
122 for (iter = parent; iter != NULL; iter = iter->pn_parent)
123 KASSERT(iter->pn_type != pfstype_procdir,
124 ("%s(): nested process directories", __func__));
125 for (iter = parent->pn_nodes; iter != NULL; iter = iter->pn_next) {
126 KASSERT(strcmp(pn->pn_name, iter->pn_name) != 0,
127 ("%s(): homonymous siblings", __func__));
128 if (pn->pn_type == pfstype_procdir)
129 KASSERT(iter->pn_type != pfstype_procdir,
130 ("%s(): sibling process directories", __func__));
131 }
132 #endif
133
134 pn->pn_parent = parent;
135 pfs_fileno_alloc(pn);
136
137 pfs_lock(parent);
138 pn->pn_next = parent->pn_nodes;
139 if ((parent->pn_flags & PFS_PROCDEP) != 0)
140 pn->pn_flags |= PFS_PROCDEP;
141 parent->pn_nodes = pn;
142 pfs_unlock(parent);
143 }
144
145 /*
146 * Detach a node from its aprent
147 */
148 static void
149 pfs_detach_node(struct pfs_node *pn)
150 {
151 struct pfs_node *parent = pn->pn_parent;
152 struct pfs_node **iter;
153
154 KASSERT(parent != NULL, ("%s(): node has no parent", __func__));
155 KASSERT(parent->pn_info == pn->pn_info,
156 ("%s(): parent has different pn_info", __func__));
157
158 pfs_lock(parent);
159 iter = &parent->pn_nodes;
160 while (*iter != NULL) {
161 if (*iter == pn) {
162 *iter = pn->pn_next;
163 break;
164 }
165 iter = &(*iter)->pn_next;
166 }
167 pn->pn_parent = NULL;
168 pfs_unlock(parent);
169 }
170
171 /*
172 * Add . and .. to a directory
173 */
174 static int
175 pfs_fixup_dir_flags(struct pfs_node *parent, int flags)
176 {
177 struct pfs_node *dot, *dotdot;
178
179 dot = pfs_alloc_node_flags(parent->pn_info, ".", pfstype_this, flags);
180 if (dot == NULL)
181 return (ENOMEM);
182 dotdot = pfs_alloc_node_flags(parent->pn_info, "..", pfstype_parent, flags);
183 if (dotdot == NULL) {
184 pfs_destroy(dot);
185 return (ENOMEM);
186 }
187 pfs_add_node(parent, dot);
188 pfs_add_node(parent, dotdot);
189 return (0);
190 }
191
192 static void
193 pfs_fixup_dir(struct pfs_node *parent)
194 {
195
196 pfs_fixup_dir_flags(parent, 0);
197 }
198
199 /*
200 * Create a directory
201 */
202 struct pfs_node *
203 pfs_create_dir(struct pfs_node *parent, const char *name,
204 pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy,
205 int flags)
206 {
207 struct pfs_node *pn;
208 int rc;
209
210 pn = pfs_alloc_node_flags(parent->pn_info, name,
211 (flags & PFS_PROCDEP) ? pfstype_procdir : pfstype_dir, flags);
212 if (pn == NULL)
213 return (NULL);
214 pn->pn_attr = attr;
215 pn->pn_vis = vis;
216 pn->pn_destroy = destroy;
217 pn->pn_flags = flags;
218 pfs_add_node(parent, pn);
219 rc = pfs_fixup_dir_flags(pn, flags);
220 if (rc) {
221 pfs_destroy(pn);
222 return (NULL);
223 }
224 return (pn);
225 }
226
227 /*
228 * Create a file
229 */
230 struct pfs_node *
231 pfs_create_file(struct pfs_node *parent, const char *name, pfs_fill_t fill,
232 pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy,
233 int flags)
234 {
235 struct pfs_node *pn;
236
237 pn = pfs_alloc_node_flags(parent->pn_info, name, pfstype_file, flags);
238 if (pn == NULL)
239 return (NULL);
240 pn->pn_fill = fill;
241 pn->pn_attr = attr;
242 pn->pn_vis = vis;
243 pn->pn_destroy = destroy;
244 pn->pn_flags = flags;
245 pfs_add_node(parent, pn);
246
247 return (pn);
248 }
249
250 /*
251 * Create a symlink
252 */
253 struct pfs_node *
254 pfs_create_link(struct pfs_node *parent, const char *name, pfs_fill_t fill,
255 pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy,
256 int flags)
257 {
258 struct pfs_node *pn;
259
260 pn = pfs_alloc_node_flags(parent->pn_info, name, pfstype_symlink, flags);
261 if (pn == NULL)
262 return (NULL);
263 pn->pn_fill = fill;
264 pn->pn_attr = attr;
265 pn->pn_vis = vis;
266 pn->pn_destroy = destroy;
267 pn->pn_flags = flags;
268 pfs_add_node(parent, pn);
269
270 return (pn);
271 }
272
273 /*
274 * Locate a node by name
275 */
276 struct pfs_node *
277 pfs_find_node(struct pfs_node *parent, const char *name)
278 {
279 struct pfs_node *pn;
280
281 pfs_lock(parent);
282 for (pn = parent->pn_nodes; pn != NULL; pn = pn->pn_next)
283 if (strcmp(pn->pn_name, name) == 0)
284 break;
285 pfs_unlock(parent);
286 return (pn);
287 }
288
289 /*
290 * Destroy a node and all its descendants. If the node to be destroyed
291 * has a parent, the parent's mutex must be held.
292 */
293 int
294 pfs_destroy(struct pfs_node *pn)
295 {
296 struct pfs_node *iter;
297
298 KASSERT(pn != NULL,
299 ("%s(): node is NULL", __func__));
300 KASSERT(pn->pn_info != NULL,
301 ("%s(): node has no pn_info", __func__));
302
303 if (pn->pn_parent)
304 pfs_detach_node(pn);
305
306 /* destroy children */
307 if (pn->pn_type == pfstype_dir ||
308 pn->pn_type == pfstype_procdir ||
309 pn->pn_type == pfstype_root) {
310 pfs_lock(pn);
311 while (pn->pn_nodes != NULL) {
312 iter = pn->pn_nodes;
313 pn->pn_nodes = iter->pn_next;
314 iter->pn_parent = NULL;
315 pfs_unlock(pn);
316 pfs_destroy(iter);
317 pfs_lock(pn);
318 }
319 pfs_unlock(pn);
320 }
321
322 /* revoke vnodes and fileno */
323 pfs_purge(pn);
324
325 /* callback to free any private resources */
326 if (pn->pn_destroy != NULL)
327 pn_destroy(pn);
328
329 /* destroy the node */
330 pfs_fileno_free(pn);
331 mtx_destroy(&pn->pn_mutex);
332 free(pn, M_PFSNODES);
333
334 return (0);
335 }
336
337 /*
338 * Mount a pseudofs instance
339 */
340 int
341 pfs_mount(struct pfs_info *pi, struct mount *mp)
342 {
343 struct statfs *sbp;
344
345 if (mp->mnt_flag & MNT_UPDATE)
346 return (EOPNOTSUPP);
347
348 MNT_ILOCK(mp);
349 mp->mnt_flag |= MNT_LOCAL;
350 MNT_IUNLOCK(mp);
351 mp->mnt_data = pi;
352 vfs_getnewfsid(mp);
353
354 sbp = &mp->mnt_stat;
355 vfs_mountedfrom(mp, pi->pi_name);
356 sbp->f_bsize = PAGE_SIZE;
357 sbp->f_iosize = PAGE_SIZE;
358 sbp->f_blocks = 1;
359 sbp->f_bfree = 0;
360 sbp->f_bavail = 0;
361 sbp->f_files = 1;
362 sbp->f_ffree = 0;
363
364 return (0);
365 }
366
367 /*
368 * Compatibility shim for old mount(2) system call
369 */
370 int
371 pfs_cmount(struct mntarg *ma, void *data, uint64_t flags)
372 {
373 int error;
374
375 error = kernel_mount(ma, flags);
376 return (error);
377 }
378
379 /*
380 * Unmount a pseudofs instance
381 */
382 int
383 pfs_unmount(struct mount *mp, int mntflags)
384 {
385 int error;
386
387 error = vflush(mp, 0, (mntflags & MNT_FORCE) ? FORCECLOSE : 0,
388 curthread);
389 return (error);
390 }
391
392 /*
393 * Return a root vnode
394 */
395 int
396 pfs_root(struct mount *mp, int flags, struct vnode **vpp)
397 {
398 struct pfs_info *pi;
399
400 pi = (struct pfs_info *)mp->mnt_data;
401 return (pfs_vncache_alloc(mp, vpp, pi->pi_root, NO_PID));
402 }
403
404 /*
405 * Return filesystem stats
406 */
407 int
408 pfs_statfs(struct mount *mp, struct statfs *sbp)
409 {
410 /* no-op: always called with mp->mnt_stat */
411 return (0);
412 }
413
414 /*
415 * Initialize a pseudofs instance
416 */
417 int
418 pfs_init(struct pfs_info *pi, struct vfsconf *vfc)
419 {
420 struct pfs_node *root;
421 int error;
422
423 pfs_fileno_init(pi);
424
425 /* set up the root directory */
426 root = pfs_alloc_node(pi, "/", pfstype_root);
427 pi->pi_root = root;
428 pfs_fileno_alloc(root);
429 pfs_fixup_dir(root);
430
431 /* construct file hierarchy */
432 error = (pi->pi_init)(pi, vfc);
433 if (error) {
434 pfs_destroy(root);
435 pi->pi_root = NULL;
436 return (error);
437 }
438
439 if (bootverbose)
440 printf("%s registered\n", pi->pi_name);
441 return (0);
442 }
443
444 /*
445 * Destroy a pseudofs instance
446 */
447 int
448 pfs_uninit(struct pfs_info *pi, struct vfsconf *vfc)
449 {
450 int error;
451
452 pfs_destroy(pi->pi_root);
453 pi->pi_root = NULL;
454 pfs_fileno_uninit(pi);
455 if (bootverbose)
456 printf("%s unregistered\n", pi->pi_name);
457 error = (pi->pi_uninit)(pi, vfc);
458 return (error);
459 }
460
461 /*
462 * Handle load / unload events
463 */
464 static int
465 pfs_modevent(module_t mod, int evt, void *arg)
466 {
467 switch (evt) {
468 case MOD_LOAD:
469 pfs_vncache_load();
470 break;
471 case MOD_UNLOAD:
472 case MOD_SHUTDOWN:
473 pfs_vncache_unload();
474 break;
475 default:
476 return EOPNOTSUPP;
477 break;
478 }
479 return 0;
480 }
481
482 /*
483 * Module declaration
484 */
485 static moduledata_t pseudofs_data = {
486 "pseudofs",
487 pfs_modevent,
488 NULL
489 };
490 DECLARE_MODULE(pseudofs, pseudofs_data, SI_SUB_EXEC, SI_ORDER_FIRST);
491 MODULE_VERSION(pseudofs, 1);
Cache object: 10f599831e21befc8405d9becc95dbae
|