1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 
  25 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T     */
  26 /*        All Rights Reserved   */
  27 
  28 
  29 /*
  30  * This file supports the vfs operations for the NAMEFS file system.
  31  */
  32 
  33 #include <sys/types.h>
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/debug.h>
  37 #include <sys/errno.h>
  38 #include <sys/kmem.h>
  39 #include <sys/inline.h>
  40 #include <sys/file.h>
  41 #include <sys/proc.h>
  42 #include <sys/stat.h>
  43 #include <sys/statvfs.h>
  44 #include <sys/mount.h>
  45 #include <sys/sysmacros.h>
  46 #include <sys/var.h>
  47 #include <sys/vfs.h>
  48 #include <sys/vfs_opreg.h>
  49 #include <sys/vnode.h>
  50 #include <sys/mode.h>
  51 #include <sys/pcb.h>
  52 #include <sys/signal.h>
  53 #include <sys/user.h>
  54 #include <sys/uio.h>
  55 #include <sys/cred.h>
  56 #include <sys/fs/namenode.h>
  57 #include <sys/stream.h>
  58 #include <sys/strsubr.h>
  59 #include <sys/cmn_err.h>
  60 #include <sys/modctl.h>
  61 #include <fs/fs_subr.h>
  62 #include <sys/policy.h>
  63 #include <sys/vmem.h>
  64 #include <sys/fs/sdev_impl.h>
  65 
  66 #define NM_INOQUANT             (64 * 1024)
  67 
  68 /*
  69  * Define global data structures.
  70  */
  71 dev_t   namedev;
  72 int     namefstype;
  73 struct  namenode *nm_filevp_hash[NM_FILEVP_HASH_SIZE];
  74 struct  vfs namevfs;
  75 kmutex_t ntable_lock;
  76 
  77 static vmem_t   *nm_inoarena;   /* vmem arena to allocate inode no's from */
  78 static kmutex_t nm_inolock;
  79 
  80 vfsops_t *namefs_vfsops;
  81 /*
  82  * Functions to allocate node id's starting from 1. Based on vmem routines.
  83  * The vmem arena is extended in NM_INOQUANT chunks.
  84  */
  85 uint64_t
  86 namenodeno_alloc(void)
  87 {
  88         uint64_t nno;
  89 
  90         mutex_enter(&nm_inolock);
  91         nno = (uint64_t)(uintptr_t)
  92             vmem_alloc(nm_inoarena, 1, VM_NOSLEEP + VM_FIRSTFIT);
  93         if (nno == 0) {
  94                 (void) vmem_add(nm_inoarena, (void *)(vmem_size(nm_inoarena,
  95                     VMEM_ALLOC | VMEM_FREE) + 1), NM_INOQUANT, VM_SLEEP);
  96                 nno = (uint64_t)(uintptr_t)
  97                     vmem_alloc(nm_inoarena, 1, VM_SLEEP + VM_FIRSTFIT);
  98                 ASSERT(nno != 0);
  99         }
 100         mutex_exit(&nm_inolock);
 101         ASSERT32(nno <= ULONG_MAX);
 102         return (nno);
 103 }
 104 
 105 static void
 106 namenodeno_init(void)
 107 {
 108         nm_inoarena = vmem_create("namefs_inodes", (void *)1, NM_INOQUANT, 1,
 109             NULL, NULL, NULL, 1, VM_SLEEP);
 110         mutex_init(&nm_inolock, NULL, MUTEX_DEFAULT, NULL);
 111 }
 112 
 113 void
 114 namenodeno_free(uint64_t nn)
 115 {
 116         void *vaddr = (void *)(uintptr_t)nn;
 117 
 118         ASSERT32((uint64_t)(uintptr_t)vaddr == nn);
 119 
 120         mutex_enter(&nm_inolock);
 121         vmem_free(nm_inoarena, vaddr, 1);
 122         mutex_exit(&nm_inolock);
 123 }
 124 
 125 /*
 126  * Insert a namenode into the nm_filevp_hash table.
 127  *
 128  * Each link has a unique namenode with a unique nm_mountvp field.
 129  * The nm_filevp field of the namenode need not be unique, since a
 130  * file descriptor may be mounted to multiple nodes at the same time.
 131  * We hash on nm_filevp since that's what discriminates the searches
 132  * in namefind() and nm_unmountall().
 133  */
 134 void
 135 nameinsert(struct namenode *nodep)
 136 {
 137         struct namenode **bucket;
 138 
 139         ASSERT(MUTEX_HELD(&ntable_lock));
 140 
 141         bucket = NM_FILEVP_HASH(nodep->nm_filevp);
 142         nodep->nm_nextp = *bucket;
 143         *bucket = nodep;
 144 }
 145 
 146 /*
 147  * Remove a namenode from the hash table, if present.
 148  */
 149 void
 150 nameremove(struct namenode *nodep)
 151 {
 152         struct namenode *np, **npp;
 153 
 154         ASSERT(MUTEX_HELD(&ntable_lock));
 155 
 156         for (npp = NM_FILEVP_HASH(nodep->nm_filevp); (np = *npp) != NULL;
 157             npp = &np->nm_nextp) {
 158                 if (np == nodep) {
 159                         *npp = np->nm_nextp;
 160                         return;
 161                 }
 162         }
 163 }
 164 
 165 /*
 166  * Search for a namenode that has a nm_filevp == vp and nm_mountpt == mnt.
 167  * If mnt is NULL, return the first link with nm_filevp of vp.
 168  * Returns namenode pointer on success, NULL on failure.
 169  */
 170 struct namenode *
 171 namefind(vnode_t *vp, vnode_t *mnt)
 172 {
 173         struct namenode *np;
 174 
 175         ASSERT(MUTEX_HELD(&ntable_lock));
 176         for (np = *NM_FILEVP_HASH(vp); np != NULL; np = np->nm_nextp)
 177                 if (np->nm_filevp == vp &&
 178                     (mnt == NULL || np->nm_mountpt == mnt))
 179                         break;
 180         return (np);
 181 }
 182 
 183 /*
 184  * Force the unmouting of a file descriptor from ALL of the nodes
 185  * that it was mounted to.
 186  * At the present time, the only usage for this routine is in the
 187  * event one end of a pipe was mounted. At the time the unmounted
 188  * end gets closed down, the mounted end is forced to be unmounted.
 189  *
 190  * This routine searches the namenode hash list for all namenodes
 191  * that have a nm_filevp field equal to vp. Each time one is found,
 192  * the dounmount() routine is called. This causes the nm_unmount()
 193  * routine to be called and thus, the file descriptor is unmounted
 194  * from the node.
 195  *
 196  * At the start of this routine, the reference count for vp is
 197  * incremented to protect the vnode from being released in the
 198  * event the mount was the only thing keeping the vnode active.
 199  * If that is the case, the VOP_CLOSE operation is applied to
 200  * the vnode, prior to it being released.
 201  */
 202 static int
 203 nm_umountall(vnode_t *vp, cred_t *crp)
 204 {
 205         vfs_t *vfsp;
 206         struct namenode *nodep;
 207         int error = 0;
 208         int realerr = 0;
 209 
 210         /*
 211          * For each namenode that is associated with the file:
 212          * If the v_vfsp field is not namevfs, dounmount it.  Otherwise,
 213          * it was created in nm_open() and will be released in time.
 214          * The following loop replicates some code from nm_find.  That
 215          * routine can't be used as is since the list isn't strictly
 216          * consumed as it is traversed.
 217          */
 218         mutex_enter(&ntable_lock);
 219         nodep = *NM_FILEVP_HASH(vp);
 220         while (nodep) {
 221                 if (nodep->nm_filevp == vp &&
 222                     (vfsp = NMTOV(nodep)->v_vfsp) != NULL &&
 223                     vfsp != &namevfs && (NMTOV(nodep)->v_flag & VROOT)) {
 224 
 225                         /*
 226                          * If the vn_vfswlock fails, skip the vfs since
 227                          * somebody else may be unmounting it.
 228                          */
 229                         if (vn_vfswlock(vfsp->vfs_vnodecovered)) {
 230                                 realerr = EBUSY;
 231                                 nodep = nodep->nm_nextp;
 232                                 continue;
 233                         }
 234 
 235                         /*
 236                          * Can't hold ntable_lock across call to do_unmount
 237                          * because nm_unmount tries to acquire it.  This means
 238                          * there is a window where another mount of vp can
 239                          * happen so it is possible that after nm_unmountall
 240                          * there are still some mounts.  This situation existed
 241                          * without MT locking because dounmount can sleep
 242                          * so another mount could happen during that time.
 243                          * This situation is unlikely and doesn't really cause
 244                          * any problems.
 245                          */
 246                         mutex_exit(&ntable_lock);
 247                         if ((error = dounmount(vfsp, 0, crp)) != 0)
 248                                 realerr = error;
 249                         mutex_enter(&ntable_lock);
 250                         /*
 251                          * Since we dropped the ntable_lock, we
 252                          * have to start over from the beginning.
 253                          * If for some reasons dounmount() fails,
 254                          * start from beginning means that we will keep on
 255                          * trying unless another thread unmounts it for us.
 256                          */
 257                         nodep = *NM_FILEVP_HASH(vp);
 258                 } else
 259                         nodep = nodep->nm_nextp;
 260         }
 261         mutex_exit(&ntable_lock);
 262         return (realerr);
 263 }
 264 
 265 /*
 266  * Force the unmouting of a file descriptor from ALL of the nodes
 267  * that it was mounted to.  XXX: fifo_close() calls this routine.
 268  *
 269  * nm_umountall() may return EBUSY.
 270  * nm_unmountall() will keep on trying until it succeeds.
 271  */
 272 int
 273 nm_unmountall(vnode_t *vp, cred_t *crp)
 274 {
 275         int error;
 276 
 277         /*
 278          * Nm_umuontall() returns only if it succeeds or
 279          * return with error EBUSY.  If EBUSY, that means
 280          * it cannot acquire the lock on the covered vnode,
 281          * and we will keep on trying.
 282          */
 283         for (;;) {
 284                 error = nm_umountall(vp, crp);
 285                 if (error != EBUSY)
 286                         break;
 287                 delay(1);       /* yield cpu briefly, then try again */
 288         }
 289         return (error);
 290 }
 291 
 292 /*
 293  * Mount a file descriptor onto the node in the file system.
 294  * Create a new vnode, update the attributes with info from the
 295  * file descriptor and the mount point.  The mask, mode, uid, gid,
 296  * atime, mtime and ctime are taken from the mountpt.  Link count is
 297  * set to one, the file system id is namedev and nodeid is unique
 298  * for each mounted object.  Other attributes are taken from mount point.
 299  * Make sure user is owner (or root) with write permissions on mount point.
 300  * Hash the new vnode and return 0.
 301  * Upon entry to this routine, the file descriptor is in the
 302  * fd field of a struct namefd.  Copy that structure from user
 303  * space and retrieve the file descriptor.
 304  */
 305 static int
 306 nm_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *crp)
 307 {
 308         struct namefd namefdp;
 309         struct vnode *filevp;           /* file descriptor vnode */
 310         struct file *fp;
 311         struct vnode *newvp;            /* vnode representing this mount */
 312         struct vnode *rvp;              /* realvp (if any) for the mountpt */
 313         struct namenode *nodep;         /* namenode for this mount */
 314         struct vattr filevattr;         /* attributes of file dec.  */
 315         struct vattr *vattrp;           /* attributes of this mount */
 316         char *resource_name;
 317         char *resource_nodetype;
 318         statvfs64_t *svfsp;
 319         int error = 0;
 320 
 321         /*
 322          * Get the file descriptor from user space.
 323          * Make sure the file descriptor is valid and has an
 324          * associated file pointer.
 325          * If so, extract the vnode from the file pointer.
 326          */
 327         if (uap->datalen != sizeof (struct namefd))
 328                 return (EINVAL);
 329 
 330         if (copyin(uap->dataptr, &namefdp, uap->datalen))
 331                 return (EFAULT);
 332 
 333         if ((fp = getf(namefdp.fd)) == NULL)
 334                 return (EBADF);
 335 
 336         /*
 337          * If the mount point already has something mounted
 338          * on it, disallow this mount.  (This restriction may
 339          * be removed in a later release).
 340          * Or unmount has completed but the namefs ROOT vnode
 341          * count has not decremented to zero, disallow this mount.
 342          */
 343 
 344         mutex_enter(&mvp->v_lock);
 345         if ((mvp->v_flag & VROOT) ||
 346             vfs_matchops(mvp->v_vfsp, namefs_vfsops)) {
 347                 mutex_exit(&mvp->v_lock);
 348                 releasef(namefdp.fd);
 349                 return (EBUSY);
 350         }
 351         mutex_exit(&mvp->v_lock);
 352 
 353         /*
 354          * Cannot allow users to fattach() in /dev/pts.
 355          * First, there is no need for doing so and secondly
 356          * we cannot allow arbitrary users to park on a node in
 357          * /dev/pts or /dev/vt.
 358          */
 359         rvp = NULLVP;
 360         if (vn_matchops(mvp, spec_getvnodeops()) &&
 361             VOP_REALVP(mvp, &rvp, NULL) == 0 && rvp &&
 362             (vn_matchops(rvp, devpts_getvnodeops()) ||
 363             vn_matchops(rvp, devvt_getvnodeops()))) {
 364                 releasef(namefdp.fd);
 365                 return (ENOTSUP);
 366         }
 367 
 368         filevp = fp->f_vnode;
 369         if (filevp->v_type == VDIR || filevp->v_type == VPORT) {
 370                 releasef(namefdp.fd);
 371                 return (EINVAL);
 372         }
 373 
 374         /*
 375          * If the fd being mounted refers to neither a door nor a stream,
 376          * make sure the caller is privileged.
 377          */
 378         if (filevp->v_type != VDOOR && filevp->v_stream == NULL) {
 379                 if (secpolicy_fs_mount(crp, filevp, vfsp) != 0) {
 380                         /* fd is neither a stream nor a door */
 381                         releasef(namefdp.fd);
 382                         return (EINVAL);
 383                 }
 384         }
 385 
 386         /*
 387          * Make sure the file descriptor is not the root of some
 388          * file system.
 389          * If it's not, create a reference and allocate a namenode
 390          * to represent this mount request.
 391          */
 392         if (filevp->v_flag & VROOT) {
 393                 releasef(namefdp.fd);
 394                 return (EBUSY);
 395         }
 396 
 397         nodep = kmem_zalloc(sizeof (struct namenode), KM_SLEEP);
 398 
 399         mutex_init(&nodep->nm_lock, NULL, MUTEX_DEFAULT, NULL);
 400         vattrp = &nodep->nm_vattr;
 401         vattrp->va_mask = AT_ALL;
 402         if (error = VOP_GETATTR(mvp, vattrp, 0, crp, NULL))
 403                 goto out;
 404 
 405         filevattr.va_mask = AT_ALL;
 406         if (error = VOP_GETATTR(filevp, &filevattr, 0, crp, NULL))
 407                 goto out;
 408         /*
 409          * Make sure the user is the owner of the mount point
 410          * or has sufficient privileges.
 411          */
 412         if (error = secpolicy_vnode_owner(crp, vattrp->va_uid))
 413                 goto out;
 414 
 415         /*
 416          * Make sure the user has write permissions on the
 417          * mount point (or has sufficient privileges).
 418          */
 419         if (secpolicy_vnode_access2(crp, mvp, vattrp->va_uid, vattrp->va_mode,
 420             VWRITE) != 0) {
 421                 error = EACCES;
 422                 goto out;
 423         }
 424 
 425         /*
 426          * If the file descriptor has file/record locking, don't
 427          * allow the mount to succeed.
 428          */
 429         if (vn_has_flocks(filevp)) {
 430                 error = EACCES;
 431                 goto out;
 432         }
 433 
 434         /*
 435          * Initialize the namenode.
 436          */
 437         if (filevp->v_stream) {
 438                 struct stdata *stp = filevp->v_stream;
 439                 mutex_enter(&stp->sd_lock);
 440                 stp->sd_flag |= STRMOUNT;
 441                 mutex_exit(&stp->sd_lock);
 442         }
 443         nodep->nm_filevp = filevp;
 444         mutex_enter(&fp->f_tlock);
 445         fp->f_count++;
 446         mutex_exit(&fp->f_tlock);
 447 
 448         releasef(namefdp.fd);
 449         nodep->nm_filep = fp;
 450         nodep->nm_mountpt = mvp;
 451 
 452         /*
 453          * The attributes for the mounted file descriptor were initialized
 454          * above by applying VOP_GETATTR to the mount point.  Some of
 455          * the fields of the attributes structure will be overwritten
 456          * by the attributes from the file descriptor.
 457          */
 458         vattrp->va_type    = filevattr.va_type;
 459         vattrp->va_fsid    = namedev;
 460         vattrp->va_nodeid  = namenodeno_alloc();
 461         vattrp->va_nlink   = 1;
 462         vattrp->va_size    = filevattr.va_size;
 463         vattrp->va_rdev    = filevattr.va_rdev;
 464         vattrp->va_blksize = filevattr.va_blksize;
 465         vattrp->va_nblocks = filevattr.va_nblocks;
 466         vattrp->va_seq          = 0;
 467 
 468         /*
 469          * Initialize new vnode structure for the mounted file descriptor.
 470          */
 471         nodep->nm_vnode = vn_alloc(KM_SLEEP);
 472         newvp = NMTOV(nodep);
 473 
 474         newvp->v_flag = filevp->v_flag | VROOT | VNOMAP | VNOSWAP;
 475         vn_setops(newvp, nm_vnodeops);
 476         newvp->v_vfsp = vfsp;
 477         newvp->v_stream = filevp->v_stream;
 478         newvp->v_type = filevp->v_type;
 479         newvp->v_rdev = filevp->v_rdev;
 480         newvp->v_data = (caddr_t)nodep;
 481         VFS_HOLD(vfsp);
 482         vn_exists(newvp);
 483 
 484         /*
 485          * Initialize the vfs structure.
 486          */
 487         vfsp->vfs_vnodecovered = NULL;
 488         vfsp->vfs_flag |= VFS_UNLINKABLE;
 489         vfsp->vfs_bsize = 1024;
 490         vfsp->vfs_fstype = namefstype;
 491         vfs_make_fsid(&vfsp->vfs_fsid, namedev, namefstype);
 492         vfsp->vfs_data = (caddr_t)nodep;
 493         vfsp->vfs_dev = namedev;
 494         vfsp->vfs_bcount = 0;
 495 
 496         /*
 497          * Set the name we mounted from.
 498          */
 499         switch (filevp->v_type) {
 500         case VPROC:     /* VOP_GETATTR() translates this to VREG */
 501         case VREG:      resource_nodetype = "file"; break;
 502         case VDIR:      resource_nodetype = "directory"; break;
 503         case VBLK:      resource_nodetype = "device"; break;
 504         case VCHR:      resource_nodetype = "device"; break;
 505         case VLNK:      resource_nodetype = "link"; break;
 506         case VFIFO:     resource_nodetype = "fifo"; break;
 507         case VDOOR:     resource_nodetype = "door"; break;
 508         case VSOCK:     resource_nodetype = "socket"; break;
 509         default:        resource_nodetype = "resource"; break;
 510         }
 511 
 512 #define RESOURCE_NAME_SZ 128 /* Maximum length of the resource name */
 513         resource_name = kmem_alloc(RESOURCE_NAME_SZ, KM_SLEEP);
 514         svfsp = kmem_alloc(sizeof (statvfs64_t), KM_SLEEP);
 515 
 516         error = VFS_STATVFS(filevp->v_vfsp, svfsp);
 517         if (error == 0) {
 518                 (void) snprintf(resource_name, RESOURCE_NAME_SZ,
 519                     "unspecified_%s_%s", svfsp->f_basetype, resource_nodetype);
 520         } else {
 521                 (void) snprintf(resource_name, RESOURCE_NAME_SZ,
 522                     "unspecified_%s", resource_nodetype);
 523         }
 524 
 525         vfs_setresource(vfsp, resource_name, 0);
 526 
 527         kmem_free(svfsp, sizeof (statvfs64_t));
 528         kmem_free(resource_name, RESOURCE_NAME_SZ);
 529 #undef RESOURCE_NAME_SZ
 530 
 531         /*
 532          * Insert the namenode.
 533          */
 534         mutex_enter(&ntable_lock);
 535         nameinsert(nodep);
 536         mutex_exit(&ntable_lock);
 537         return (0);
 538 out:
 539         releasef(namefdp.fd);
 540         kmem_free(nodep, sizeof (struct namenode));
 541         return (error);
 542 }
 543 
 544 /*
 545  * Unmount a file descriptor from a node in the file system.
 546  * If the user is not the owner of the file and is not privileged,
 547  * the request is denied.
 548  * Otherwise, remove the namenode from the hash list.
 549  * If the mounted file descriptor was that of a stream and this
 550  * was the last mount of the stream, turn off the STRMOUNT flag.
 551  * If the rootvp is referenced other than through the mount,
 552  * nm_inactive will clean up.
 553  */
 554 static int
 555 nm_unmount(vfs_t *vfsp, int flag, cred_t *crp)
 556 {
 557         struct namenode *nodep = (struct namenode *)vfsp->vfs_data;
 558         vnode_t *vp, *thisvp;
 559         struct file *fp = NULL;
 560 
 561         ASSERT((nodep->nm_flag & NMNMNT) == 0);
 562 
 563         /*
 564          * forced unmount is not supported by this file system
 565          * and thus, ENOTSUP, is being returned.
 566          */
 567         if (flag & MS_FORCE) {
 568                 return (ENOTSUP);
 569         }
 570 
 571         vp = nodep->nm_filevp;
 572         mutex_enter(&nodep->nm_lock);
 573         if (secpolicy_vnode_owner(crp, nodep->nm_vattr.va_uid) != 0) {
 574                 mutex_exit(&nodep->nm_lock);
 575                 return (EPERM);
 576         }
 577 
 578         mutex_exit(&nodep->nm_lock);
 579 
 580         mutex_enter(&ntable_lock);
 581         nameremove(nodep);
 582         thisvp = NMTOV(nodep);
 583         mutex_enter(&thisvp->v_lock);
 584         if (thisvp->v_count-- == 1) {
 585                 fp = nodep->nm_filep;
 586                 mutex_exit(&thisvp->v_lock);
 587                 vn_invalid(thisvp);
 588                 vn_free(thisvp);
 589                 VFS_RELE(vfsp);
 590                 namenodeno_free(nodep->nm_vattr.va_nodeid);
 591                 kmem_free(nodep, sizeof (struct namenode));
 592         } else {
 593                 thisvp->v_flag &= ~VROOT;
 594                 mutex_exit(&thisvp->v_lock);
 595         }
 596         if (namefind(vp, NULLVP) == NULL && vp->v_stream) {
 597                 struct stdata *stp = vp->v_stream;
 598                 mutex_enter(&stp->sd_lock);
 599                 stp->sd_flag &= ~STRMOUNT;
 600                 mutex_exit(&stp->sd_lock);
 601         }
 602         mutex_exit(&ntable_lock);
 603         if (fp != NULL)
 604                 (void) closef(fp);
 605         return (0);
 606 }
 607 
 608 /*
 609  * Create a reference to the root of a mounted file descriptor.
 610  * This routine is called from lookupname() in the event a path
 611  * is being searched that has a mounted file descriptor in it.
 612  */
 613 static int
 614 nm_root(vfs_t *vfsp, vnode_t **vpp)
 615 {
 616         struct namenode *nodep = (struct namenode *)vfsp->vfs_data;
 617         struct vnode *vp = NMTOV(nodep);
 618 
 619         VN_HOLD(vp);
 620         *vpp = vp;
 621         return (0);
 622 }
 623 
 624 /*
 625  * Return in sp the status of this file system.
 626  */
 627 static int
 628 nm_statvfs(vfs_t *vfsp, struct statvfs64 *sp)
 629 {
 630         dev32_t d32;
 631 
 632         bzero(sp, sizeof (*sp));
 633         sp->f_bsize  = 1024;
 634         sp->f_frsize = 1024;
 635         (void) cmpldev(&d32, vfsp->vfs_dev);
 636         sp->f_fsid = d32;
 637         (void) strcpy(sp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name);
 638         sp->f_flag   = vf_to_stf(vfsp->vfs_flag);
 639         return (0);
 640 }
 641 
 642 /*
 643  * Since this file system has no disk blocks of its own, apply
 644  * the VOP_FSYNC operation on the mounted file descriptor.
 645  */
 646 static int
 647 nm_sync(vfs_t *vfsp, short flag, cred_t *crp)
 648 {
 649         struct namenode *nodep;
 650 
 651         if (vfsp == NULL)
 652                 return (0);
 653 
 654         nodep = (struct namenode *)vfsp->vfs_data;
 655         if (flag & SYNC_CLOSE)
 656                 return (nm_umountall(nodep->nm_filevp, crp));
 657 
 658         return (VOP_FSYNC(nodep->nm_filevp, FSYNC, crp, NULL));
 659 }
 660 
 661 /*
 662  * File system initialization routine. Save the file system type,
 663  * establish a file system device number and initialize nm_filevp_hash[].
 664  */
 665 int
 666 nameinit(int fstype, char *name)
 667 {
 668         static const fs_operation_def_t nm_vfsops_template[] = {
 669                 { VFSNAME_MOUNT,        { .vfs_mount = nm_mount } },
 670                 { VFSNAME_UNMOUNT,      { .vfs_unmount = nm_unmount } },
 671                 { VFSNAME_ROOT,         { .vfs_root = nm_root } },
 672                 { VFSNAME_STATVFS,      { .vfs_statvfs = nm_statvfs } },
 673                 { VFSNAME_SYNC,         { .vfs_sync = nm_sync } },
 674                 { NULL,                 { NULL } }
 675         };
 676         static const fs_operation_def_t nm_dummy_vfsops_template[] = {
 677                 { VFSNAME_STATVFS,      { .vfs_statvfs = nm_statvfs } },
 678                 { VFSNAME_SYNC,         { .vfs_sync = nm_sync } },
 679                 { NULL,                 { NULL } }
 680         };
 681         int error;
 682         int dev;
 683         vfsops_t *dummy_vfsops;
 684 
 685         error = vfs_setfsops(fstype, nm_vfsops_template, &namefs_vfsops);
 686         if (error != 0) {
 687                 cmn_err(CE_WARN, "nameinit: bad vfs ops template");
 688                 return (error);
 689         }
 690 
 691         error = vfs_makefsops(nm_dummy_vfsops_template, &dummy_vfsops);
 692         if (error != 0) {
 693                 (void) vfs_freevfsops_by_type(fstype);
 694                 cmn_err(CE_WARN, "nameinit: bad dummy vfs ops template");
 695                 return (error);
 696         }
 697 
 698         error = vn_make_ops(name, nm_vnodeops_template, &nm_vnodeops);
 699         if (error != 0) {
 700                 (void) vfs_freevfsops_by_type(fstype);
 701                 vfs_freevfsops(dummy_vfsops);
 702                 cmn_err(CE_WARN, "nameinit: bad vnode ops template");
 703                 return (error);
 704         }
 705 
 706         namefstype = fstype;
 707 
 708         if ((dev = getudev()) == (major_t)-1) {
 709                 cmn_err(CE_WARN, "nameinit: can't get unique device");
 710                 dev = 0;
 711         }
 712         mutex_init(&ntable_lock, NULL, MUTEX_DEFAULT, NULL);
 713         namedev = makedevice(dev, 0);
 714         bzero(nm_filevp_hash, sizeof (nm_filevp_hash));
 715         vfs_setops(&namevfs, dummy_vfsops);
 716         namevfs.vfs_vnodecovered = NULL;
 717         namevfs.vfs_bsize = 1024;
 718         namevfs.vfs_fstype = namefstype;
 719         vfs_make_fsid(&namevfs.vfs_fsid, namedev, namefstype);
 720         namevfs.vfs_dev = namedev;
 721         return (0);
 722 }
 723 
 724 static mntopts_t nm_mntopts = {
 725         NULL,
 726         0
 727 };
 728 
 729 static vfsdef_t vfw = {
 730         VFSDEF_VERSION,
 731         "namefs",
 732         nameinit,
 733         VSW_HASPROTO | VSW_ZMOUNT,
 734         &nm_mntopts
 735 };
 736 
 737 /*
 738  * Module linkage information for the kernel.
 739  */
 740 static struct modlfs modlfs = {
 741         &mod_fsops, "filesystem for namefs", &vfw
 742 };
 743 
 744 static struct modlinkage modlinkage = {
 745         MODREV_1, { (void *)&modlfs, NULL }
 746 };
 747 
 748 int
 749 _init(void)
 750 {
 751         namenodeno_init();
 752         return (mod_install(&modlinkage));
 753 }
 754 
 755 int
 756 _fini(void)
 757 {
 758         return (EBUSY);
 759 }
 760 
 761 int
 762 _info(struct modinfo *modinfop)
 763 {
 764         return (mod_info(&modlinkage, modinfop));
 765 }