mount_zfs.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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 https://opensource.org/licenses/CDDL-1.0.
   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 /*
   23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
   24  * Copyright (c) 2011 Lawrence Livermore National Security, LLC.
   25  */
   26 
   27 #include <libintl.h>
   28 #include <unistd.h>
   29 #include <sys/file.h>
   30 #include <sys/mount.h>
   31 #include <sys/mntent.h>
   32 #include <sys/stat.h>
   33 #include <libzfs.h>
   34 #include <libzutil.h>
   35 #include <locale.h>
   36 #include <getopt.h>
   37 #include <fcntl.h>
   38 #include <errno.h>
   39 
   40 #define ZS_COMMENT      0x00000000      /* comment */
   41 #define ZS_ZFSUTIL      0x00000001      /* caller is zfs(8) */
   42 
   43 libzfs_handle_t *g_zfs;
   44 
   45 /*
   46  * Opportunistically convert a target string into a pool name. If the
   47  * string does not represent a block device with a valid zfs label
   48  * then it is passed through without modification.
   49  */
   50 static void
   51 parse_dataset(const char *target, char **dataset)
   52 {
   53         /*
   54          * Prior to util-linux 2.36.2, if a file or directory in the
   55          * current working directory was named 'dataset' then mount(8)
   56          * would prepend the current working directory to the dataset.
   57          * Check for it and strip the prepended path when it is added.
   58          */
   59         char cwd[PATH_MAX];
   60         if (getcwd(cwd, PATH_MAX) == NULL) {
   61                 perror("getcwd");
   62                 return;
   63         }
   64         int len = strlen(cwd);
   65         if (strncmp(cwd, target, len) == 0)
   66                 target += len;
   67 
   68         /* Assume pool/dataset is more likely */
   69         strlcpy(*dataset, target, PATH_MAX);
   70 
   71         int fd = open(target, O_RDONLY | O_CLOEXEC);
   72         if (fd < 0)
   73                 return;
   74 
   75         nvlist_t *cfg = NULL;
   76         if (zpool_read_label(fd, &cfg, NULL) == 0) {
   77                 char *nm = NULL;
   78                 if (!nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &nm))
   79                         strlcpy(*dataset, nm, PATH_MAX);
   80                 nvlist_free(cfg);
   81         }
   82 
   83         if (close(fd))
   84                 perror("close");
   85 }
   86 
   87 /*
   88  * Update the mtab_* code to use the libmount library when it is commonly
   89  * available otherwise fallback to legacy mode.  The mount(8) utility will
   90  * manage the lock file for us to prevent racing updates to /etc/mtab.
   91  */
   92 static int
   93 mtab_is_writeable(void)
   94 {
   95         struct stat st;
   96         int error, fd;
   97 
   98         error = lstat("/etc/mtab", &st);
   99         if (error || S_ISLNK(st.st_mode))
  100                 return (0);
  101 
  102         fd = open("/etc/mtab", O_RDWR | O_CREAT, 0644);
  103         if (fd < 0)
  104                 return (0);
  105 
  106         close(fd);
  107         return (1);
  108 }
  109 
  110 static int
  111 mtab_update(const char *dataset, const char *mntpoint, const char *type,
  112     const char *mntopts)
  113 {
  114         struct mntent mnt;
  115         FILE *fp;
  116         int error;
  117 
  118         mnt.mnt_fsname = (char *)dataset;
  119         mnt.mnt_dir = (char *)mntpoint;
  120         mnt.mnt_type = (char *)type;
  121         mnt.mnt_opts = (char *)(mntopts ?: "");
  122         mnt.mnt_freq = 0;
  123         mnt.mnt_passno = 0;
  124 
  125         fp = setmntent("/etc/mtab", "a+e");
  126         if (!fp) {
  127                 (void) fprintf(stderr, gettext(
  128                     "filesystem '%s' was mounted, but /etc/mtab "
  129                     "could not be opened due to error: %s\n"),
  130                     dataset, strerror(errno));
  131                 return (MOUNT_FILEIO);
  132         }
  133 
  134         error = addmntent(fp, &mnt);
  135         if (error) {
  136                 (void) fprintf(stderr, gettext(
  137                     "filesystem '%s' was mounted, but /etc/mtab "
  138                     "could not be updated due to error: %s\n"),
  139                     dataset, strerror(errno));
  140                 return (MOUNT_FILEIO);
  141         }
  142 
  143         (void) endmntent(fp);
  144 
  145         return (MOUNT_SUCCESS);
  146 }
  147 
  148 int
  149 main(int argc, char **argv)
  150 {
  151         zfs_handle_t *zhp;
  152         char prop[ZFS_MAXPROPLEN];
  153         uint64_t zfs_version = 0;
  154         char mntopts[MNT_LINE_MAX] = { '\0' };
  155         char badopt[MNT_LINE_MAX] = { '\0' };
  156         char mtabopt[MNT_LINE_MAX] = { '\0' };
  157         char mntpoint[PATH_MAX];
  158         char dataset[PATH_MAX], *pdataset = dataset;
  159         unsigned long mntflags = 0, zfsflags = 0, remount = 0;
  160         int sloppy = 0, fake = 0, verbose = 0, nomtab = 0, zfsutil = 0;
  161         int error, c;
  162 
  163         (void) setlocale(LC_ALL, "");
  164         (void) setlocale(LC_NUMERIC, "C");
  165         (void) textdomain(TEXT_DOMAIN);
  166 
  167         opterr = 0;
  168 
  169         /* check options */
  170         while ((c = getopt_long(argc, argv, "sfnvo:h?", 0, 0)) != -1) {
  171                 switch (c) {
  172                 case 's':
  173                         sloppy = 1;
  174                         break;
  175                 case 'f':
  176                         fake = 1;
  177                         break;
  178                 case 'n':
  179                         nomtab = 1;
  180                         break;
  181                 case 'v':
  182                         verbose++;
  183                         break;
  184                 case 'o':
  185                         (void) strlcpy(mntopts, optarg, sizeof (mntopts));
  186                         break;
  187                 case 'h':
  188                 case '?':
  189                         if (optopt)
  190                                 (void) fprintf(stderr,
  191                                     gettext("Invalid option '%c'\n"), optopt);
  192                         (void) fprintf(stderr, gettext("Usage: mount.zfs "
  193                             "[-sfnvh] [-o options] <dataset> <mountpoint>\n"));
  194                         return (MOUNT_USAGE);
  195                 }
  196         }
  197 
  198         argc -= optind;
  199         argv += optind;
  200 
  201         /* check that we only have two arguments */
  202         if (argc != 2) {
  203                 if (argc == 0)
  204                         (void) fprintf(stderr, gettext("missing dataset "
  205                             "argument\n"));
  206                 else if (argc == 1)
  207                         (void) fprintf(stderr,
  208                             gettext("missing mountpoint argument\n"));
  209                 else
  210                         (void) fprintf(stderr, gettext("too many arguments\n"));
  211                 (void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n");
  212                 return (MOUNT_USAGE);
  213         }
  214 
  215         parse_dataset(argv[0], &pdataset);
  216 
  217         /* canonicalize the mount point */
  218         if (realpath(argv[1], mntpoint) == NULL) {
  219                 (void) fprintf(stderr, gettext("filesystem '%s' cannot be "
  220                     "mounted at '%s' due to canonicalization error: %s\n"),
  221                     dataset, argv[1], strerror(errno));
  222                 return (MOUNT_SYSERR);
  223         }
  224 
  225         /* validate mount options and set mntflags */
  226         error = zfs_parse_mount_options(mntopts, &mntflags, &zfsflags, sloppy,
  227             badopt, mtabopt);
  228         if (error) {
  229                 switch (error) {
  230                 case ENOMEM:
  231                         (void) fprintf(stderr, gettext("filesystem '%s' "
  232                             "cannot be mounted due to a memory allocation "
  233                             "failure.\n"), dataset);
  234                         return (MOUNT_SYSERR);
  235                 case ENOENT:
  236                         (void) fprintf(stderr, gettext("filesystem '%s' "
  237                             "cannot be mounted due to invalid option "
  238                             "'%s'.\n"), dataset, badopt);
  239                         (void) fprintf(stderr, gettext("Use the '-s' option "
  240                             "to ignore the bad mount option.\n"));
  241                         return (MOUNT_USAGE);
  242                 default:
  243                         (void) fprintf(stderr, gettext("filesystem '%s' "
  244                             "cannot be mounted due to internal error %d.\n"),
  245                             dataset, error);
  246                         return (MOUNT_SOFTWARE);
  247                 }
  248         }
  249 
  250         if (mntflags & MS_REMOUNT) {
  251                 nomtab = 1;
  252                 remount = 1;
  253         }
  254 
  255         if (zfsflags & ZS_ZFSUTIL)
  256                 zfsutil = 1;
  257 
  258         if ((g_zfs = libzfs_init()) == NULL) {
  259                 (void) fprintf(stderr, "%s\n", libzfs_error_init(errno));
  260                 return (MOUNT_SYSERR);
  261         }
  262 
  263         /* try to open the dataset to access the mount point */
  264         if ((zhp = zfs_open(g_zfs, dataset,
  265             ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT)) == NULL) {
  266                 (void) fprintf(stderr, gettext("filesystem '%s' cannot be "
  267                     "mounted, unable to open the dataset\n"), dataset);
  268                 libzfs_fini(g_zfs);
  269                 return (MOUNT_USAGE);
  270         }
  271 
  272         if (!zfsutil || sloppy ||
  273             libzfs_envvar_is_set("ZFS_MOUNT_HELPER")) {
  274                 zfs_adjust_mount_options(zhp, mntpoint, mntopts, mtabopt);
  275         }
  276 
  277         /* treat all snapshots as legacy mount points */
  278         if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT)
  279                 (void) strlcpy(prop, ZFS_MOUNTPOINT_LEGACY, ZFS_MAXPROPLEN);
  280         else
  281                 (void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, prop,
  282                     sizeof (prop), NULL, NULL, 0, B_FALSE);
  283 
  284         /*
  285          * Fetch the max supported zfs version in case we get ENOTSUP
  286          * back from the mount command, since we need the zfs handle
  287          * to do so.
  288          */
  289         zfs_version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
  290         if (zfs_version == 0) {
  291                 fprintf(stderr, gettext("unable to fetch "
  292                     "ZFS version for filesystem '%s'\n"), dataset);
  293                 zfs_close(zhp);
  294                 libzfs_fini(g_zfs);
  295                 return (MOUNT_SYSERR);
  296         }
  297 
  298         /*
  299          * Legacy mount points may only be mounted using 'mount', never using
  300          * 'zfs mount'.  However, since 'zfs mount' actually invokes 'mount'
  301          * we differentiate the two cases using the 'zfsutil' mount option.
  302          * This mount option should only be supplied by the 'zfs mount' util.
  303          *
  304          * The only exception to the above rule is '-o remount' which is
  305          * always allowed for non-legacy datasets.  This is done because when
  306          * using zfs as your root file system both rc.sysinit/umountroot and
  307          * systemd depend on 'mount -o remount <mountpoint>' to work.
  308          */
  309         if (zfsutil && (strcmp(prop, ZFS_MOUNTPOINT_LEGACY) == 0)) {
  310                 (void) fprintf(stderr, gettext(
  311                     "filesystem '%s' cannot be mounted using 'zfs mount'.\n"
  312                     "Use 'zfs set mountpoint=%s' or 'mount -t zfs %s %s'.\n"
  313                     "See zfs(8) for more information.\n"),
  314                     dataset, mntpoint, dataset, mntpoint);
  315                 zfs_close(zhp);
  316                 libzfs_fini(g_zfs);
  317                 return (MOUNT_USAGE);
  318         }
  319 
  320         if (!zfsutil && !(remount || fake) &&
  321             strcmp(prop, ZFS_MOUNTPOINT_LEGACY)) {
  322                 (void) fprintf(stderr, gettext(
  323                     "filesystem '%s' cannot be mounted using 'mount'.\n"
  324                     "Use 'zfs set mountpoint=%s' or 'zfs mount %s'.\n"
  325                     "See zfs(8) for more information.\n"),
  326                     dataset, "legacy", dataset);
  327                 zfs_close(zhp);
  328                 libzfs_fini(g_zfs);
  329                 return (MOUNT_USAGE);
  330         }
  331 
  332         if (verbose)
  333                 (void) fprintf(stdout, gettext("mount.zfs:\n"
  334                     "  dataset:    \"%s\"\n  mountpoint: \"%s\"\n"
  335                     "  mountflags: 0x%lx\n  zfsflags:   0x%lx\n"
  336                     "  mountopts:  \"%s\"\n  mtabopts:   \"%s\"\n"),
  337                     dataset, mntpoint, mntflags, zfsflags, mntopts, mtabopt);
  338 
  339         if (!fake) {
  340                 if (zfsutil && !sloppy &&
  341                     !libzfs_envvar_is_set("ZFS_MOUNT_HELPER")) {
  342                         error = zfs_mount_at(zhp, mntopts, mntflags, mntpoint);
  343                         if (error) {
  344                                 (void) fprintf(stderr, "zfs_mount_at() failed: "
  345                                     "%s", libzfs_error_description(g_zfs));
  346                                 zfs_close(zhp);
  347                                 libzfs_fini(g_zfs);
  348                                 return (MOUNT_SYSERR);
  349                         }
  350                 } else {
  351                         error = mount(dataset, mntpoint, MNTTYPE_ZFS,
  352                             mntflags, mntopts);
  353                 }
  354         }
  355 
  356         zfs_close(zhp);
  357         libzfs_fini(g_zfs);
  358 
  359         if (error) {
  360                 switch (errno) {
  361                 case ENOENT:
  362                         (void) fprintf(stderr, gettext("mount point "
  363                             "'%s' does not exist\n"), mntpoint);
  364                         return (MOUNT_SYSERR);
  365                 case EBUSY:
  366                         (void) fprintf(stderr, gettext("filesystem "
  367                             "'%s' is already mounted\n"), dataset);
  368                         return (MOUNT_BUSY);
  369                 case ENOTSUP:
  370                         if (zfs_version > ZPL_VERSION) {
  371                                 (void) fprintf(stderr,
  372                                     gettext("filesystem '%s' (v%d) is not "
  373                                     "supported by this implementation of "
  374                                     "ZFS (max v%d).\n"), dataset,
  375                                     (int)zfs_version, (int)ZPL_VERSION);
  376                         } else {
  377                                 (void) fprintf(stderr,
  378                                     gettext("filesystem '%s' mount "
  379                                     "failed for unknown reason.\n"), dataset);
  380                         }
  381                         return (MOUNT_SYSERR);
  382 #ifdef MS_MANDLOCK
  383                 case EPERM:
  384                         if (mntflags & MS_MANDLOCK) {
  385                                 (void) fprintf(stderr, gettext("filesystem "
  386                                     "'%s' has the 'nbmand=on' property set, "
  387                                     "this mount\noption may be disabled in "
  388                                     "your kernel.  Use 'zfs set nbmand=off'\n"
  389                                     "to disable this option and try to "
  390                                     "mount the filesystem again.\n"), dataset);
  391                                 return (MOUNT_SYSERR);
  392                         }
  393 #endif
  394                         zfs_fallthrough;
  395                 default:
  396                         (void) fprintf(stderr, gettext("filesystem "
  397                             "'%s' can not be mounted: %s\n"), dataset,
  398                             strerror(errno));
  399                         return (MOUNT_USAGE);
  400                 }
  401         }
  402 
  403         if (!nomtab && mtab_is_writeable()) {
  404                 error = mtab_update(dataset, mntpoint, MNTTYPE_ZFS, mtabopt);
  405                 if (error)
  406                         return (error);
  407         }
  408 
  409         return (MOUNT_SUCCESS);
  410 }
Cache object: 3209cda5a22e309112674252a101af82
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/contrib/openzfs/cmd/mount_zfs.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/openzfs/cmd/mount_zfs.c
