lustre/obdclass/obd_mount.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.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/obdclass/obd_mount.c
  33  *
  34  * Client mount routines
  35  *
  36  * Author: Nathan Rutman <nathan@clusterfs.com>
  37  */
  38
  39
  40 #define DEBUG_SUBSYSTEM S_CLASS
  41 #define D_MOUNT (D_SUPER|D_CONFIG/*|D_WARNING */)
  42 #define PRINT_CMD CDEBUG
  43
  44 #include <obd.h>
  45 #include <obd_class.h>
  46 #include <linux/version.h>
  47 #include <lustre_log.h>
  48 #include <lustre_disk.h>
  49 #include <uapi/linux/lustre/lustre_param.h>
  50
  51 static int (*client_fill_super)(struct super_block *sb,
  52                                 struct vfsmount *mnt);
  53
  54 static void (*kill_super_cb)(struct super_block *sb);
  55
  56 /**************** config llog ********************/
  57
  58 /** Get a config log from the MGS and process it.
  59  * This func is called for both clients and servers.
  60  * Continue to process new statements appended to the logs
  61  * (whenever the config lock is revoked) until lustre_end_log
  62  * is called.
  63  * @param sb The superblock is used by the MGC to write to the local copy of
  64  *   the config log
  65  * @param logname The name of the llog to replicate from the MGS
  66  * @param cfg Since the same mgc may be used to follow multiple config logs
  67  *   (e.g. ost1, ost2, client), the config_llog_instance keeps the state for
  68  *   this log, and is added to the mgc's list of logs to follow.
  69  */
  70 int lustre_process_log(struct super_block *sb, char *logname,
  71                      struct config_llog_instance *cfg)
  72 {
  73         struct lustre_cfg *lcfg;
  74         struct lustre_cfg_bufs *bufs;
  75         struct lustre_sb_info *lsi = s2lsi(sb);
  76         struct obd_device *mgc = lsi->lsi_mgc;
  77         int rc;
  78         ENTRY;
  79
  80         LASSERT(mgc);
  81         LASSERT(cfg);
  82
  83         OBD_ALLOC_PTR(bufs);
  84         if (bufs == NULL)
  85                 RETURN(-ENOMEM);
  86
  87         /* mgc_process_config */
  88         lustre_cfg_bufs_reset(bufs, mgc->obd_name);
  89         lustre_cfg_bufs_set_string(bufs, 1, logname);
  90         lustre_cfg_bufs_set(bufs, 2, cfg, sizeof(*cfg));
  91         lustre_cfg_bufs_set(bufs, 3, &sb, sizeof(sb));
  92         OBD_ALLOC(lcfg, lustre_cfg_len(bufs->lcfg_bufcount, bufs->lcfg_buflen));
  93         if (!lcfg)
  94                 GOTO(out, rc = -ENOMEM);
  95         lustre_cfg_init(lcfg, LCFG_LOG_START, bufs);
  96
  97         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
  98         OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens));
  99 out:
 100         OBD_FREE_PTR(bufs);
 101
 102         if (rc == -EINVAL)
 103                 LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
 104                                    "failed from the MGS (%d).  Make sure this "
 105                                    "client and the MGS are running compatible "
 106                                    "versions of Lustre.\n",
 107                                    mgc->obd_name, logname, rc);
 108         else if (rc != 0)
 109                 LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
 110                                    "failed (%d). This may be the result of "
 111                                    "communication errors between this node and "
 112                                    "the MGS, a bad configuration, or other "
 113                                    "errors. See the syslog for more "
 114                                    "information.\n", mgc->obd_name, logname,
 115                                    rc);
 116
 117         /* class_obd_list(); */
 118         RETURN(rc);
 119 }
 120 EXPORT_SYMBOL(lustre_process_log);
 121
 122 /* Stop watching this config log for updates */
 123 int lustre_end_log(struct super_block *sb, char *logname,
 124                        struct config_llog_instance *cfg)
 125 {
 126         struct lustre_cfg *lcfg;
 127         struct lustre_cfg_bufs bufs;
 128         struct lustre_sb_info *lsi = s2lsi(sb);
 129         struct obd_device *mgc = lsi->lsi_mgc;
 130         int rc;
 131         ENTRY;
 132
 133         if (!mgc)
 134                 RETURN(-ENOENT);
 135
 136         /* mgc_process_config */
 137         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
 138         lustre_cfg_bufs_set_string(&bufs, 1, logname);
 139         if (cfg)
 140                 lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
 141         OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
 142         if (!lcfg)
 143                 RETURN(-ENOMEM);
 144         lustre_cfg_init(lcfg, LCFG_LOG_END, &bufs);
 145         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 146         OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens));
 147         RETURN(rc);
 148 }
 149 EXPORT_SYMBOL(lustre_end_log);
 150
 151 /**************** obd start *******************/
 152
 153 /** lustre_cfg_bufs are a holdover from 1.4; we can still set these up from
 154  * lctl (and do for echo cli/srv.
 155  */
 156 static int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
 157                    char *s1, char *s2, char *s3, char *s4)
 158 {
 159         struct lustre_cfg_bufs bufs;
 160         struct lustre_cfg *lcfg = NULL;
 161         int rc;
 162
 163         CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
 164                cmd, s1, s2, s3, s4);
 165
 166         lustre_cfg_bufs_reset(&bufs, cfgname);
 167         if (s1)
 168                 lustre_cfg_bufs_set_string(&bufs, 1, s1);
 169         if (s2)
 170                 lustre_cfg_bufs_set_string(&bufs, 2, s2);
 171         if (s3)
 172                 lustre_cfg_bufs_set_string(&bufs, 3, s3);
 173         if (s4)
 174                 lustre_cfg_bufs_set_string(&bufs, 4, s4);
 175
 176         OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
 177         if (!lcfg)
 178                 return -ENOMEM;
 179         lustre_cfg_init(lcfg, cmd, &bufs);
 180         lcfg->lcfg_nid = nid;
 181         rc = class_process_config(lcfg);
 182         OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens));
 183         return rc;
 184 }
 185
 186 /** Call class_attach and class_setup.  These methods in turn call
 187  * obd type-specific methods.
 188  */
 189 int lustre_start_simple(char *obdname, char *type, char *uuid,
 190                         char *s1, char *s2, char *s3, char *s4)
 191 {
 192         int rc;
 193         CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
 194
 195         rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, NULL, NULL);
 196         if (rc) {
 197                 CERROR("%s attach error %d\n", obdname, rc);
 198                 return rc;
 199         }
 200         rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, s3, s4);
 201         if (rc) {
 202                 CERROR("%s setup error %d\n", obdname, rc);
 203                 do_lcfg(obdname, 0, LCFG_DETACH, NULL, NULL, NULL, NULL);
 204         }
 205         return rc;
 206 }
 207
 208 static DEFINE_MUTEX(mgc_start_lock);
 209
 210 /** Set up a mgc obd to process startup logs
 211  *
 212  * \param sb [in] super block of the mgc obd
 213  *
 214  * \retval 0 success, otherwise error code
 215  */
 216 int lustre_start_mgc(struct super_block *sb)
 217 {
 218         struct obd_connect_data *data = NULL;
 219         struct lustre_sb_info *lsi = s2lsi(sb);
 220         struct obd_device *obd;
 221         struct obd_export *exp;
 222         struct obd_uuid *uuid = NULL;
 223         class_uuid_t uuidc;
 224         lnet_nid_t nid;
 225         char nidstr[LNET_NIDSTR_SIZE];
 226         char *mgcname = NULL, *niduuid = NULL, *mgssec = NULL;
 227         char *ptr;
 228         int rc = 0, i = 0, j;
 229         size_t len;
 230         ENTRY;
 231
 232         LASSERT(lsi->lsi_lmd);
 233
 234         /* Find the first non-lo MGS nid for our MGC name */
 235         if (IS_SERVER(lsi)) {
 236                 /* mount -o mgsnode=nid */
 237                 ptr = lsi->lsi_lmd->lmd_mgs;
 238                 if (lsi->lsi_lmd->lmd_mgs &&
 239                     (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
 240                         i++;
 241                 } else if (IS_MGS(lsi)) {
 242                         struct lnet_process_id id;
 243
 244                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 245                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 246                                         continue;
 247                                 nid = id.nid;
 248                                 i++;
 249                                 break;
 250                         }
 251                 }
 252         } else { /* client */
 253                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 254                 ptr = lsi->lsi_lmd->lmd_dev;
 255                 if (class_parse_nid(ptr, &nid, &ptr) == 0)
 256                         i++;
 257         }
 258         if (i == 0) {
 259                 CERROR("No valid MGS nids found.\n");
 260                 RETURN(-EINVAL);
 261         }
 262
 263         mutex_lock(&mgc_start_lock);
 264
 265         libcfs_nid2str_r(nid, nidstr, sizeof(nidstr));
 266         len = strlen(LUSTRE_MGC_OBDNAME) + strlen(nidstr) + 1;
 267         OBD_ALLOC(mgcname, len);
 268         OBD_ALLOC(niduuid, len + 2);
 269         if (mgcname == NULL || niduuid == NULL)
 270                 GOTO(out_free, rc = -ENOMEM);
 271         snprintf(mgcname, len, "%s%s", LUSTRE_MGC_OBDNAME, nidstr);
 272
 273         mgssec = lsi->lsi_lmd->lmd_mgssec ? lsi->lsi_lmd->lmd_mgssec : "";
 274
 275         OBD_ALLOC_PTR(data);
 276         if (data == NULL)
 277                 GOTO(out_free, rc = -ENOMEM);
 278
 279         obd = class_name2obd(mgcname);
 280         if (obd && !obd->obd_stopping) {
 281                 int recov_bk;
 282
 283                 rc = obd_set_info_async(NULL, obd->obd_self_export,
 284                                         strlen(KEY_MGSSEC), KEY_MGSSEC,
 285                                         strlen(mgssec), mgssec, NULL);
 286                 if (rc)
 287                         GOTO(out_free, rc);
 288
 289                 /* Re-using an existing MGC */
 290                 atomic_inc(&obd->u.cli.cl_mgc_refcount);
 291
 292                 /* IR compatibility check, only for clients */
 293                 if (lmd_is_client(lsi->lsi_lmd)) {
 294                         int has_ir;
 295                         int vallen = sizeof(*data);
 296                         __u32 *flags = &lsi->lsi_lmd->lmd_flags;
 297
 298                         rc = obd_get_info(NULL, obd->obd_self_export,
 299                                           strlen(KEY_CONN_DATA), KEY_CONN_DATA,
 300                                           &vallen, data);
 301                         LASSERT(rc == 0);
 302                         has_ir = OCD_HAS_FLAG(data, IMP_RECOV);
 303                         if (has_ir ^ !(*flags & LMD_FLG_NOIR)) {
 304                                 /* LMD_FLG_NOIR is for test purpose only */
 305                                 LCONSOLE_WARN(
 306                                     "Trying to mount a client with IR setting "
 307                                     "not compatible with current mgc. "
 308                                     "Force to use current mgc setting that is "
 309                                     "IR %s.\n",
 310                                     has_ir ? "enabled" : "disabled");
 311                                 if (has_ir)
 312                                         *flags &= ~LMD_FLG_NOIR;
 313                                 else
 314                                         *flags |= LMD_FLG_NOIR;
 315                         }
 316                 }
 317
 318                 recov_bk = 0;
 319                 /* If we are restarting the MGS, don't try to keep the MGC's
 320                    old connection, or registration will fail. */
 321                 if (IS_MGS(lsi)) {
 322                         CDEBUG(D_MOUNT, "New MGS with live MGC\n");
 323                         recov_bk = 1;
 324                 }
 325
 326                 /* Try all connections, but only once (again).
 327                    We don't want to block another target from starting
 328                    (using its local copy of the log), but we do want to connect
 329                    if at all possible. */
 330                 recov_bk++;
 331                 CDEBUG(D_MOUNT, "%s: Set MGC reconnect %d\n", mgcname,recov_bk);
 332                 rc = obd_set_info_async(NULL, obd->obd_self_export,
 333                                         sizeof(KEY_INIT_RECOV_BACKUP),
 334                                         KEY_INIT_RECOV_BACKUP,
 335                                         sizeof(recov_bk), &recov_bk, NULL);
 336                 GOTO(out, rc = 0);
 337         }
 338
 339         CDEBUG(D_MOUNT, "Start MGC '%s'\n", mgcname);
 340
 341         /* Add the primary nids for the MGS */
 342         i = 0;
 343         snprintf(niduuid, len + 2, "%s_%x", mgcname, i);
 344         if (IS_SERVER(lsi)) {
 345                 ptr = lsi->lsi_lmd->lmd_mgs;
 346                 CDEBUG(D_MOUNT, "mgs nids %s.\n", ptr);
 347                 if (IS_MGS(lsi)) {
 348                         /* Use local nids (including LO) */
 349                         struct lnet_process_id id;
 350
 351                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 352                                 rc = do_lcfg(mgcname, id.nid, LCFG_ADD_UUID,
 353                                              niduuid, NULL, NULL, NULL);
 354                         }
 355                 } else {
 356                         /* Use mgsnode= nids */
 357                         /* mount -o mgsnode=nid */
 358                         if (lsi->lsi_lmd->lmd_mgs) {
 359                                 ptr = lsi->lsi_lmd->lmd_mgs;
 360                         } else if (class_find_param(ptr, PARAM_MGSNODE,
 361                                                     &ptr) != 0) {
 362                                 CERROR("No MGS nids given.\n");
 363                                 GOTO(out_free, rc = -EINVAL);
 364                         }
 365                         /*
 366                          * Add primary MGS nid(s).
 367                          * Multiple nids on one MGS node are separated
 368                          * by commas.
 369                          */
 370                         while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 371                                 rc = do_lcfg(mgcname, nid, LCFG_ADD_UUID,
 372                                              niduuid, NULL, NULL, NULL);
 373                                 if (rc == 0)
 374                                         ++i;
 375                                 /* Stop at the first failover nid */
 376                                 if (*ptr == ':')
 377                                         break;
 378                         }
 379                 }
 380         } else { /* client */
 381                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 382                 ptr = lsi->lsi_lmd->lmd_dev;
 383                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 384                         rc = do_lcfg(mgcname, nid, LCFG_ADD_UUID,
 385                                      niduuid, NULL, NULL, NULL);
 386                         if (rc == 0)
 387                                 ++i;
 388                         /* Stop at the first failover nid */
 389                         if (*ptr == ':')
 390                                 break;
 391                 }
 392         }
 393         if (i == 0) {
 394                 CERROR("No valid MGS nids found.\n");
 395                 GOTO(out_free, rc = -EINVAL);
 396         }
 397         lsi->lsi_lmd->lmd_mgs_failnodes = 1;
 398
 399         /* Random uuid for MGC allows easier reconnects */
 400         OBD_ALLOC_PTR(uuid);
 401         if (uuid == NULL)
 402                 GOTO(out_free, rc = -ENOMEM);
 403
 404         ll_generate_random_uuid(uuidc);
 405         class_uuid_unparse(uuidc, uuid);
 406
 407         /* Start the MGC */
 408         rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
 409                                  (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
 410                                  niduuid, NULL, NULL);
 411         if (rc)
 412                 GOTO(out_free, rc);
 413
 414         /* Add any failover MGS nids */
 415         i = 1;
 416         while (ptr && ((*ptr == ':' ||
 417                class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0))) {
 418                 /* New failover node */
 419                 sprintf(niduuid, "%s_%x", mgcname, i);
 420                 j = 0;
 421                 while (class_parse_nid_quiet(ptr, &nid, &ptr) == 0) {
 422                         rc = do_lcfg(mgcname, nid, LCFG_ADD_UUID,
 423                                      niduuid, NULL, NULL, NULL);
 424                         if (rc == 0)
 425                                 ++j;
 426                         if (*ptr == ':')
 427                                 break;
 428                 }
 429                 if (j > 0) {
 430                         rc = do_lcfg(mgcname, 0, LCFG_ADD_CONN,
 431                                      niduuid, NULL, NULL, NULL);
 432                         if (rc == 0)
 433                                 ++i;
 434                 } else {
 435                         /* at ":/fsname" */
 436                         break;
 437                 }
 438         }
 439         lsi->lsi_lmd->lmd_mgs_failnodes = i;
 440
 441         obd = class_name2obd(mgcname);
 442         if (!obd) {
 443                 CERROR("Can't find mgcobd %s\n", mgcname);
 444                 GOTO(out_free, rc = -ENOTCONN);
 445         }
 446
 447         rc = obd_set_info_async(NULL, obd->obd_self_export,
 448                                 strlen(KEY_MGSSEC), KEY_MGSSEC,
 449                                 strlen(mgssec), mgssec, NULL);
 450         if (rc)
 451                 GOTO(out_free, rc);
 452
 453         /* Keep a refcount of servers/clients who started with "mount",
 454            so we know when we can get rid of the mgc. */
 455         atomic_set(&obd->u.cli.cl_mgc_refcount, 1);
 456
 457         /* We connect to the MGS at setup, and don't disconnect until cleanup */
 458         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
 459                                   OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV |
 460                                   OBD_CONNECT_LVB_TYPE |
 461                                   OBD_CONNECT_BULK_MBITS | OBD_CONNECT_BARRIER;
 462
 463 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0)
 464         data->ocd_connect_flags |= OBD_CONNECT_MNE_SWAB;
 465 #endif
 466
 467         if (lmd_is_client(lsi->lsi_lmd) &&
 468             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
 469                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
 470         data->ocd_version = LUSTRE_VERSION_CODE;
 471         rc = obd_connect(NULL, &exp, obd, uuid, data, NULL);
 472         if (rc) {
 473                 CERROR("connect failed %d\n", rc);
 474                 GOTO(out, rc);
 475         }
 476
 477         obd->u.cli.cl_mgc_mgsexp = exp;
 478
 479 out:
 480         /* Keep the mgc info in the sb. Note that many lsi's can point
 481            to the same mgc.*/
 482         lsi->lsi_mgc = obd;
 483 out_free:
 484         mutex_unlock(&mgc_start_lock);
 485
 486         if (uuid)
 487                 OBD_FREE_PTR(uuid);
 488         if (data)
 489                 OBD_FREE_PTR(data);
 490         if (mgcname)
 491                 OBD_FREE(mgcname, len);
 492         if (niduuid)
 493                 OBD_FREE(niduuid, len + 2);
 494         RETURN(rc);
 495 }
 496
 497 static int lustre_stop_mgc(struct super_block *sb)
 498 {
 499         struct lustre_sb_info *lsi = s2lsi(sb);
 500         struct obd_device *obd;
 501         char *niduuid = NULL, *ptr = NULL;
 502         int i, rc = 0, len = 0;
 503         ENTRY;
 504
 505         if (!lsi)
 506                 RETURN(-ENOENT);
 507         obd = lsi->lsi_mgc;
 508         if (!obd)
 509                 RETURN(-ENOENT);
 510         lsi->lsi_mgc = NULL;
 511
 512         mutex_lock(&mgc_start_lock);
 513         LASSERT(atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
 514         if (!atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 515                 /* This is not fatal, every client that stops
 516                    will call in here. */
 517                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 518                        atomic_read(&obd->u.cli.cl_mgc_refcount));
 519                 GOTO(out, rc = -EBUSY);
 520         }
 521
 522         /* The MGC has no recoverable data in any case.
 523          * force shotdown set in umount_begin */
 524         obd->obd_no_recov = 1;
 525
 526         if (obd->u.cli.cl_mgc_mgsexp) {
 527                 /* An error is not fatal, if we are unable to send the
 528                    disconnect mgs ping evictor cleans up the export */
 529                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 530                 if (rc)
 531                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 532         }
 533
 534         /* Save the obdname for cleaning the nid uuids, which are
 535            obdname_XX */
 536         len = strlen(obd->obd_name) + 6;
 537         OBD_ALLOC(niduuid, len);
 538         if (niduuid) {
 539                 strcpy(niduuid, obd->obd_name);
 540                 ptr = niduuid + strlen(niduuid);
 541         }
 542
 543         rc = class_manual_cleanup(obd);
 544         if (rc)
 545                 GOTO(out, rc);
 546
 547         /* Clean the nid uuids */
 548         if (!niduuid)
 549                 GOTO(out, rc = -ENOMEM);
 550
 551         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 552                 sprintf(ptr, "_%x", i);
 553                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 554                              niduuid, NULL, NULL, NULL);
 555                 if (rc)
 556                         CERROR("del MDC UUID %s failed: rc = %d\n",
 557                                niduuid, rc);
 558         }
 559 out:
 560         if (niduuid)
 561                 OBD_FREE(niduuid, len);
 562
 563         /* class_import_put will get rid of the additional connections */
 564         mutex_unlock(&mgc_start_lock);
 565         RETURN(rc);
 566 }
 567
 568 /***************** lustre superblock **************/
 569
 570 static struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
 571 {
 572         struct lustre_sb_info *lsi;
 573         ENTRY;
 574
 575         OBD_ALLOC_PTR(lsi);
 576         if (!lsi)
 577                 RETURN(NULL);
 578         OBD_ALLOC_PTR(lsi->lsi_lmd);
 579         if (!lsi->lsi_lmd) {
 580                 OBD_FREE_PTR(lsi);
 581                 RETURN(NULL);
 582         }
 583
 584         lsi->lsi_lmd->lmd_exclude_count = 0;
 585         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
 586         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
 587         s2lsi_nocast(sb) = lsi;
 588         /* we take 1 extra ref for our setup */
 589         atomic_set(&lsi->lsi_mounts, 1);
 590
 591         /* Default umount style */
 592         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
 593         INIT_LIST_HEAD(&lsi->lsi_lwp_list);
 594         spin_lock_init(&lsi->lsi_lwp_lock);
 595
 596         RETURN(lsi);
 597 }
 598
 599 static int lustre_free_lsi(struct super_block *sb)
 600 {
 601         struct lustre_sb_info *lsi = s2lsi(sb);
 602         ENTRY;
 603
 604         LASSERT(lsi != NULL);
 605         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
 606
 607         /* someone didn't call server_put_mount. */
 608         LASSERT(atomic_read(&lsi->lsi_mounts) == 0);
 609
 610         if (lsi->lsi_lmd != NULL) {
 611                 if (lsi->lsi_lmd->lmd_dev != NULL)
 612                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
 613                                 strlen(lsi->lsi_lmd->lmd_dev) + 1);
 614                 if (lsi->lsi_lmd->lmd_profile != NULL)
 615                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
 616                                 strlen(lsi->lsi_lmd->lmd_profile) + 1);
 617                 if (lsi->lsi_lmd->lmd_fileset != NULL)
 618                         OBD_FREE(lsi->lsi_lmd->lmd_fileset,
 619                                 strlen(lsi->lsi_lmd->lmd_fileset) + 1);
 620                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
 621                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
 622                                 strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
 623                 if (lsi->lsi_lmd->lmd_opts != NULL)
 624                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
 625                                 strlen(lsi->lsi_lmd->lmd_opts) + 1);
 626                 if (lsi->lsi_lmd->lmd_exclude_count)
 627                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
 628                                 sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
 629                                 lsi->lsi_lmd->lmd_exclude_count);
 630                 if (lsi->lsi_lmd->lmd_mgs != NULL)
 631                         OBD_FREE(lsi->lsi_lmd->lmd_mgs,
 632                                  strlen(lsi->lsi_lmd->lmd_mgs) + 1);
 633                 if (lsi->lsi_lmd->lmd_osd_type != NULL)
 634                         OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
 635                                  strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
 636                 if (lsi->lsi_lmd->lmd_params != NULL)
 637                         OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
 638                 if (lsi->lsi_lmd->lmd_nidnet != NULL)
 639                         OBD_FREE(lsi->lsi_lmd->lmd_nidnet,
 640                                 strlen(lsi->lsi_lmd->lmd_nidnet) + 1);
 641
 642                 OBD_FREE_PTR(lsi->lsi_lmd);
 643         }
 644
 645         LASSERT(lsi->lsi_llsbi == NULL);
 646         OBD_FREE_PTR(lsi);
 647         s2lsi_nocast(sb) = NULL;
 648
 649         RETURN(0);
 650 }
 651
 652 /* The lsi has one reference for every server that is using the disk -
 653    e.g. MDT, MGS, and potentially MGC */
 654 int lustre_put_lsi(struct super_block *sb)
 655 {
 656         struct lustre_sb_info *lsi = s2lsi(sb);
 657         ENTRY;
 658
 659         LASSERT(lsi != NULL);
 660
 661         CDEBUG(D_MOUNT, "put %p %d\n", sb, atomic_read(&lsi->lsi_mounts));
 662         if (atomic_dec_and_test(&lsi->lsi_mounts)) {
 663                 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
 664                         lu_device_put(&lsi->lsi_dt_dev->dd_lu_dev);
 665                         lsi->lsi_osd_exp->exp_obd->obd_lvfs_ctxt.dt = NULL;
 666                         lsi->lsi_dt_dev = NULL;
 667                         obd_disconnect(lsi->lsi_osd_exp);
 668                         /* wait till OSD is gone */
 669                         obd_zombie_barrier();
 670                 }
 671                 lustre_free_lsi(sb);
 672                 RETURN(1);
 673         }
 674         RETURN(0);
 675 }
 676
 677 /*
 678  * The goal of this function is to extract the file system name
 679  * from the obd name. This can come in two flavors. One is
 680  * fsname-MDTXXXX or fsname-XXXXXXX were X is a hexadecimal
 681  * number. In both cases we should return fsname. If it is
 682  * not a valid obd name it is assumed to be the file system
 683  * name itself.
 684  */
 685 void obdname2fsname(const char *tgt, char *fsname, size_t buflen)
 686 {
 687         const char *ptr;
 688         const char *tmp;
 689         size_t len = 0;
 690
 691         /* First we have to see if the @tgt has '-' at all. It is
 692          * valid for the user to request something like
 693          * lctl set_param -P llite.lustre*.xattr_cache=0
 694          */
 695         ptr = strrchr(tgt, '-');
 696         if (!ptr) {
 697                 /* No '-' means it could end in '*' */
 698                 ptr = strchr(tgt, '*');
 699                 if (!ptr) {
 700                         /* No '*' either. Assume tgt = fsname */
 701                         len = strlen(tgt);
 702                         goto valid_obd_name;
 703                 }
 704                 len = ptr - tgt;
 705                 goto valid_obd_name;
 706         }
 707
 708         /* tgt format fsname-MDT0000-* */
 709         if ((!strncmp(ptr, "-MDT", 4) ||
 710              !strncmp(ptr, "-OST", 4)) &&
 711              (isxdigit(ptr[4]) && isxdigit(ptr[5]) &&
 712               isxdigit(ptr[6]) && isxdigit(ptr[7]))) {
 713                 len = ptr - tgt;
 714                 goto valid_obd_name;
 715         }
 716
 717         /* tgt_format fsname-cli'dev'-'uuid' except for the llite case
 718          * which are named fsname-'uuid'. Examples:
 719          *
 720          * lustre-clilov-ffff88104db5b800
 721          * lustre-ffff88104db5b800  (for llite device)
 722          *
 723          * The length of the obd uuid can vary on different platforms.
 724          * This test if any invalid characters are in string. Allow
 725          * wildcards with '*' character.
 726          */
 727         ptr++;
 728         if (!strspn(ptr, "0123456789abcdefABCDEF*")) {
 729                 len = 0;
 730                 goto no_fsname;
 731         }
 732
 733         /* Now that we validated the device name lets extract the
 734          * file system name. Most of the names in this class will
 735          * have '-cli' in its name which needs to be dropped. If
 736          * it doesn't have '-cli' then its a llite device which
 737          * ptr already points to the start of the uuid string.
 738          */
 739         tmp = strstr(tgt, "-cli");
 740         if (tmp)
 741                 ptr = tmp;
 742         else
 743                 ptr--;
 744         len = ptr - tgt;
 745 valid_obd_name:
 746         len = min_t(size_t, len, LUSTRE_MAXFSNAME);
 747         snprintf(fsname, buflen, "%.*s", (int)len, tgt);
 748 no_fsname:
 749         fsname[len] = '\0';
 750 }
 751 EXPORT_SYMBOL(obdname2fsname);
 752
 753 /*** SERVER NAME ***
 754  * <FSNAME><SEPARATOR><TYPE><INDEX>
 755  * FSNAME is between 1 and 8 characters (inclusive).
 756  *      Excluded characters are '/' and ':'
 757  * SEPARATOR is either ':' or '-'
 758  * TYPE: "OST", "MDT", etc.
 759  * INDEX: Hex representation of the index
 760  */
 761
 762 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
 763  * @param [in] svname server name including type and index
 764  * @param [out] fsname Buffer to copy filesystem name prefix into.
 765  *  Must have at least 'strlen(fsname) + 1' chars.
 766  * @param [out] endptr if endptr isn't NULL it is set to end of fsname
 767  * rc < 0  on error
 768  */
 769 int server_name2fsname(const char *svname, char *fsname, const char **endptr)
 770 {
 771         const char *dash;
 772
 773         dash = svname + strnlen(svname, LUSTRE_MAXFSNAME);
 774         for (; dash > svname && *dash != '-' && *dash != ':'; dash--)
 775                 ;
 776         if (dash == svname)
 777                 return -EINVAL;
 778
 779         if (fsname != NULL) {
 780                 strncpy(fsname, svname, dash - svname);
 781                 fsname[dash - svname] = '\0';
 782         }
 783
 784         if (endptr != NULL)
 785                 *endptr = dash;
 786
 787         return 0;
 788 }
 789 EXPORT_SYMBOL(server_name2fsname);
 790
 791 /**
 792  * Get service name (svname) from string
 793  * rc < 0 on error
 794  * if endptr isn't NULL it is set to end of fsname *
 795  */
 796 int server_name2svname(const char *label, char *svname, const char **endptr,
 797                        size_t svsize)
 798 {
 799         int rc;
 800         const char *dash;
 801
 802         /* We use server_name2fsname() just for parsing */
 803         rc = server_name2fsname(label, NULL, &dash);
 804         if (rc != 0)
 805                 return rc;
 806
 807         if (endptr != NULL)
 808                 *endptr = dash;
 809
 810         if (strlcpy(svname, dash + 1, svsize) >= svsize)
 811                 return -E2BIG;
 812
 813         return 0;
 814 }
 815 EXPORT_SYMBOL(server_name2svname);
 816
 817 /**
 818  * check server name is OST.
 819  **/
 820 int server_name_is_ost(const char *svname)
 821 {
 822         const char *dash;
 823         int rc;
 824
 825         /* We use server_name2fsname() just for parsing */
 826         rc = server_name2fsname(svname, NULL, &dash);
 827         if (rc != 0)
 828                 return rc;
 829
 830         dash++;
 831
 832         if (strncmp(dash, "OST", 3) == 0)
 833                 return 1;
 834         return 0;
 835 }
 836 EXPORT_SYMBOL(server_name_is_ost);
 837
 838 /**
 839  * Get the index from the target name MDTXXXX/OSTXXXX
 840  * rc = server type, or rc < 0  on error
 841  **/
 842 int target_name2index(const char *tgtname, __u32 *idx, const char **endptr)
 843 {
 844         const char *dash = tgtname;
 845         unsigned long index;
 846         int rc;
 847
 848         if (strncmp(dash, "MDT", 3) == 0)
 849                 rc = LDD_F_SV_TYPE_MDT;
 850         else if (strncmp(dash, "OST", 3) == 0)
 851                 rc = LDD_F_SV_TYPE_OST;
 852         else
 853                 return -EINVAL;
 854
 855         dash += 3;
 856
 857         if (strncmp(dash, "all", 3) == 0) {
 858                 if (endptr != NULL)
 859                         *endptr = dash + 3;
 860                 return rc | LDD_F_SV_ALL;
 861         }
 862
 863         index = simple_strtoul(dash, (char **)endptr, 16);
 864         if (idx != NULL)
 865                 *idx = index;
 866         return rc;
 867 }
 868 EXPORT_SYMBOL(target_name2index);
 869
 870 /* Get the index from the obd name.
 871    rc = server type, or
 872    rc < 0  on error
 873    if endptr isn't NULL it is set to end of name */
 874 int server_name2index(const char *svname, __u32 *idx, const char **endptr)
 875 {
 876         const char *dash;
 877         int rc;
 878
 879         /* We use server_name2fsname() just for parsing */
 880         rc = server_name2fsname(svname, NULL, &dash);
 881         if (rc != 0)
 882                 return rc;
 883
 884         dash++;
 885         rc = target_name2index(dash, idx, endptr);
 886         if (rc < 0)
 887                 return rc;
 888
 889         /* Account for -mdc after index that is possible when specifying mdt */
 890         if (endptr != NULL && strncmp(LUSTRE_MDC_NAME, *endptr + 1,
 891                                       sizeof(LUSTRE_MDC_NAME)-1) == 0)
 892                 *endptr += sizeof(LUSTRE_MDC_NAME);
 893
 894         return rc;
 895 }
 896 EXPORT_SYMBOL(server_name2index);
 897
 898 /*************** mount common betweeen server and client ***************/
 899
 900 /* Common umount */
 901 int lustre_common_put_super(struct super_block *sb)
 902 {
 903         int rc;
 904         ENTRY;
 905
 906         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
 907
 908         /* Drop a ref to the MGC */
 909         rc = lustre_stop_mgc(sb);
 910         if (rc && (rc != -ENOENT)) {
 911                 if (rc != -EBUSY) {
 912                         CERROR("Can't stop MGC: %d\n", rc);
 913                         RETURN(rc);
 914                 }
 915                 /* BUSY just means that there's some other obd that
 916                    needs the mgc.  Let him clean it up. */
 917                 CDEBUG(D_MOUNT, "MGC still in use\n");
 918         }
 919         /* Drop a ref to the mounted disk */
 920         lustre_put_lsi(sb);
 921
 922         RETURN(rc);
 923 }
 924 EXPORT_SYMBOL(lustre_common_put_super);
 925
 926 static void lmd_print(struct lustre_mount_data *lmd)
 927 {
 928         int i;
 929
 930         PRINT_CMD(D_MOUNT, "  mount data:\n");
 931         if (lmd_is_client(lmd))
 932                 PRINT_CMD(D_MOUNT, "profile: %s\n", lmd->lmd_profile);
 933         PRINT_CMD(D_MOUNT, "device:  %s\n", lmd->lmd_dev);
 934         PRINT_CMD(D_MOUNT, "flags:   %x\n", lmd->lmd_flags);
 935
 936         if (lmd->lmd_opts)
 937                 PRINT_CMD(D_MOUNT, "options: %s\n", lmd->lmd_opts);
 938
 939         if (lmd->lmd_recovery_time_soft)
 940                 PRINT_CMD(D_MOUNT, "recovery time soft: %d\n",
 941                           lmd->lmd_recovery_time_soft);
 942
 943         if (lmd->lmd_recovery_time_hard)
 944                 PRINT_CMD(D_MOUNT, "recovery time hard: %d\n",
 945                           lmd->lmd_recovery_time_hard);
 946
 947         for (i = 0; i < lmd->lmd_exclude_count; i++) {
 948                 PRINT_CMD(D_MOUNT, "exclude %d:  OST%04x\n", i,
 949                           lmd->lmd_exclude[i]);
 950         }
 951 }
 952
 953 /* Is this server on the exclusion list */
 954 int lustre_check_exclusion(struct super_block *sb, char *svname)
 955 {
 956         struct lustre_sb_info *lsi = s2lsi(sb);
 957         struct lustre_mount_data *lmd = lsi->lsi_lmd;
 958         __u32 index;
 959         int i, rc;
 960         ENTRY;
 961
 962         rc = server_name2index(svname, &index, NULL);
 963         if (rc != LDD_F_SV_TYPE_OST)
 964                 /* Only exclude OSTs */
 965                 RETURN(0);
 966
 967         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
 968                index, lmd->lmd_exclude_count, lmd->lmd_dev);
 969
 970         for(i = 0; i < lmd->lmd_exclude_count; i++) {
 971                 if (index == lmd->lmd_exclude[i]) {
 972                         CWARN("Excluding %s (on exclusion list)\n", svname);
 973                         RETURN(1);
 974                 }
 975         }
 976         RETURN(0);
 977 }
 978
 979 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
 980 static int lmd_make_exclusion(struct lustre_mount_data *lmd, const char *ptr)
 981 {
 982         const char *s1 = ptr, *s2;
 983         __u32 *exclude_list;
 984         __u32 index = 0;
 985         int rc = 0, devmax;
 986         ENTRY;
 987
 988         /* The shortest an ost name can be is 8 chars: -OST0000.
 989            We don't actually know the fsname at this time, so in fact
 990            a user could specify any fsname. */
 991         devmax = strlen(ptr) / 8 + 1;
 992
 993         /* temp storage until we figure out how many we have */
 994         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
 995         if (!exclude_list)
 996                 RETURN(-ENOMEM);
 997
 998         /* we enter this fn pointing at the '=' */
 999         while (*s1 && *s1 != ' ' && *s1 != ',') {
1000                 s1++;
1001                 rc = server_name2index(s1, &index, &s2);
1002                 if (rc < 0) {
1003                         CERROR("Can't parse server name '%s': rc = %d\n",
1004                                s1, rc);
1005                         break;
1006                 }
1007                 if (rc == LDD_F_SV_TYPE_OST)
1008                         exclude_list[lmd->lmd_exclude_count++] = index;
1009                 else
1010                         CDEBUG(D_MOUNT, "ignoring exclude %.*s: type = %#x\n",
1011                                (uint)(s2-s1), s1, rc);
1012                 s1 = s2;
1013                 /* now we are pointing at ':' (next exclude)
1014                    or ',' (end of excludes) */
1015                 if (lmd->lmd_exclude_count >= devmax)
1016                         break;
1017         }
1018         if (rc >= 0) /* non-err */
1019                 rc = 0;
1020
1021         if (lmd->lmd_exclude_count) {
1022                 /* permanent, freed in lustre_free_lsi */
1023                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
1024                           lmd->lmd_exclude_count);
1025                 if (lmd->lmd_exclude) {
1026                         memcpy(lmd->lmd_exclude, exclude_list,
1027                                sizeof(index) * lmd->lmd_exclude_count);
1028                 } else {
1029                         rc = -ENOMEM;
1030                         lmd->lmd_exclude_count = 0;
1031                 }
1032         }
1033         OBD_FREE(exclude_list, sizeof(index) * devmax);
1034         RETURN(rc);
1035 }
1036
1037 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
1038 {
1039         char   *tail;
1040         int     length;
1041
1042         if (lmd->lmd_mgssec != NULL) {
1043                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
1044                 lmd->lmd_mgssec = NULL;
1045         }
1046
1047         tail = strchr(ptr, ',');
1048         if (tail == NULL)
1049                 length = strlen(ptr);
1050         else
1051                 length = tail - ptr;
1052
1053         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
1054         if (lmd->lmd_mgssec == NULL)
1055                 return -ENOMEM;
1056
1057         memcpy(lmd->lmd_mgssec, ptr, length);
1058         lmd->lmd_mgssec[length] = '\0';
1059         return 0;
1060 }
1061
1062 static int lmd_parse_network(struct lustre_mount_data *lmd, char *ptr)
1063 {
1064         char   *tail;
1065         int     length;
1066
1067         if (lmd->lmd_nidnet != NULL) {
1068                 OBD_FREE(lmd->lmd_nidnet, strlen(lmd->lmd_nidnet) + 1);
1069                 lmd->lmd_nidnet = NULL;
1070         }
1071
1072         tail = strchr(ptr, ',');
1073         if (tail == NULL)
1074                 length = strlen(ptr);
1075         else
1076                 length = tail - ptr;
1077
1078         OBD_ALLOC(lmd->lmd_nidnet, length + 1);
1079         if (lmd->lmd_nidnet == NULL)
1080                 return -ENOMEM;
1081
1082         memcpy(lmd->lmd_nidnet, ptr, length);
1083         lmd->lmd_nidnet[length] = '\0';
1084         return 0;
1085 }
1086
1087 static int lmd_parse_string(char **handle, char *ptr)
1088 {
1089         char   *tail;
1090         int     length;
1091
1092         if ((handle == NULL) || (ptr == NULL))
1093                 return -EINVAL;
1094
1095         if (*handle != NULL) {
1096                 OBD_FREE(*handle, strlen(*handle) + 1);
1097                 *handle = NULL;
1098         }
1099
1100         tail = strchr(ptr, ',');
1101         if (tail == NULL)
1102                 length = strlen(ptr);
1103         else
1104                 length = tail - ptr;
1105
1106         OBD_ALLOC(*handle, length + 1);
1107         if (*handle == NULL)
1108                 return -ENOMEM;
1109
1110         memcpy(*handle, ptr, length);
1111         (*handle)[length] = '\0';
1112
1113         return 0;
1114 }
1115
1116 /* Collect multiple values for mgsnid specifiers */
1117 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
1118 {
1119         lnet_nid_t nid;
1120         char *tail = *ptr;
1121         char *mgsnid;
1122         int   length;
1123         int   oldlen = 0;
1124
1125         /* Find end of nidlist */
1126         while (class_parse_nid_quiet(tail, &nid, &tail) == 0) {}
1127         length = tail - *ptr;
1128         if (length == 0) {
1129                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
1130                 return -EINVAL;
1131         }
1132
1133         if (lmd->lmd_mgs != NULL)
1134                 oldlen = strlen(lmd->lmd_mgs) + 1;
1135
1136         OBD_ALLOC(mgsnid, oldlen + length + 1);
1137         if (mgsnid == NULL)
1138                 return -ENOMEM;
1139
1140         if (lmd->lmd_mgs != NULL) {
1141                 /* Multiple mgsnid= are taken to mean failover locations */
1142                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
1143                 mgsnid[oldlen - 1] = ':';
1144                 OBD_FREE(lmd->lmd_mgs, oldlen);
1145         }
1146         memcpy(mgsnid + oldlen, *ptr, length);
1147         mgsnid[oldlen + length] = '\0';
1148         lmd->lmd_mgs = mgsnid;
1149         *ptr = tail;
1150
1151         return 0;
1152 }
1153
1154 /**
1155  * Find the first delimiter (comma or colon) from the specified \a buf and
1156  * make \a *endh point to the string starting with the delimiter. The commas
1157  * in expression list [...] will be skipped.
1158  *
1159  * @buf         a delimiter-separated string
1160  * @endh        a pointer to a pointer that will point to the string
1161  *              starting with the delimiter
1162  *
1163  * RETURNS      true if delimiter is found, false if delimiter is not found
1164  */
1165 static bool lmd_find_delimiter(char *buf, char **endh)
1166 {
1167         char *c = buf;
1168         size_t pos;
1169         bool found;
1170
1171         if (!buf)
1172                 return false;
1173 try_again:
1174         if (*c == ',' || *c == ':')
1175                 return true;
1176
1177         pos = strcspn(c, "[:,]");
1178         if (!pos)
1179                 return false;
1180
1181         /* Not a valid mount string */
1182         if (*c == ']') {
1183                 CWARN("invalid mount string format\n");
1184                 return false;
1185         }
1186
1187         c += pos;
1188         if (*c == '[') {
1189                 c = strchr(c, ']');
1190
1191                 /* invalid mount string */
1192                 if (!c) {
1193                         CWARN("invalid mount string format\n");
1194                         return false;
1195                 }
1196                 c++;
1197                 goto try_again;
1198         }
1199
1200         found = *c != '\0';
1201         if (found && endh)
1202                 *endh = c;
1203
1204         return found;
1205 }
1206
1207 /**
1208  * Find the first valid string delimited by comma or colon from the specified
1209  * \a buf and parse it to see whether it's a valid nid list. If yes, \a *endh
1210  * will point to the next string starting with the delimiter.
1211  *
1212  * \param[in] buf       a delimiter-separated string
1213  * \param[in] endh      a pointer to a pointer that will point to the string
1214  *                      starting with the delimiter
1215  *
1216  * \retval 0            if the string is a valid nid list
1217  * \retval 1            if the string is not a valid nid list
1218  */
1219 static int lmd_parse_nidlist(char *buf, char **endh)
1220 {
1221         struct list_head nidlist;
1222         char            *endp = buf;
1223         char             tmp;
1224         int              rc = 0;
1225
1226         if (buf == NULL)
1227                 return 1;
1228         while (*buf == ',' || *buf == ':')
1229                 buf++;
1230         if (*buf == ' ' || *buf == '/' || *buf == '\0')
1231                 return 1;
1232
1233         if (!lmd_find_delimiter(buf, &endp))
1234                 endp = buf + strlen(buf);
1235
1236         tmp = *endp;
1237         *endp = '\0';
1238
1239         INIT_LIST_HEAD(&nidlist);
1240         if (cfs_parse_nidlist(buf, strlen(buf), &nidlist) <= 0)
1241                 rc = 1;
1242         cfs_free_nidlist(&nidlist);
1243
1244         *endp = tmp;
1245         if (rc != 0)
1246                 return rc;
1247         if (endh != NULL)
1248                 *endh = endp;
1249         return 0;
1250 }
1251
1252 /** Parse mount line options
1253  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
1254  * dev is passed as device=uml1:/lustre by mount.lustre
1255  */
1256 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
1257 {
1258         char *s1, *s2, *devname = NULL;
1259         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
1260         int rc = 0;
1261         ENTRY;
1262
1263         LASSERT(lmd);
1264         if (!options) {
1265                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
1266                                    "/sbin/mount.lustre is installed.\n");
1267                 RETURN(-EINVAL);
1268         }
1269
1270         /* Options should be a string - try to detect old lmd data */
1271         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
1272                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
1273                                    "/sbin/mount.lustre.  Please install "
1274                                    "version %s\n", LUSTRE_VERSION_STRING);
1275                 RETURN(-EINVAL);
1276         }
1277         lmd->lmd_magic = LMD_MAGIC;
1278
1279         OBD_ALLOC(lmd->lmd_params, LMD_PARAMS_MAXLEN);
1280         if (lmd->lmd_params == NULL)
1281                 RETURN(-ENOMEM);
1282         lmd->lmd_params[0] = '\0';
1283
1284         /* Set default flags here */
1285
1286         s1 = options;
1287         while (*s1) {
1288                 int clear = 0;
1289                 int time_min = OBD_RECOVERY_TIME_MIN;
1290                 char *s3;
1291
1292                 /* Skip whitespace and extra commas */
1293                 while (*s1 == ' ' || *s1 == ',')
1294                         s1++;
1295                 s3 = s1;
1296
1297                 /* Client options are parsed in ll_options: eg. flock,
1298                    user_xattr, acl */
1299
1300                 /* Parse non-ldiskfs options here. Rather than modifying
1301                    ldiskfs, we just zero these out here */
1302                 if (strncmp(s1, "abort_recov", 11) == 0) {
1303                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
1304                         clear++;
1305                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
1306                         lmd->lmd_recovery_time_soft =
1307                                 max_t(int, simple_strtoul(s1 + 19, NULL, 10),
1308                                       time_min);
1309                         clear++;
1310                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
1311                         lmd->lmd_recovery_time_hard =
1312                                 max_t(int, simple_strtoul(s1 + 19, NULL, 10),
1313                                       time_min);
1314                         clear++;
1315                 } else if (strncmp(s1, "noir", 4) == 0) {
1316                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
1317                         clear++;
1318                 } else if (strncmp(s1, "nosvc", 5) == 0) {
1319                         lmd->lmd_flags |= LMD_FLG_NOSVC;
1320                         clear++;
1321                 } else if (strncmp(s1, "nomgs", 5) == 0) {
1322                         lmd->lmd_flags |= LMD_FLG_NOMGS;
1323                         clear++;
1324                 } else if (strncmp(s1, "noscrub", 7) == 0) {
1325                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
1326                         clear++;
1327                 } else if (strncmp(s1, "skip_lfsck", 10) == 0) {
1328                         lmd->lmd_flags |= LMD_FLG_SKIP_LFSCK;
1329                         clear++;
1330                 } else if (strncmp(s1, "rdonly_dev", 10) == 0) {
1331                         lmd->lmd_flags |= LMD_FLG_DEV_RDONLY;
1332                         clear++;
1333                 } else if (strncmp(s1, PARAM_MGSNODE,
1334                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
1335                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
1336                         /* Assume the next mount opt is the first
1337                            invalid nid we get to. */
1338                         rc = lmd_parse_mgs(lmd, &s2);
1339                         if (rc)
1340                                 goto invalid;
1341                         s3 = s2;
1342                         clear++;
1343                 } else if (strncmp(s1, "writeconf", 9) == 0) {
1344                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
1345                         clear++;
1346                 } else if (strncmp(s1, "update", 6) == 0) {
1347                         lmd->lmd_flags |= LMD_FLG_UPDATE;
1348                         clear++;
1349                 } else if (strncmp(s1, "virgin", 6) == 0) {
1350                         lmd->lmd_flags |= LMD_FLG_VIRGIN;
1351                         clear++;
1352                 } else if (strncmp(s1, "noprimnode", 10) == 0) {
1353                         lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
1354                         clear++;
1355                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
1356                         rc = lmd_parse_mgssec(lmd, s1 + 7);
1357                         if (rc)
1358                                 goto invalid;
1359                         clear++;
1360                         /* ost exclusion list */
1361                 } else if (strncmp(s1, "exclude=", 8) == 0) {
1362                         rc = lmd_make_exclusion(lmd, s1 + 7);
1363                         if (rc)
1364                                 goto invalid;
1365                         clear++;
1366                 } else if (strncmp(s1, "mgs", 3) == 0) {
1367                         /* We are an MGS */
1368                         lmd->lmd_flags |= LMD_FLG_MGS;
1369                         clear++;
1370                 } else if (strncmp(s1, "svname=", 7) == 0) {
1371                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
1372                         if (rc)
1373                                 goto invalid;
1374                         clear++;
1375                 } else if (strncmp(s1, "param=", 6) == 0) {
1376                         size_t length, params_length;
1377                         char  *tail = s1;
1378
1379                         if (lmd_find_delimiter(s1 + 6, &tail)) {
1380                                 char *param_str = tail + 1;
1381                                 int   supplementary = 1;
1382                                 while (lmd_parse_nidlist(param_str,
1383                                                          &param_str) == 0) {
1384                                         supplementary = 0;
1385                                 }
1386                                 length = param_str - s1 - supplementary;
1387                         } else {
1388                                 length = strlen(s1);
1389                         }
1390                         length -= 6;
1391                         params_length = strlen(lmd->lmd_params);
1392                         if (params_length + length + 1 >= LMD_PARAMS_MAXLEN)
1393                                 RETURN(-E2BIG);
1394                         strncat(lmd->lmd_params, s1 + 6, length);
1395                         lmd->lmd_params[params_length + length] = '\0';
1396                         strlcat(lmd->lmd_params, " ", LMD_PARAMS_MAXLEN);
1397                         s3 = s1 + 6 + length;
1398                         clear++;
1399                 } else if (strncmp(s1, "osd=", 4) == 0) {
1400                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
1401                         if (rc)
1402                                 goto invalid;
1403                         clear++;
1404                 }
1405                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
1406                    end of the options. */
1407                 else if (strncmp(s1, "device=", 7) == 0) {
1408                         devname = s1 + 7;
1409                         /* terminate options right before device.  device
1410                            must be the last one. */
1411                         *s1 = '\0';
1412                         break;
1413                 } else if (strncmp(s1, "network=", 8) == 0) {
1414                         rc = lmd_parse_network(lmd, s1 + 8);
1415                         if (rc)
1416                                 goto invalid;
1417
1418                         /* check if LNet dynamic peer discovery is activated */
1419                         if (LNetGetPeerDiscoveryStatus()) {
1420                                 CERROR("LNet Dynamic Peer Discovery is enabled "
1421                                        "on this node. 'network' mount option "
1422                                        "cannot be taken into account.\n");
1423                                 goto invalid;
1424                         }
1425
1426                         clear++;
1427                 }
1428
1429                 /* Find next opt */
1430                 s2 = strchr(s3, ',');
1431                 if (s2 == NULL) {
1432                         if (clear)
1433                                 *s1 = '\0';
1434                         break;
1435                 }
1436                 s2++;
1437                 if (clear)
1438                         memmove(s1, s2, strlen(s2) + 1);
1439                 else
1440                         s1 = s2;
1441         }
1442
1443         if (!devname) {
1444                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
1445                                    "(need mount option 'device=...')\n");
1446                 goto invalid;
1447         }
1448
1449         s1 = strstr(devname, ":/");
1450         if (s1) {
1451                 ++s1;
1452                 lmd->lmd_flags |= LMD_FLG_CLIENT;
1453                 /* Remove leading /s from fsname */
1454                 while (*++s1 == '/')
1455                         ;
1456                 s2 = s1;
1457                 while (*s2 != '/' && *s2 != '\0')
1458                         s2++;
1459                 /* Freed in lustre_free_lsi */
1460                 OBD_ALLOC(lmd->lmd_profile, s2 - s1 + 8);
1461                 if (!lmd->lmd_profile)
1462                         RETURN(-ENOMEM);
1463
1464                 strncat(lmd->lmd_profile, s1, s2 - s1);
1465                 strncat(lmd->lmd_profile, "-client", 7);
1466
1467                 s1 = s2;
1468                 s2 = s1 + strlen(s1) - 1;
1469                 /* Remove padding /s from fileset */
1470                 while (*s2 == '/')
1471                         s2--;
1472                 if (s2 > s1) {
1473                         OBD_ALLOC(lmd->lmd_fileset, s2 - s1 + 2);
1474                         if (lmd->lmd_fileset == NULL) {
1475                                 OBD_FREE(lmd->lmd_profile,
1476                                          strlen(lmd->lmd_profile) + 1);
1477                                 RETURN(-ENOMEM);
1478                         }
1479                         strncat(lmd->lmd_fileset, s1, s2 - s1 + 1);
1480                 }
1481         } else {
1482                 /* server mount */
1483                 if (lmd->lmd_nidnet != NULL) {
1484                         /* 'network=' mount option forbidden for server */
1485                         OBD_FREE(lmd->lmd_nidnet, strlen(lmd->lmd_nidnet) + 1);
1486                         lmd->lmd_nidnet = NULL;
1487                         rc = -EINVAL;
1488                         CERROR("%s: option 'network=' not allowed for Lustre "
1489                                "servers: rc = %d\n", devname, rc);
1490                         RETURN(rc);
1491                 }
1492         }
1493
1494         /* Freed in lustre_free_lsi */
1495         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
1496         if (!lmd->lmd_dev)
1497                 RETURN(-ENOMEM);
1498         strncpy(lmd->lmd_dev, devname, strlen(devname)+1);
1499
1500         /* Save mount options */
1501         s1 = options + strlen(options) - 1;
1502         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
1503                 *s1-- = 0;
1504         while (*options && (*options == ',' || *options == ' '))
1505                 options++;
1506         if (*options != 0) {
1507                 /* Freed in lustre_free_lsi */
1508                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
1509                 if (!lmd->lmd_opts)
1510                         RETURN(-ENOMEM);
1511                 strncpy(lmd->lmd_opts, options, strlen(options)+1);
1512         }
1513
1514         lmd_print(lmd);
1515         lmd->lmd_magic = LMD_MAGIC;
1516
1517         RETURN(rc);
1518
1519 invalid:
1520         CERROR("Bad mount options %s\n", options);
1521         RETURN(-EINVAL);
1522 }
1523
1524 struct lustre_mount_data2 {
1525         void *lmd2_data;
1526         struct vfsmount *lmd2_mnt;
1527 };
1528
1529 /** This is the entry point for the mount call into Lustre.
1530  * This is called when a server or client is mounted,
1531  * and this is where we start setting things up.
1532  * @param data Mount options (e.g. -o flock,abort_recov)
1533  */
1534 static int lustre_fill_super(struct super_block *sb, void *data, int silent)
1535 {
1536         struct lustre_mount_data *lmd;
1537         struct lustre_mount_data2 *lmd2 = data;
1538         struct lustre_sb_info *lsi;
1539         int rc;
1540         ENTRY;
1541
1542         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
1543
1544         lsi = lustre_init_lsi(sb);
1545         if (!lsi)
1546                 RETURN(-ENOMEM);
1547         lmd = lsi->lsi_lmd;
1548
1549         /*
1550          * Disable lockdep during mount, because mount locking patterns are
1551          * `special'.
1552          */
1553         lockdep_off();
1554
1555         /*
1556          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
1557          */
1558         obd_zombie_barrier();
1559
1560         /* Figure out the lmd from the mount options */
1561         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
1562                 lustre_put_lsi(sb);
1563                 GOTO(out, rc = -EINVAL);
1564         }
1565
1566         if (lmd_is_client(lmd)) {
1567                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
1568                 if (client_fill_super == NULL)
1569                         request_module("lustre");
1570                 if (client_fill_super == NULL) {
1571                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
1572                                            "client mount! Is the 'lustre' "
1573                                            "module loaded?\n");
1574                         lustre_put_lsi(sb);
1575                         rc = -ENODEV;
1576                 } else {
1577                         rc = lustre_start_mgc(sb);
1578                         if (rc) {
1579                                 lustre_common_put_super(sb);
1580                                 GOTO(out, rc);
1581                         }
1582                         /* Connect and start */
1583                         /* (should always be ll_fill_super) */
1584                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
1585                         /* c_f_s will call lustre_common_put_super on failure */
1586                 }
1587         } else {
1588 #ifdef HAVE_SERVER_SUPPORT
1589                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
1590                 rc = server_fill_super(sb);
1591                 /* s_f_s calls lustre_start_mgc after the mount because we need
1592                    the MGS nids which are stored on disk.  Plus, we may
1593                    need to start the MGS first. */
1594                 /* s_f_s will call server_put_super on failure */
1595 #else
1596                 CERROR("This is client-side-only module, "
1597                        "cannot handle server mount.\n");
1598                 rc = -EINVAL;
1599 #endif
1600         }
1601
1602         /* If error happens in fill_super() call, @lsi will be killed there.
1603          * This is why we do not put it here. */
1604         GOTO(out, rc);
1605 out:
1606         if (rc) {
1607                 CERROR("Unable to mount %s (%d)\n",
1608                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
1609         } else {
1610                 CDEBUG(D_SUPER, "Mount %s complete\n",
1611                        lmd->lmd_dev);
1612         }
1613         lockdep_on();
1614         return rc;
1615 }
1616
1617
1618 /* We can't call ll_fill_super by name because it lives in a module that
1619    must be loaded after this one. */
1620 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
1621                                                   struct vfsmount *mnt))
1622 {
1623         client_fill_super = cfs;
1624 }
1625 EXPORT_SYMBOL(lustre_register_client_fill_super);
1626
1627 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
1628 {
1629         kill_super_cb = cfs;
1630 }
1631 EXPORT_SYMBOL(lustre_register_kill_super_cb);
1632
1633 /***************** FS registration ******************/
1634 #ifdef HAVE_FSTYPE_MOUNT
1635 static struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
1636                                    const char *devname, void *data)
1637 {
1638         struct lustre_mount_data2 lmd2 = {
1639                 .lmd2_data = data,
1640         };
1641
1642         return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
1643 }
1644 #else
1645 static int lustre_get_sb(struct file_system_type *fs_type, int flags,
1646                          const char *devname, void *data, struct vfsmount *mnt)
1647 {
1648         struct lustre_mount_data2 lmd2 = {
1649                 .lmd2_data = data,
1650                 .lmd2_mnt = mnt,
1651         };
1652
1653         return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
1654 }
1655 #endif
1656
1657 static void lustre_kill_super(struct super_block *sb)
1658 {
1659         struct lustre_sb_info *lsi = s2lsi(sb);
1660
1661         if (kill_super_cb && lsi && !IS_SERVER(lsi))
1662                 (*kill_super_cb)(sb);
1663
1664         kill_anon_super(sb);
1665 }
1666
1667 /** Register the "lustre" fs type
1668  */
1669 static struct file_system_type lustre_fs_type = {
1670         .owner        = THIS_MODULE,
1671         .name         = "lustre",
1672 #ifdef HAVE_FSTYPE_MOUNT
1673         .mount        = lustre_mount,
1674 #else
1675         .get_sb       = lustre_get_sb,
1676 #endif
1677         .kill_sb      = lustre_kill_super,
1678         .fs_flags     = FS_REQUIRES_DEV | FS_HAS_FIEMAP | FS_RENAME_DOES_D_MOVE,
1679 };
1680 MODULE_ALIAS_FS("lustre");
1681
1682 int lustre_register_fs(void)
1683 {
1684         return register_filesystem(&lustre_fs_type);
1685 }
1686
1687 int lustre_unregister_fs(void)
1688 {
1689         return unregister_filesystem(&lustre_fs_type);
1690 }