lustre/utils/mount_lustre.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2012, Whamcloud, Inc.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/utils/mount_lustre.c
  37  *
  38  * Author: Robert Read <rread@clusterfs.com>
  39  * Author: Nathan Rutman <nathan@clusterfs.com>
  40  */
  41
  42 #ifndef _GNU_SOURCE
  43 #define _GNU_SOURCE
  44 #endif
  45 #include <stdlib.h>
  46 #include <stdio.h>
  47 #include <unistd.h>
  48 #include <fcntl.h>
  49 #include <errno.h>
  50 #include <string.h>
  51 #include "obdctl.h"
  52 #include <lustre_ver.h>
  53 #include <ctype.h>
  54 #include <limits.h>
  55 #include "mount_utils.h"
  56
  57 #define MAXOPT 4096
  58 #define MAX_RETRIES 99
  59
  60 int          verbose = 0;
  61 char         *progname = NULL;
  62
  63 void usage(FILE *out)
  64 {
  65         fprintf(out, "%s v"LUSTRE_VERSION_STRING"\n", progname);
  66         fprintf(out, "\nThis mount helper should only be invoked via the "
  67                 "mount (8) command,\ne.g. mount -t lustre dev dir\n\n");
  68         fprintf(out, "usage: %s [-fhnv] [-o <mntopt>] <device> <mountpt>\n",
  69                 progname);
  70         fprintf(out,
  71                 "\t<device>: the disk device, or for a client:\n"
  72                 "\t\t<mgmtnid>[:<altmgtnid>...]:/<filesystem>-client\n"
  73                 "\t<filesystem>: name of the Lustre filesystem (e.g. lustre1)\n"
  74                 "\t<mountpt>: filesystem mountpoint (e.g. /mnt/lustre)\n"
  75                 "\t-f|--fake: fake mount (updates /etc/mtab)\n"
  76                 "\t-o force|--force: force mount even if already in /etc/mtab\n"
  77                 "\t-h|--help: print this usage message\n"
  78                 "\t-n|--nomtab: do not update /etc/mtab after mount\n"
  79                 "\t-v|--verbose: print verbose config settings\n"
  80                 "\t<mntopt>: one or more comma separated of:\n"
  81                 "\t\t(no)flock,(no)user_xattr,(no)acl\n"
  82                 "\t\tabort_recov: abort server recovery handling\n"
  83                 "\t\tnosvc: only start MGC/MGS obds\n"
  84                 "\t\tnomgs: only start target obds, using existing MGS\n"
  85                 "\t\texclude=<ostname>[:<ostname>] : colon-separated list of "
  86                 "inactive OSTs (e.g. lustre-OST0001)\n"
  87                 "\t\tretry=<num>: number of times mount is retried by client\n"
  88                 "\t\tmd_stripe_cache_size=<num>: set the raid stripe cache "
  89                 "size for the underlying raid if present\n"
  90                 );
  91         exit((out != stdout) ? EINVAL : 0);
  92 }
  93
  94 /* Get rid of symbolic hostnames for tcp, since kernel can't do lookups */
  95 #define MAXNIDSTR 1024
  96 static char *convert_hostnames(char *s1)
  97 {
  98         char *converted, *s2 = 0, *c;
  99         char sep;
 100         int left = MAXNIDSTR;
 101         lnet_nid_t nid;
 102
 103         converted = malloc(left);
 104         if (converted == NULL) {
 105                 fprintf(stderr, "out of memory: needed %d bytes\n",
 106                         MAXNIDSTR);
 107                 return NULL;
 108         }
 109         c = converted;
 110         while ((left > 0) && (*s1 != '/')) {
 111                 s2 = strpbrk(s1, ",:");
 112                 if (!s2)
 113                         goto out_free;
 114                 sep = *s2;
 115                 *s2 = '\0';
 116                 nid = libcfs_str2nid(s1);
 117                 *s2 = sep;                      /* back to original string */
 118                 if (nid == LNET_NID_ANY)
 119                         goto out_free;
 120                 c += snprintf(c, left, "%s%c", libcfs_nid2str(nid), sep);
 121                 left = converted + MAXNIDSTR - c;
 122                 s1 = s2 + 1;
 123         }
 124         snprintf(c, left, "%s", s1);
 125         return converted;
 126 out_free:
 127         fprintf(stderr, "%s: Can't parse NID '%s'\n", progname, s1);
 128         free(converted);
 129         return NULL;
 130 }
 131
 132 /*****************************************************************************
 133  *
 134  * This part was cribbed from util-linux/mount/mount.c.  There was no clear
 135  * license information, but many other files in the package are identified as
 136  * GNU GPL, so it's a pretty safe bet that was their intent.
 137  *
 138  ****************************************************************************/
 139 struct opt_map {
 140         const char *opt;        /* option name */
 141         int inv;                /* true if flag value should be inverted */
 142         int mask;               /* flag mask value */
 143 };
 144
 145 static const struct opt_map opt_map[] = {
 146   /*"optname", inv,ms_mask */
 147   /* These flags are parsed by mount, not lustre */
 148   { "defaults", 0, 0         },      /* default options */
 149   { "remount",  0, MS_REMOUNT},      /* remount with different options */
 150   { "rw",       1, MS_RDONLY },      /* read-write */
 151   { "ro",       0, MS_RDONLY },      /* read-only */
 152   { "exec",     1, MS_NOEXEC },      /* permit execution of binaries */
 153   { "noexec",   0, MS_NOEXEC },      /* don't execute binaries */
 154   { "suid",     1, MS_NOSUID },      /* honor suid executables */
 155   { "nosuid",   0, MS_NOSUID },      /* don't honor suid executables */
 156   { "dev",      1, MS_NODEV  },      /* interpret device files  */
 157   { "nodev",    0, MS_NODEV  },      /* don't interpret devices */
 158   { "sync",     0, MS_SYNCHRONOUS},  /* synchronous I/O */
 159   { "async",    1, MS_SYNCHRONOUS},  /* asynchronous I/O */
 160   { "atime",    1, MS_NOATIME  },    /* set file access time on read */
 161   { "noatime",  0, MS_NOATIME  },    /* do not set file access time on read */
 162 #ifdef MS_NODIRATIME
 163   { "diratime", 1, MS_NODIRATIME },  /* set file access time on read */
 164   { "nodiratime",0,MS_NODIRATIME },  /* do not set file access time on read */
 165 #endif
 166 #ifdef MS_RELATIME
 167   { "relatime", 0, MS_RELATIME },  /* set file access time on read */
 168   { "norelatime",1,MS_RELATIME },  /* do not set file access time on read */
 169 #endif
 170 #ifdef MS_STRICTATIME
 171   { "strictatime",0,MS_STRICTATIME },  /* update access time strictly */
 172 #endif
 173   { "auto",     0, 0         },      /* Can be mounted using -a */
 174   { "noauto",   0, 0         },      /* Can only be mounted explicitly */
 175   { "nousers",  1, 0         },      /* Forbid ordinary user to mount */
 176   { "nouser",   1, 0         },      /* Forbid ordinary user to mount */
 177   { "noowner",  1, 0         },      /* Device owner has no special privs */
 178   { "_netdev",  0, 0         },      /* Device accessible only via network */
 179   { "loop",     0, 0         },
 180   { NULL,       0, 0         }
 181 };
 182 /****************************************************************************/
 183
 184 /* 1  = don't pass on to lustre
 185    0  = pass on to lustre */
 186 static int parse_one_option(const char *check, int *flagp)
 187 {
 188         const struct opt_map *opt;
 189
 190         for (opt = &opt_map[0]; opt->opt != NULL; opt++) {
 191                 if (strncmp(check, opt->opt, strlen(opt->opt)) == 0) {
 192                         if (opt->mask) {
 193                                 if (opt->inv)
 194                                         *flagp &= ~(opt->mask);
 195                                 else
 196                                         *flagp |= opt->mask;
 197                         }
 198                         return 1;
 199                 }
 200         }
 201         /* Assume any unknown options are valid and pass them on.  The mount
 202            will fail if lmd_parse, ll_options or ldiskfs doesn't recognize it.*/
 203         return 0;
 204 }
 205
 206 static void append_option(char *options, const char *one)
 207 {
 208         if (*options)
 209                 strcat(options, ",");
 210         strcat(options, one);
 211 }
 212
 213 /* Replace options with subset of Lustre-specific options, and
 214    fill in mount flags */
 215 int parse_options(struct mount_opts *mop, char *orig_options, int *flagp)
 216 {
 217         char *options, *opt, *nextopt, *arg, *val;
 218
 219         options = calloc(strlen(orig_options) + 1, 1);
 220         *flagp = 0;
 221         nextopt = orig_options;
 222         while ((opt = strsep(&nextopt, ","))) {
 223                 if (!*opt)
 224                         /* empty option */
 225                         continue;
 226
 227                 /* Handle retries in a slightly different
 228                  * manner */
 229                 arg = opt;
 230                 val = strchr(opt, '=');
 231                 /* please note that some ldiskfs mount options are also in the form
 232                  * of param=value. We should pay attention not to remove those
 233                  * mount options, see bug 22097. */
 234                 if (val && strncmp(arg, "md_stripe_cache_size", 20) == 0) {
 235                         mop->mo_md_stripe_cache_size = atoi(val + 1);
 236                 } else if (val && strncmp(arg, "retry", 5) == 0) {
 237                         mop->mo_retry = atoi(val + 1);
 238                         if (mop->mo_retry > MAX_RETRIES)
 239                                 mop->mo_retry = MAX_RETRIES;
 240                         else if (mop->mo_retry < 0)
 241                                 mop->mo_retry = 0;
 242                 } else if (val && strncmp(arg, "mgssec", 6) == 0) {
 243                         append_option(options, opt);
 244                 } else if (strcmp(opt, "force") == 0) {
 245                         //XXX special check for 'force' option
 246                         ++mop->mo_force;
 247                         printf("force: %d\n", mop->mo_force);
 248                 } else if (parse_one_option(opt, flagp) == 0) {
 249                         /* pass this on as an option */
 250                         append_option(options, opt);
 251                 }
 252         }
 253 #ifdef MS_STRICTATIME
 254                 /* set strictatime to default if NOATIME or RELATIME
 255                    not given explicit */
 256         if (!(*flagp & (MS_NOATIME | MS_RELATIME)))
 257                 *flagp |= MS_STRICTATIME;
 258 #endif
 259         strcpy(orig_options, options);
 260         free(options);
 261         return 0;
 262 }
 263
 264
 265 static int parse_ldd(char *source, struct mount_opts *mop, char *options)
 266 {
 267         struct lustre_disk_data *ldd = &mop->mo_ldd;
 268         int rc;
 269
 270         rc = osd_is_lustre(source, &ldd->ldd_mount_type);
 271         if (rc == 0) {
 272                 fprintf(stderr, "%s: %s has not been formatted with mkfs.lustre"
 273                         " or the backend filesystem type is not supported by "
 274                         "this tool\n", progname, source);
 275                 return ENODEV;
 276         }
 277
 278         return 0;
 279 }
 280
 281 static void set_defaults(struct mount_opts *mop)
 282 {
 283         memset(mop, 0, sizeof(*mop));
 284         mop->mo_usource = NULL;
 285         mop->mo_source = NULL;
 286         mop->mo_nomtab = 0;
 287         mop->mo_fake = 0;
 288         mop->mo_force = 0;
 289         mop->mo_retry = 0;
 290         mop->mo_have_mgsnid = 0;
 291         mop->mo_md_stripe_cache_size = 16384;
 292         mop->mo_orig_options = "";
 293 }
 294
 295 static int parse_opts(int argc, char *const argv[], struct mount_opts *mop)
 296 {
 297         static struct option long_opt[] = {
 298                 {"fake", 0, 0, 'f'},
 299                 {"force", 0, 0, 1},
 300                 {"help", 0, 0, 'h'},
 301                 {"nomtab", 0, 0, 'n'},
 302                 {"options", 1, 0, 'o'},
 303                 {"verbose", 0, 0, 'v'},
 304                 {0, 0, 0, 0}
 305         };
 306         char real_path[PATH_MAX] = {'\0'};
 307         FILE *f;
 308         char path[256], name[256];
 309         size_t sz;
 310         char *ptr;
 311         int opt, rc;
 312
 313         while ((opt = getopt_long(argc, argv, "fhno:v",
 314                                   long_opt, NULL)) != EOF){
 315                 switch (opt) {
 316                 case 1:
 317                         ++mop->mo_force;
 318                         printf("force: %d\n", mop->mo_force);
 319                         break;
 320                 case 'f':
 321                         ++mop->mo_fake;
 322                         printf("fake: %d\n", mop->mo_fake);
 323                         break;
 324                 case 'h':
 325                         usage(stdout);
 326                         break;
 327                 case 'n':
 328                         ++mop->mo_nomtab;
 329                         printf("nomtab: %d\n", mop->mo_nomtab);
 330                         break;
 331                 case 'o':
 332                         mop->mo_orig_options = optarg;
 333                         break;
 334                 case 'v':
 335                         ++verbose;
 336                         break;
 337                 default:
 338                         fprintf(stderr, "%s: unknown option '%c'\n",
 339                                         progname, opt);
 340                         usage(stderr);
 341                         break;
 342                 }
 343         }
 344
 345         if (optind + 2 > argc) {
 346                 fprintf(stderr, "%s: too few arguments\n", progname);
 347                 usage(stderr);
 348         }
 349
 350         mop->mo_usource = argv[optind];
 351         if (!mop->mo_usource) {
 352                 usage(stderr);
 353         }
 354
 355         /**
 356          * Try to get the real path to the device, in case it is a
 357          * symbolic link for instance
 358          */
 359         if (realpath(mop->mo_usource, real_path) != NULL) {
 360                 mop->mo_usource = strdup(real_path);
 361
 362                 ptr = strrchr(real_path, '/');
 363                 if (ptr && strncmp(ptr, "/dm-", 4) == 0 && isdigit(*(ptr + 4))) {
 364                         snprintf(path, sizeof(path), "/sys/block/%s/dm/name", ptr+1);
 365                         if ((f = fopen(path, "r"))) {
 366                                 /* read "<name>\n" from sysfs */
 367                                 if (fgets(name, sizeof(name), f) && (sz = strlen(name)) > 1) {
 368                                         name[sz - 1] = '\0';
 369                                         snprintf(real_path, sizeof(real_path), "/dev/mapper/%s", name);
 370                                 }
 371                                 fclose(f);
 372                         }
 373                 }
 374         }
 375
 376         mop->mo_source = convert_hostnames(mop->mo_usource);
 377         if (!mop->mo_source) {
 378                 usage(stderr);
 379         }
 380
 381         if (realpath(argv[optind + 1], mop->mo_target) == NULL) {
 382                 rc = errno;
 383                 fprintf(stderr, "warning: %s: cannot resolve: %s\n",
 384                                 argv[optind + 1], strerror(errno));
 385                 return rc;
 386         }
 387
 388         return 0;
 389 }
 390
 391 int main(int argc, char *const argv[])
 392 {
 393         struct mount_opts mop;
 394         char *options;
 395         int i, rc, flags;
 396
 397         progname = strrchr(argv[0], '/');
 398         progname = progname ? progname + 1 : argv[0];
 399
 400         set_defaults(&mop);
 401
 402         rc = osd_init();
 403         if (rc)
 404                 return rc;
 405
 406         rc = parse_opts(argc, argv, &mop);
 407         if (rc)
 408                 return rc;
 409
 410         if (verbose) {
 411                 for (i = 0; i < argc; i++)
 412                         printf("arg[%d] = %s\n", i, argv[i]);
 413                 printf("source = %s (%s), target = %s\n", mop.mo_usource,
 414                        mop.mo_source, mop.mo_target);
 415                 printf("options = %s\n", mop.mo_orig_options);
 416         }
 417
 418         options = malloc(MAXOPT);
 419         if (options == NULL) {
 420                 fprintf(stderr, "can't allocate memory for options\n");
 421                 return -1;
 422         }
 423         strcpy(options, mop.mo_orig_options);
 424         rc = parse_options(&mop, options, &flags);
 425         if (rc) {
 426                 fprintf(stderr, "%s: can't parse options: %s\n",
 427                         progname, options);
 428                 return(EINVAL);
 429         }
 430
 431         if (!mop.mo_force) {
 432                 rc = check_mtab_entry(mop.mo_usource, mop.mo_source,
 433                                       mop.mo_target, "lustre");
 434                 if (rc && !(flags & MS_REMOUNT)) {
 435                         fprintf(stderr, "%s: according to %s %s is "
 436                                 "already mounted on %s\n", progname, MOUNTED,
 437                                 mop.mo_usource, mop.mo_target);
 438                         return(EEXIST);
 439                 }
 440                 if (!rc && (flags & MS_REMOUNT)) {
 441                         fprintf(stderr, "%s: according to %s %s is "
 442                                 "not already mounted on %s\n", progname, MOUNTED,
 443                                 mop.mo_usource, mop.mo_target);
 444                         return(ENOENT);
 445                 }
 446         }
 447         if (flags & MS_REMOUNT)
 448                 mop.mo_nomtab++;
 449
 450         rc = access(mop.mo_target, F_OK);
 451         if (rc) {
 452                 rc = errno;
 453                 fprintf(stderr, "%s: %s inaccessible: %s\n", progname,
 454                         mop.mo_target, strerror(errno));
 455                 return rc;
 456         }
 457
 458         if (!strstr(mop.mo_usource, ":/")) {
 459                 rc = parse_ldd(mop.mo_source, &mop, options);
 460                 if (rc)
 461                         return rc;
 462         }
 463
 464         /* In Linux 2.4, the target device doesn't get passed to any of our
 465            functions.  So we'll stick it on the end of the options. */
 466         append_option(options, "device=");
 467         strcat(options, mop.mo_source);
 468
 469         if (verbose)
 470                 printf("mounting device %s at %s, flags=%#x options=%s\n",
 471                        mop.mo_source, mop.mo_target, flags, options);
 472
 473         if (!strstr(mop.mo_usource, ":/") &&
 474             osd_tune_lustre(mop.mo_source, &mop)) {
 475                 if (verbose)
 476                         fprintf(stderr, "%s: unable to set tunables for %s"
 477                                         " (may cause reduced IO performance)\n",
 478                                         argv[0], mop.mo_source);
 479         }
 480
 481         if (!mop.mo_fake) {
 482                 /* flags and target get to lustre_get_sb, but not
 483                    lustre_fill_super.  Lustre ignores the flags, but mount
 484                    does not. */
 485                 for (i = 0, rc = -EAGAIN; i <= mop.mo_retry && rc != 0; i++) {
 486                         rc = mount(mop.mo_source, mop.mo_target, "lustre",
 487                                    flags, (void *)options);
 488                         if (rc) {
 489                                 if (verbose) {
 490                                         fprintf(stderr, "%s: mount %s at %s "
 491                                                 "failed: %s retries left: "
 492                                                 "%d\n", basename(progname),
 493                                                 mop.mo_usource, mop.mo_target,
 494                                                 strerror(errno),
 495                                                 mop.mo_retry - i);
 496                                 }
 497
 498                                 if (mop.mo_retry) {
 499                                         sleep(1 << max((i/2), 5));
 500                                 }
 501                                 else {
 502                                         rc = errno;
 503                                 }
 504                         }
 505                 }
 506         }
 507
 508         if (rc) {
 509                 char *cli;
 510
 511                 rc = errno;
 512
 513                 cli = strrchr(mop.mo_usource, ':');
 514                 if (cli && (strlen(cli) > 2))
 515                         cli += 2;
 516                 else
 517                         cli = NULL;
 518
 519                 fprintf(stderr, "%s: mount %s at %s failed: %s\n", progname,
 520                         mop.mo_usource, mop.mo_target, strerror(errno));
 521                 if (errno == ENODEV)
 522                         fprintf(stderr, "Are the lustre modules loaded?\n"
 523                                 "Check /etc/modprobe.conf and "
 524                                 "/proc/filesystems\n");
 525                 if (errno == ENOTBLK)
 526                         fprintf(stderr, "Do you need -o loop?\n");
 527                 if (errno == ENOMEDIUM)
 528                         fprintf(stderr,
 529                                 "This filesystem needs at least 1 OST\n");
 530                 if (errno == ENOENT) {
 531                         fprintf(stderr, "Is the MGS specification correct?\n");
 532                         fprintf(stderr, "Is the filesystem name correct?\n");
 533                         fprintf(stderr, "If upgrading, is the copied client log"
 534                                 " valid? (see upgrade docs)\n");
 535                 }
 536                 if (errno == EALREADY)
 537                         fprintf(stderr, "The target service is already running."
 538                                 " (%s)\n", mop.mo_usource);
 539                 if (errno == ENXIO)
 540                         fprintf(stderr, "The target service failed to start "
 541                                 "(bad config log?) (%s).  "
 542                                 "See /var/log/messages.\n", mop.mo_usource);
 543                 if (errno == EIO)
 544                         fprintf(stderr, "Is the MGS running?\n");
 545                 if (errno == EADDRINUSE)
 546                         fprintf(stderr, "The target service's index is already "
 547                                 "in use. (%s)\n", mop.mo_usource);
 548                 if (errno == EINVAL) {
 549                         fprintf(stderr, "This may have multiple causes.\n");
 550                         if (cli)
 551                                 fprintf(stderr, "Is '%s' the correct filesystem"
 552                                         " name?\n", cli);
 553                         fprintf(stderr, "Are the mount options correct?\n");
 554                         fprintf(stderr, "Check the syslog for more info.\n");
 555                 }
 556
 557                 /* May as well try to clean up loop devs */
 558                 if (strncmp(mop.mo_usource, "/dev/loop", 9) == 0) {
 559                         char cmd[256];
 560                         int ret;
 561                         sprintf(cmd, "/sbin/losetup -d %s", mop.mo_usource);
 562                         if ((ret = system(cmd)) < 0)
 563                                 rc = errno;
 564                         else if (ret > 0)
 565                                 rc = WEXITSTATUS(ret);
 566                 }
 567
 568         } else if (!mop.mo_nomtab) {
 569                 rc = update_mtab_entry(mop.mo_usource, mop.mo_target, "lustre",
 570                                        mop.mo_orig_options, 0,0,0);
 571         }
 572
 573         free(options);
 574         /* mo_usource should be freed, but we can rely on the kernel */
 575         free(mop.mo_source);
 576
 577         osd_fini();
 578
 579         return rc;
 580 }