sys/fs/pseudofs/pseudofs.c

   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);