libsysio/src/mount.c

   1 /*
   2  *    This Cplant(TM) source code is the property of Sandia National
   3  *    Laboratories.
   4  *
   5  *    This Cplant(TM) source code is copyrighted by Sandia National
   6  *    Laboratories.
   7  *
   8  *    The redistribution of this Cplant(TM) source code is subject to the
   9  *    terms of the GNU Lesser General Public License
  10  *    (see cit/LGPL or http://www.gnu.org/licenses/lgpl.html)
  11  *
  12  *    Cplant(TM) Copyright 1998-2004 Sandia Corporation.
  13  *    Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
  14  *    license for use of this work by or on behalf of the US Government.
  15  *    Export of this program may require a license from the United States
  16  *    Government.
  17  */
  18
  19 /*
  20  * This library is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU Lesser General Public
  22  * License as published by the Free Software Foundation; either
  23  * version 2.1 of the License, or (at your option) any later version.
  24  *
  25  * This library is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  28  * Lesser General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU Lesser General Public
  31  * License along with this library; if not, write to the Free Software
  32  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  33  *
  34  * Questions or comments about this library should be sent to:
  35  *
  36  * Lee Ward
  37  * Sandia National Laboratories, New Mexico
  38  * P.O. Box 5800
  39  * Albuquerque, NM 87185-1110
  40  *
  41  * lee@sandia.gov
  42  */
  43
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <errno.h>
  47 #include <assert.h>
  48 #include <sys/types.h>
  49 #include <sys/stat.h>
  50 #ifdef AUTOMOUNT_FILE_NAME
  51 #include <fcntl.h>
  52 #include <sys/uio.h>
  53 #endif
  54 #include <sys/queue.h>
  55
  56 #include "sysio.h"
  57 #include "xtio.h"
  58 #include "fs.h"
  59 #include "mount.h"
  60 #include "inode.h"
  61
  62 /*
  63  * File system and volume mount support.
  64  */
  65
  66 #ifdef AUTOMOUNT_FILE_NAME
  67 /*
  68  * Name of autmount specification file in a directory with
  69  * the sticky-bit set.
  70  */
  71 struct qstr _sysio_mount_file_name = { "", 0, 0 };
  72 #endif
  73
  74 /*
  75  * Active mounts.
  76  */
  77 static LIST_HEAD(, mount) mounts;
  78
  79 static int _sysio_sub_fsswop_mount(const char *source,
  80                                    unsigned flags,
  81                                    const void *data,
  82                                    struct pnode *tocover,
  83                                    struct mount **mntp);
  84
  85 static struct fssw_ops _sysio_sub_fssw_ops = {
  86         _sysio_sub_fsswop_mount
  87 };
  88
  89 /*
  90  * Initialization. Must be called before any other routine in this module.
  91  */
  92 int
  93 _sysio_mount_init()
  94 {
  95         int     err;
  96
  97         LIST_INIT(&mounts);
  98 #ifdef AUTOMOUNT_FILE_NAME
  99         _sysio_next_component(AUTOMOUNT_FILE_NAME, &_sysio_mount_file_name);
 100 #endif
 101
 102         /*
 103          * Register the sub-trees "file system" driver.
 104          */
 105         err = _sysio_fssw_register("sub", &_sysio_sub_fssw_ops);
 106         if (err)
 107                 return err;
 108
 109         return 0;
 110 }
 111
 112 /*
 113  * Mount rooted sub-tree somewhere in the existing name space.
 114  */
 115 int
 116 _sysio_do_mount(struct filesys *fs,
 117                 struct pnode_base *rootpb,
 118                 unsigned flags,
 119                 struct pnode *tocover,
 120                 struct mount **mntp)
 121 {
 122         struct mount *mnt;
 123         int     err;
 124
 125         /*
 126          * It's really poor form to allow the new root to be a
 127          * descendant of the pnode being covered.
 128          */
 129         if (tocover) {
 130                 struct pnode_base *pb;
 131
 132                 for (pb = rootpb;
 133                      pb && pb != tocover->p_base;
 134                      pb = pb->pb_parent)
 135                         ;
 136                 if (pb == tocover->p_base)
 137                         return -EBUSY;
 138         }
 139
 140         /*
 141          * Alloc
 142          */
 143         mnt = malloc(sizeof(struct mount));
 144         if (!mnt)
 145                 return -ENOMEM;
 146         err = 0;
 147         /*
 148          * Init enough to make the mount record usable to the path node
 149          * generation routines.
 150          */
 151         mnt->mnt_fs = fs;
 152         if (fs->fs_flags & FS_F_RO) {
 153                 /*
 154                  * Propagate the read-only flag -- Whether they set it or not.
 155                  */
 156                 flags |= MOUNT_F_RO;
 157         }
 158         mnt->mnt_flags = flags;
 159         /*
 160          * Get alias for the new root.
 161          */
 162         mnt->mnt_root =
 163             _sysio_p_new_alias(tocover ? tocover->p_parent : NULL, rootpb, mnt);
 164         if (!mnt->mnt_root) {
 165                 err = -ENOMEM;
 166                 goto error;
 167         }
 168         /*
 169          * It may have been a while since the root inode was validated;
 170          * better validate again.  And it better be a directory!
 171          */
 172         err = _sysio_p_validate(mnt->mnt_root, NULL, NULL);
 173         if (err)
 174                 goto error;
 175
 176         if (!S_ISDIR(mnt->mnt_root->p_base->pb_ino->i_stbuf.st_mode)) {
 177                 err = -ENOTDIR;
 178                 goto error;
 179         }
 180         /*
 181          * Cover up the mount point.
 182          */
 183         mnt->mnt_covers = tocover;
 184         if (!mnt->mnt_covers) {
 185                 /*
 186                  * New graph; It covers itself.
 187                  */
 188                 mnt->mnt_covers = tocover = mnt->mnt_root;
 189         }
 190         assert(!tocover->p_cover);
 191         tocover->p_cover = mnt->mnt_root;
 192
 193         LIST_INSERT_HEAD(&mounts, mnt, mnt_link);
 194
 195         *mntp = mnt;
 196         return 0;
 197
 198 error:
 199         if (mnt->mnt_root) {
 200                 P_RELE(mnt->mnt_root);
 201                 _sysio_p_prune(mnt->mnt_root);
 202         }
 203         free(mnt);
 204         return err;
 205 }
 206
 207 /*
 208  * Remove mounted sub-tree from the system.
 209  */
 210 int
 211 _sysio_do_unmount(struct mount *mnt)
 212 {
 213         struct pnode *root;
 214         struct filesys *fs;
 215
 216         root = mnt->mnt_root;
 217         if (root->p_cover && root->p_cover != root) {
 218                 /*
 219                  * Active mount.
 220                  */
 221                 return -EBUSY;
 222         }
 223         assert(mnt->mnt_covers->p_cover == root);
 224         if (_sysio_p_prune(root) != 1) {
 225                 /*
 226                  * Active aliases.
 227                  */
 228                 return -EBUSY;
 229         }
 230         /*
 231          * We're committed.
 232          *
 233          * Drop ref of covered pnode and break linkage in name space.
 234          */
 235         if (root->p_cover != root)
 236                 P_RELE(mnt->mnt_covers);
 237         mnt->mnt_covers->p_cover = NULL;
 238         LIST_REMOVE(mnt, mnt_link);
 239         /*
 240          * Kill the root.
 241          */
 242         P_RELE(root);
 243         root->p_cover = NULL;
 244         _sysio_p_gone(root);
 245         /*
 246          * Release mount record resource.
 247          */
 248         fs = mnt->mnt_fs;
 249         free(mnt);
 250         FS_RELE(fs);
 251
 252         return 0;
 253 }
 254
 255 /*
 256  * Establish the system name space.
 257  */
 258 int
 259 _sysio_mount_root(const char *source,
 260                   const char *fstype,
 261                   unsigned flags,
 262                   const void *data)
 263 {
 264         struct fsswent *fssw;
 265         int     err;
 266         struct mount *mnt;
 267
 268         if (_sysio_root)
 269                 return -EBUSY;
 270
 271         fssw = _sysio_fssw_lookup(fstype);
 272         if (!fssw)
 273                 return -ENODEV;
 274
 275         err = (*fssw->fssw_ops.fsswop_mount)(source, flags, data, NULL, &mnt);
 276         if (err)
 277                 return err;
 278
 279         _sysio_root = mnt->mnt_root;
 280 #ifndef DEFER_INIT_CWD
 281         /*
 282          * It is very annoying to have to set the current working directory.
 283          * So... If it isn't set, make it the root now.
 284          */
 285         if (!_sysio_cwd) {
 286                 _sysio_cwd = _sysio_root;
 287                 P_REF(_sysio_cwd);
 288         }
 289 #endif
 290
 291         return 0;
 292 }
 293
 294 int
 295 _sysio_mount(struct pnode *cwd,
 296              const char *source,
 297              const char *target,
 298              const char *filesystemtype,
 299              unsigned long mountflags,
 300              const void *data)
 301 {
 302         int     err;
 303         struct fsswent *fssw;
 304         struct intent intent;
 305         struct pnode *tgt;
 306         struct mount *mnt;
 307
 308         /*
 309          * Find the file system switch entry specified.
 310          */
 311         fssw = _sysio_fssw_lookup(filesystemtype);
 312         if (!fssw)
 313                 return -ENODEV;
 314
 315         /*
 316          * Look up the target path node.
 317          */
 318         INTENT_INIT(&intent, INT_GETATTR, NULL, NULL);
 319         err = _sysio_namei(cwd, target, 0, &intent, &tgt);
 320         if (err)
 321                 return err;
 322
 323         if (tgt == _sysio_root) {
 324                 /*
 325                  * Attempting to mount over root.
 326                  */
 327                 err = -EBUSY;
 328         } else {
 329                 /*
 330                  * Do the deed.
 331                  */
 332                 err =
 333                     (*fssw->fssw_ops.fsswop_mount)(source,
 334                                                    mountflags,
 335                                                    data,
 336                                                    tgt,
 337                                                    &mnt);
 338         }
 339         if (err)
 340                 P_RELE(tgt);
 341         return err;
 342 }
 343
 344 int
 345 SYSIO_INTERFACE_NAME(mount)(const char *source,
 346       const char *target,
 347       const char *filesystemtype,
 348       unsigned long mountflags,
 349       const void *data)
 350 {
 351         int     err;
 352         SYSIO_INTERFACE_DISPLAY_BLOCK;
 353
 354         SYSIO_INTERFACE_ENTER;
 355         err =
 356             _sysio_mount(_sysio_cwd,
 357                          source,
 358                          target,
 359                          filesystemtype,
 360                          mountflags,
 361                          data);
 362         SYSIO_INTERFACE_RETURN(err ? -1 : 0, err);
 363 }
 364
 365 int
 366 SYSIO_INTERFACE_NAME(umount)(const char *target)
 367 {
 368         int     err;
 369         struct pnode *pno;
 370         SYSIO_INTERFACE_DISPLAY_BLOCK;
 371
 372         SYSIO_INTERFACE_ENTER;
 373         /*
 374          * Look up the target path node.
 375          */
 376         err = _sysio_namei(_sysio_cwd, target, 0, NULL, &pno);
 377         if (err)
 378                 goto out;
 379         P_RELE(pno);                            /* was ref'd */
 380
 381         /*
 382          * Do the deed.
 383          */
 384 #if 0
 385         if (!pno->p_cover) {
 386                 err = -EINVAL;
 387                 goto error;
 388         }
 389 #endif
 390         assert(pno->p_mount);
 391         err = _sysio_do_unmount(pno->p_mount);
 392
 393 out:
 394         SYSIO_INTERFACE_RETURN(err ? -1 : 0, err);
 395 }
 396
 397 /*
 398  * Unmount all file systems -- Usually as part of shutting everything down.
 399  */
 400 int
 401 _sysio_unmount_all()
 402 {
 403         int     err;
 404         struct mount *mnt, *nxt;
 405         struct pnode *pno;
 406
 407         err = 0;
 408         nxt = mounts.lh_first;
 409         while ((mnt = nxt)) {
 410                 nxt = mnt->mnt_link.le_next;
 411                 pno = mnt->mnt_root;
 412                 /*
 413                  * If this is an automount generated mount, the root
 414                  * has no reference. We can cause the dismount with a
 415                  * simple prune.
 416                  */
 417                 if (!_sysio_p_prune(pno))
 418                         continue;
 419 #ifdef notdef
 420                 /*
 421                  * Need a ref but only if this is not the root of a
 422                  * disconnected graph. If it is, then it is covered by itself
 423                  * and, so, already referenced.
 424                  */
 425                 if (pno->p_cover != pno)
 426                         P_REF(pno);
 427 #endif
 428                 err = _sysio_do_unmount(mnt);
 429                 if (err) {
 430 #ifdef notdef
 431                         if (pno->p_cover != pno)
 432                                 P_RELE(pno);
 433 #endif
 434                         break;
 435                 }
 436                 if (pno == _sysio_root)
 437                         _sysio_root = NULL;
 438         }
 439
 440         return err;
 441 }
 442
 443 static int
 444 _sysio_sub_fsswop_mount(const char *source,
 445                         unsigned flags,
 446                         const void *data __IS_UNUSED,
 447                         struct pnode *tocover,
 448                         struct mount **mntp)
 449 {
 450         int     err;
 451         struct nameidata nameidata;
 452         struct mount *mnt;
 453
 454         /*
 455          * How can we make a sub-mount from nothing?
 456          */
 457         if (!_sysio_root)
 458                 return -EBUSY;
 459
 460         /*
 461          * Lookup the source.
 462          */
 463         ND_INIT(&nameidata, 0, source, _sysio_root, NULL);
 464         err = _sysio_path_walk(_sysio_root, &nameidata);
 465         if (err)
 466                 return err;
 467
 468         /*
 469          * Mount the rooted sub-tree at the given position.
 470          */
 471         err =
 472             _sysio_do_mount(nameidata.nd_pno->p_mount->mnt_fs,
 473                             nameidata.nd_pno->p_base,
 474                             nameidata.nd_pno->p_mount->mnt_flags & flags,
 475                             tocover,
 476                             &mnt);
 477
 478         /*
 479          * Clean up and return.
 480          */
 481         if (!err) {
 482                 FS_REF(nameidata.nd_pno->p_mount->mnt_fs);
 483                 *mntp = mnt;
 484         }
 485         P_RELE(nameidata.nd_pno);
 486         return err;
 487 }
 488
 489 #ifdef AUTOMOUNT_FILE_NAME
 490 /*
 491  * Parse automount specification formatted as:
 492  *
 493  * <fstype>:<source>[[ \t]+<comma-separated-mount-options>]
 494  *
 495  * NB:
 496  * The buffer sent is (almost) always modified.
 497  */
 498 static int
 499 parse_automount_spec(char *s, char **fstyp, char **srcp, char **optsp)
 500 {
 501         int     err;
 502         char    *cp;
 503         char    *fsty, *src, *opts;
 504
 505         err = 0;
 506
 507         /*
 508          * Eat leading white.
 509          */
 510         while (*s && *s == ' ' && *s == '\t')
 511                 s++;
 512         /*
 513          * Get fstype.
 514          */
 515         fsty = cp = s;
 516         while (*cp &&
 517                *cp != ':' &&
 518                *cp != ' ' &&
 519                *cp != '\t' &&
 520                *cp != '\r' &&
 521                *cp != '\n')
 522                 cp++;
 523         if (fsty == cp || *cp != ':')
 524                 goto error;
 525         *cp++ = '\0';
 526
 527         s = cp;
 528         /*
 529          * Eat leading white.
 530          */
 531         while (*s && *s == ' ' && *s == '\t')
 532                 s++;
 533         /*
 534          * Get source.
 535          */
 536         src = cp = s;
 537         while (*cp &&
 538                *cp != ' ' &&
 539                *cp != '\t' &&
 540                *cp != '\r' &&
 541                *cp != '\n')
 542                 cp++;
 543         if (src == cp)
 544                 goto error;
 545         if (*cp)
 546                 *cp++ = '\0';
 547
 548         s = cp;
 549         /*
 550          * Eat leading white.
 551          */
 552         while (*s && *s == ' ' && *s == '\t')
 553                 s++;
 554         /*
 555          * Get opts.
 556          */
 557         opts = cp = s;
 558         while (*cp &&
 559                *cp != ' ' &&
 560                *cp != '\t' &&
 561                *cp != '\r' &&
 562                *cp != '\n')
 563                 cp++;
 564         if (opts == cp)
 565                 opts = NULL;
 566         if (*cp)
 567                 *cp++ = '\0';
 568
 569         if (*cp)
 570                 goto error;
 571
 572         *fstyp = fsty;
 573         *srcp = src;
 574         *optsp = opts;
 575         return 0;
 576
 577 error:
 578         return -EINVAL;
 579 }
 580
 581 /*
 582  * Parse (and strip) system mount options.
 583  */
 584 static char *
 585 parse_opts(char *opts, unsigned *flagsp)
 586 {
 587         unsigned flags;
 588         char    *src, *dst;
 589         char    *cp;
 590
 591         flags = 0;
 592         src = dst = opts;
 593         for (;;) {
 594                 cp = src;
 595                 while (*cp && *cp != ',')
 596                         cp++;
 597                 if (src + 2 == cp && strncmp(src, "rw", 2) == 0) {
 598                         /*
 599                          * Do nothing. This is the default.
 600                          */
 601                         src += 2;
 602                 } else if (src + 2 == cp && strncmp(src, "ro", 2) == 0) {
 603                         /*
 604                          * Read-only.
 605                          */
 606                         flags |= MOUNT_F_RO;
 607                         src += 2;
 608                 }
 609                 else if (src + 4 == cp && strncmp(src, "auto", 4) == 0) {
 610                         /*
 611                          * Enable automounts.
 612                          */
 613                         flags |= MOUNT_F_AUTO;
 614                         src += 4;
 615                 }
 616                 if (src < cp) {
 617                         /*
 618                          * Copy what we didn't consume.
 619                          */
 620                         if (dst != opts)
 621                                 *dst++ = ',';
 622                         do
 623                                 *dst++ = *src++;
 624                         while (src != cp);
 625                 }
 626                 if (!*src)
 627                         break;
 628                 *dst = '\0';
 629                 src++;                                  /* skip comma */
 630         }
 631         *dst = '\0';
 632
 633         *flagsp = flags;
 634         return opts;
 635 }
 636
 637 /*
 638  * Attempt automount over the given directory.
 639  */
 640 int
 641 _sysio_automount(struct pnode *mntpno)
 642 {
 643         int     err;
 644         struct inode *ino;
 645         struct iovec iovec;
 646         struct ioctx iocontext;
 647         struct intnl_xtvec xtvec;
 648         ssize_t cc;
 649         char    *fstype, *source, *opts;
 650         unsigned flags;
 651         struct fsswent *fssw;
 652         struct mount *mnt;
 653
 654         /*
 655          * Revalidate -- Paranoia.
 656          */
 657         err = _sysio_p_validate(mntpno, NULL, NULL);
 658         if (err)
 659                 return err;
 660
 661         /*
 662          * Read file content.
 663          */
 664         ino = mntpno->p_base->pb_ino;
 665         if (ino->i_stbuf.st_size > 64 * 1024) {
 666                 /*
 667                  * Let's be reasonable.
 668                  */
 669                 return -EINVAL;
 670         }
 671         iovec.iov_base = malloc(ino->i_stbuf.st_size + 1);
 672         if (!iovec.iov_base)
 673                 return -ENOMEM;
 674         iovec.iov_len = ino->i_stbuf.st_size;
 675         err = _sysio_open(mntpno, O_RDONLY, 0);
 676         if (err)
 677                 goto out;
 678         xtvec.xtv_off = 0;
 679         xtvec.xtv_len = ino->i_stbuf.st_size;
 680         IOCTX_INIT(&iocontext,
 681                    1,
 682                    0,
 683                    ino,
 684                    &iovec, 1,
 685                    &xtvec, 1);
 686         _sysio_ioctx_enter(&iocontext);
 687         err = (*ino->i_ops.inop_read)(ino, &iocontext);
 688         if (err) {
 689                 _sysio_ioctx_complete(&iocontext);
 690                 (void )(*ino->i_ops.inop_close)(ino);
 691                 goto out;
 692         }
 693         cc = _sysio_ioctx_wait(&iocontext);
 694         err = (*ino->i_ops.inop_close)(ino);
 695         if (err)
 696                 goto out;
 697         if (cc < 0) {
 698                 err = (int )cc;
 699                 goto out;
 700         }
 701         ((char *)iovec.iov_base)[cc] = '\0';
 702
 703         /*
 704          * Parse.
 705          */
 706         err = parse_automount_spec(iovec.iov_base, &fstype, &source, &opts);
 707         if (err)
 708                 goto out;
 709         flags = 0;
 710         if (opts)
 711                 opts = parse_opts(opts, &flags);
 712
 713         /*
 714          * Find the file system switch entry specified.
 715          */
 716         fssw = _sysio_fssw_lookup(fstype);
 717         if (!fssw) {
 718                 err = -ENODEV;
 719                 goto out;
 720         }
 721
 722         /*
 723          * Do the deed.
 724          */
 725         P_REF(mntpno->p_parent);
 726         err =
 727             (*fssw->fssw_ops.fsswop_mount)(source,
 728                                            flags,
 729                                            opts,
 730                                            mntpno->p_parent,
 731                                            &mnt);
 732         if (err)
 733                 P_RELE(mntpno->p_parent);
 734
 735 out:
 736         if (iovec.iov_base)
 737                 free(iovec.iov_base);
 738         return err;
 739 }
 740 #endif