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