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, 2014, 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
 187 /** Call class_attach and class_setup.  These methods in turn call
 188  * obd type-specific methods.
 189  */
 190 int lustre_start_simple(char *obdname, char *type, char *uuid,
 191                         char *s1, char *s2, char *s3, char *s4)
 192 {
 193         int rc;
 194         CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
 195
 196         rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, NULL, NULL);
 197         if (rc) {
 198                 CERROR("%s attach error %d\n", obdname, rc);
 199                 return rc;
 200         }
 201         rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, s3, s4);
 202         if (rc) {
 203                 CERROR("%s setup error %d\n", obdname, rc);
 204                 do_lcfg(obdname, 0, LCFG_DETACH, NULL, NULL, NULL, NULL);
 205         }
 206         return rc;
 207 }
 208
 209 static DEFINE_MUTEX(mgc_start_lock);
 210
 211 /** Set up a mgc obd to process startup logs
 212  *
 213  * \param sb [in] super block of the mgc obd
 214  *
 215  * \retval 0 success, otherwise error code
 216  */
 217 int lustre_start_mgc(struct super_block *sb)
 218 {
 219         struct obd_connect_data *data = NULL;
 220         struct lustre_sb_info *lsi = s2lsi(sb);
 221         struct obd_device *obd;
 222         struct obd_export *exp;
 223         struct obd_uuid *uuid;
 224         class_uuid_t uuidc;
 225         lnet_nid_t nid;
 226         char *mgcname = NULL, *niduuid = NULL, *mgssec = NULL;
 227         char *ptr;
 228         int rc = 0, i = 0, j, len;
 229         ENTRY;
 230
 231         LASSERT(lsi->lsi_lmd);
 232
 233         /* Find the first non-lo MGS nid for our MGC name */
 234         if (IS_SERVER(lsi)) {
 235                 /* mount -o mgsnode=nid */
 236                 ptr = lsi->lsi_lmd->lmd_mgs;
 237                 if (lsi->lsi_lmd->lmd_mgs &&
 238                     (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
 239                         i++;
 240                 } else if (IS_MGS(lsi)) {
 241                         lnet_process_id_t id;
 242                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 243                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 244                                         continue;
 245                                 nid = id.nid;
 246                                 i++;
 247                                 break;
 248                         }
 249                 }
 250         } else { /* client */
 251                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 252                 ptr = lsi->lsi_lmd->lmd_dev;
 253                 if (class_parse_nid(ptr, &nid, &ptr) == 0)
 254                         i++;
 255         }
 256         if (i == 0) {
 257                 CERROR("No valid MGS nids found.\n");
 258                 RETURN(-EINVAL);
 259         }
 260
 261         mutex_lock(&mgc_start_lock);
 262
 263         len = strlen(LUSTRE_MGC_OBDNAME) + strlen(libcfs_nid2str(nid)) + 1;
 264         OBD_ALLOC(mgcname, len);
 265         OBD_ALLOC(niduuid, len + 2);
 266         if (!mgcname || !niduuid)
 267                 GOTO(out_free, rc = -ENOMEM);
 268         sprintf(mgcname, "%s%s", LUSTRE_MGC_OBDNAME, libcfs_nid2str(nid));
 269
 270         mgssec = lsi->lsi_lmd->lmd_mgssec ? lsi->lsi_lmd->lmd_mgssec : "";
 271
 272         OBD_ALLOC_PTR(data);
 273         if (data == NULL)
 274                 GOTO(out_free, rc = -ENOMEM);
 275
 276         obd = class_name2obd(mgcname);
 277         if (obd && !obd->obd_stopping) {
 278                 int recov_bk;
 279
 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, NULL, NULL, NULL);
 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, NULL, NULL, NULL);
 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, NULL, NULL, NULL);
 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, NULL, NULL);
 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, NULL, NULL, NULL);
 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, NULL, NULL, NULL);
 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         /* We connect to the MGS at setup, and don't disconnect until cleanup */
 453         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
 454                                   OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV |
 455                                   OBD_CONNECT_LVB_TYPE;
 456
 457 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0)
 458         data->ocd_connect_flags |= OBD_CONNECT_MNE_SWAB;
 459 #endif
 460
 461         if (lmd_is_client(lsi->lsi_lmd) &&
 462             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
 463                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
 464         data->ocd_version = LUSTRE_VERSION_CODE;
 465         rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
 466         if (rc) {
 467                 CERROR("connect failed %d\n", rc);
 468                 GOTO(out, rc);
 469         }
 470
 471         obd->u.cli.cl_mgc_mgsexp = exp;
 472
 473 out:
 474         /* Keep the mgc info in the sb. Note that many lsi's can point
 475            to the same mgc.*/
 476         lsi->lsi_mgc = obd;
 477 out_free:
 478         mutex_unlock(&mgc_start_lock);
 479
 480         if (data)
 481                 OBD_FREE_PTR(data);
 482         if (mgcname)
 483                 OBD_FREE(mgcname, len);
 484         if (niduuid)
 485                 OBD_FREE(niduuid, len + 2);
 486         RETURN(rc);
 487 }
 488
 489 static int lustre_stop_mgc(struct super_block *sb)
 490 {
 491         struct lustre_sb_info *lsi = s2lsi(sb);
 492         struct obd_device *obd;
 493         char *niduuid = NULL, *ptr = NULL;
 494         int i, rc = 0, len = 0;
 495         ENTRY;
 496
 497         if (!lsi)
 498                 RETURN(-ENOENT);
 499         obd = lsi->lsi_mgc;
 500         if (!obd)
 501                 RETURN(-ENOENT);
 502         lsi->lsi_mgc = NULL;
 503
 504         mutex_lock(&mgc_start_lock);
 505         LASSERT(atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
 506         if (!atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 507                 /* This is not fatal, every client that stops
 508                    will call in here. */
 509                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 510                        atomic_read(&obd->u.cli.cl_mgc_refcount));
 511                 GOTO(out, rc = -EBUSY);
 512         }
 513
 514         /* The MGC has no recoverable data in any case.
 515          * force shotdown set in umount_begin */
 516         obd->obd_no_recov = 1;
 517
 518         if (obd->u.cli.cl_mgc_mgsexp) {
 519                 /* An error is not fatal, if we are unable to send the
 520                    disconnect mgs ping evictor cleans up the export */
 521                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 522                 if (rc)
 523                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 524         }
 525
 526         /* Save the obdname for cleaning the nid uuids, which are
 527            obdname_XX */
 528         len = strlen(obd->obd_name) + 6;
 529         OBD_ALLOC(niduuid, len);
 530         if (niduuid) {
 531                 strcpy(niduuid, obd->obd_name);
 532                 ptr = niduuid + strlen(niduuid);
 533         }
 534
 535         rc = class_manual_cleanup(obd);
 536         if (rc)
 537                 GOTO(out, rc);
 538
 539         /* Clean the nid uuids */
 540         if (!niduuid)
 541                 GOTO(out, rc = -ENOMEM);
 542
 543         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 544                 sprintf(ptr, "_%x", i);
 545                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 546                              niduuid, NULL, NULL, NULL);
 547                 if (rc)
 548                         CERROR("del MDC UUID %s failed: rc = %d\n",
 549                                niduuid, rc);
 550         }
 551 out:
 552         if (niduuid)
 553                 OBD_FREE(niduuid, len);
 554
 555         /* class_import_put will get rid of the additional connections */
 556         mutex_unlock(&mgc_start_lock);
 557         RETURN(rc);
 558 }
 559
 560 /***************** lustre superblock **************/
 561
 562 static struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
 563 {
 564         struct lustre_sb_info *lsi;
 565         ENTRY;
 566
 567         OBD_ALLOC_PTR(lsi);
 568         if (!lsi)
 569                 RETURN(NULL);
 570         OBD_ALLOC_PTR(lsi->lsi_lmd);
 571         if (!lsi->lsi_lmd) {
 572                 OBD_FREE_PTR(lsi);
 573                 RETURN(NULL);
 574         }
 575
 576         lsi->lsi_lmd->lmd_exclude_count = 0;
 577         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
 578         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
 579         s2lsi_nocast(sb) = lsi;
 580         /* we take 1 extra ref for our setup */
 581         atomic_set(&lsi->lsi_mounts, 1);
 582
 583         /* Default umount style */
 584         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
 585         INIT_LIST_HEAD(&lsi->lsi_lwp_list);
 586         spin_lock_init(&lsi->lsi_lwp_lock);
 587
 588         RETURN(lsi);
 589 }
 590
 591 static int lustre_free_lsi(struct super_block *sb)
 592 {
 593         struct lustre_sb_info *lsi = s2lsi(sb);
 594         ENTRY;
 595
 596         LASSERT(lsi != NULL);
 597         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
 598
 599         /* someone didn't call server_put_mount. */
 600         LASSERT(atomic_read(&lsi->lsi_mounts) == 0);
 601
 602         if (lsi->lsi_lmd != NULL) {
 603                 if (lsi->lsi_lmd->lmd_dev != NULL)
 604                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
 605                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
 606                 if (lsi->lsi_lmd->lmd_profile != NULL)
 607                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
 608                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
 609                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
 610                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
 611                                  strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
 612                 if (lsi->lsi_lmd->lmd_opts != NULL)
 613                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
 614                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
 615                 if (lsi->lsi_lmd->lmd_exclude_count)
 616                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
 617                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
 618                                  lsi->lsi_lmd->lmd_exclude_count);
 619                 if (lsi->lsi_lmd->lmd_mgs != NULL)
 620                         OBD_FREE(lsi->lsi_lmd->lmd_mgs,
 621                                  strlen(lsi->lsi_lmd->lmd_mgs) + 1);
 622                 if (lsi->lsi_lmd->lmd_osd_type != NULL)
 623                         OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
 624                                  strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
 625                 if (lsi->lsi_lmd->lmd_params != NULL)
 626                         OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
 627
 628                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
 629         }
 630
 631         LASSERT(lsi->lsi_llsbi == NULL);
 632         OBD_FREE(lsi, sizeof(*lsi));
 633         s2lsi_nocast(sb) = NULL;
 634
 635         RETURN(0);
 636 }
 637
 638 /* The lsi has one reference for every server that is using the disk -
 639    e.g. MDT, MGS, and potentially MGC */
 640 int lustre_put_lsi(struct super_block *sb)
 641 {
 642         struct lustre_sb_info *lsi = s2lsi(sb);
 643         ENTRY;
 644
 645         LASSERT(lsi != NULL);
 646
 647         CDEBUG(D_MOUNT, "put %p %d\n", sb, atomic_read(&lsi->lsi_mounts));
 648         if (atomic_dec_and_test(&lsi->lsi_mounts)) {
 649                 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
 650                         lu_device_put(&lsi->lsi_dt_dev->dd_lu_dev);
 651                         lsi->lsi_osd_exp->exp_obd->obd_lvfs_ctxt.dt = NULL;
 652                         lsi->lsi_dt_dev = NULL;
 653                         obd_disconnect(lsi->lsi_osd_exp);
 654                         /* wait till OSD is gone */
 655                         obd_zombie_barrier();
 656                 }
 657                 lustre_free_lsi(sb);
 658                 RETURN(1);
 659         }
 660         RETURN(0);
 661 }
 662
 663 /*** SERVER NAME ***
 664  * <FSNAME><SEPERATOR><TYPE><INDEX>
 665  * FSNAME is between 1 and 8 characters (inclusive).
 666  *      Excluded characters are '/' and ':'
 667  * SEPERATOR is either ':' or '-'
 668  * TYPE: "OST", "MDT", etc.
 669  * INDEX: Hex representation of the index
 670  */
 671
 672 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
 673  * @param [in] svname server name including type and index
 674  * @param [out] fsname Buffer to copy filesystem name prefix into.
 675  *  Must have at least 'strlen(fsname) + 1' chars.
 676  * @param [out] endptr if endptr isn't NULL it is set to end of fsname
 677  * rc < 0  on error
 678  */
 679 int server_name2fsname(const char *svname, char *fsname, const char **endptr)
 680 {
 681         const char *dash;
 682
 683         dash = svname + strnlen(svname, 8); /* max fsname length is 8 */
 684         for (; dash > svname && *dash != '-' && *dash != ':'; dash--)
 685                 ;
 686         if (dash == svname)
 687                 return -EINVAL;
 688
 689         if (fsname != NULL) {
 690                 strncpy(fsname, svname, dash - svname);
 691                 fsname[dash - svname] = '\0';
 692         }
 693
 694         if (endptr != NULL)
 695                 *endptr = dash;
 696
 697         return 0;
 698 }
 699 EXPORT_SYMBOL(server_name2fsname);
 700
 701 /**
 702  * Get service name (svname) from string
 703  * rc < 0 on error
 704  * if endptr isn't NULL it is set to end of fsname *
 705  */
 706 int server_name2svname(const char *label, char *svname, const char **endptr,
 707                        size_t svsize)
 708 {
 709         int rc;
 710         const char *dash;
 711
 712         /* We use server_name2fsname() just for parsing */
 713         rc = server_name2fsname(label, NULL, &dash);
 714         if (rc != 0)
 715                 return rc;
 716
 717         if (endptr != NULL)
 718                 *endptr = dash;
 719
 720         if (strlcpy(svname, dash + 1, svsize) >= svsize)
 721                 return -E2BIG;
 722
 723         return 0;
 724 }
 725 EXPORT_SYMBOL(server_name2svname);
 726
 727 /**
 728  * check server name is OST.
 729  **/
 730 int server_name_is_ost(const char *svname)
 731 {
 732         const char *dash;
 733         int rc;
 734
 735         /* We use server_name2fsname() just for parsing */
 736         rc = server_name2fsname(svname, NULL, &dash);
 737         if (rc != 0)
 738                 return rc;
 739
 740         dash++;
 741
 742         if (strncmp(dash, "OST", 3) == 0)
 743                 return 1;
 744         return 0;
 745 }
 746 EXPORT_SYMBOL(server_name_is_ost);
 747
 748 /**
 749  * Get the index from the target name MDTXXXX/OSTXXXX
 750  * rc = server type, or rc < 0  on error
 751  **/
 752 int target_name2index(const char *tgtname, __u32 *idx, const char **endptr)
 753 {
 754         const char *dash = tgtname;
 755         unsigned long index;
 756         int rc;
 757
 758         if (strncmp(dash, "MDT", 3) == 0)
 759                 rc = LDD_F_SV_TYPE_MDT;
 760         else if (strncmp(dash, "OST", 3) == 0)
 761                 rc = LDD_F_SV_TYPE_OST;
 762         else
 763                 return -EINVAL;
 764
 765         dash += 3;
 766
 767         if (strncmp(dash, "all", 3) == 0) {
 768                 if (endptr != NULL)
 769                         *endptr = dash + 3;
 770                 return rc | LDD_F_SV_ALL;
 771         }
 772
 773         index = simple_strtoul(dash, (char **)endptr, 16);
 774         if (idx != NULL)
 775                 *idx = index;
 776         return rc;
 777 }
 778 EXPORT_SYMBOL(target_name2index);
 779
 780 /* Get the index from the obd name.
 781    rc = server type, or
 782    rc < 0  on error
 783    if endptr isn't NULL it is set to end of name */
 784 int server_name2index(const char *svname, __u32 *idx, const char **endptr)
 785 {
 786         const char *dash;
 787         int rc;
 788
 789         /* We use server_name2fsname() just for parsing */
 790         rc = server_name2fsname(svname, NULL, &dash);
 791         if (rc != 0)
 792                 return rc;
 793
 794         dash++;
 795         rc = target_name2index(dash, idx, endptr);
 796         if (rc < 0)
 797                 return rc;
 798
 799         /* Account for -mdc after index that is possible when specifying mdt */
 800         if (endptr != NULL && strncmp(LUSTRE_MDC_NAME, *endptr + 1,
 801                                       sizeof(LUSTRE_MDC_NAME)-1) == 0)
 802                 *endptr += sizeof(LUSTRE_MDC_NAME);
 803
 804         return rc;
 805 }
 806 EXPORT_SYMBOL(server_name2index);
 807
 808 /*************** mount common betweeen server and client ***************/
 809
 810 /* Common umount */
 811 int lustre_common_put_super(struct super_block *sb)
 812 {
 813         int rc;
 814         ENTRY;
 815
 816         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
 817
 818         /* Drop a ref to the MGC */
 819         rc = lustre_stop_mgc(sb);
 820         if (rc && (rc != -ENOENT)) {
 821                 if (rc != -EBUSY) {
 822                         CERROR("Can't stop MGC: %d\n", rc);
 823                         RETURN(rc);
 824                 }
 825                 /* BUSY just means that there's some other obd that
 826                    needs the mgc.  Let him clean it up. */
 827                 CDEBUG(D_MOUNT, "MGC still in use\n");
 828         }
 829         /* Drop a ref to the mounted disk */
 830         lustre_put_lsi(sb);
 831
 832         RETURN(rc);
 833 }
 834 EXPORT_SYMBOL(lustre_common_put_super);
 835
 836 static void lmd_print(struct lustre_mount_data *lmd)
 837 {
 838         int i;
 839
 840         PRINT_CMD(D_MOUNT, "  mount data:\n");
 841         if (lmd_is_client(lmd))
 842                 PRINT_CMD(D_MOUNT, "profile: %s\n", lmd->lmd_profile);
 843         PRINT_CMD(D_MOUNT, "device:  %s\n", lmd->lmd_dev);
 844         PRINT_CMD(D_MOUNT, "flags:   %x\n", lmd->lmd_flags);
 845
 846         if (lmd->lmd_opts)
 847                 PRINT_CMD(D_MOUNT, "options: %s\n", lmd->lmd_opts);
 848
 849         if (lmd->lmd_recovery_time_soft)
 850                 PRINT_CMD(D_MOUNT, "recovery time soft: %d\n",
 851                           lmd->lmd_recovery_time_soft);
 852
 853         if (lmd->lmd_recovery_time_hard)
 854                 PRINT_CMD(D_MOUNT, "recovery time hard: %d\n",
 855                           lmd->lmd_recovery_time_hard);
 856
 857         for (i = 0; i < lmd->lmd_exclude_count; i++) {
 858                 PRINT_CMD(D_MOUNT, "exclude %d:  OST%04x\n", i,
 859                           lmd->lmd_exclude[i]);
 860         }
 861 }
 862
 863 /* Is this server on the exclusion list */
 864 int lustre_check_exclusion(struct super_block *sb, char *svname)
 865 {
 866         struct lustre_sb_info *lsi = s2lsi(sb);
 867         struct lustre_mount_data *lmd = lsi->lsi_lmd;
 868         __u32 index;
 869         int i, rc;
 870         ENTRY;
 871
 872         rc = server_name2index(svname, &index, NULL);
 873         if (rc != LDD_F_SV_TYPE_OST)
 874                 /* Only exclude OSTs */
 875                 RETURN(0);
 876
 877         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
 878                index, lmd->lmd_exclude_count, lmd->lmd_dev);
 879
 880         for(i = 0; i < lmd->lmd_exclude_count; i++) {
 881                 if (index == lmd->lmd_exclude[i]) {
 882                         CWARN("Excluding %s (on exclusion list)\n", svname);
 883                         RETURN(1);
 884                 }
 885         }
 886         RETURN(0);
 887 }
 888
 889 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
 890 static int lmd_make_exclusion(struct lustre_mount_data *lmd, const char *ptr)
 891 {
 892         const char *s1 = ptr, *s2;
 893         __u32 *exclude_list;
 894         __u32 index = 0;
 895         int rc = 0, devmax;
 896         ENTRY;
 897
 898         /* The shortest an ost name can be is 8 chars: -OST0000.
 899            We don't actually know the fsname at this time, so in fact
 900            a user could specify any fsname. */
 901         devmax = strlen(ptr) / 8 + 1;
 902
 903         /* temp storage until we figure out how many we have */
 904         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
 905         if (!exclude_list)
 906                 RETURN(-ENOMEM);
 907
 908         /* we enter this fn pointing at the '=' */
 909         while (*s1 && *s1 != ' ' && *s1 != ',') {
 910                 s1++;
 911                 rc = server_name2index(s1, &index, &s2);
 912                 if (rc < 0) {
 913                         CERROR("Can't parse server name '%s': rc = %d\n",
 914                                s1, rc);
 915                         break;
 916                 }
 917                 if (rc == LDD_F_SV_TYPE_OST)
 918                         exclude_list[lmd->lmd_exclude_count++] = index;
 919                 else
 920                         CDEBUG(D_MOUNT, "ignoring exclude %.*s: type = %#x\n",
 921                                (uint)(s2-s1), s1, rc);
 922                 s1 = s2;
 923                 /* now we are pointing at ':' (next exclude)
 924                    or ',' (end of excludes) */
 925                 if (lmd->lmd_exclude_count >= devmax)
 926                         break;
 927         }
 928         if (rc >= 0) /* non-err */
 929                 rc = 0;
 930
 931         if (lmd->lmd_exclude_count) {
 932                 /* permanent, freed in lustre_free_lsi */
 933                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
 934                           lmd->lmd_exclude_count);
 935                 if (lmd->lmd_exclude) {
 936                         memcpy(lmd->lmd_exclude, exclude_list,
 937                                sizeof(index) * lmd->lmd_exclude_count);
 938                 } else {
 939                         rc = -ENOMEM;
 940                         lmd->lmd_exclude_count = 0;
 941                 }
 942         }
 943         OBD_FREE(exclude_list, sizeof(index) * devmax);
 944         RETURN(rc);
 945 }
 946
 947 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
 948 {
 949         char   *tail;
 950         int     length;
 951
 952         if (lmd->lmd_mgssec != NULL) {
 953                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
 954                 lmd->lmd_mgssec = NULL;
 955         }
 956
 957         tail = strchr(ptr, ',');
 958         if (tail == NULL)
 959                 length = strlen(ptr);
 960         else
 961                 length = tail - ptr;
 962
 963         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
 964         if (lmd->lmd_mgssec == NULL)
 965                 return -ENOMEM;
 966
 967         memcpy(lmd->lmd_mgssec, ptr, length);
 968         lmd->lmd_mgssec[length] = '\0';
 969         return 0;
 970 }
 971
 972 static int lmd_parse_string(char **handle, char *ptr)
 973 {
 974         char   *tail;
 975         int     length;
 976
 977         if ((handle == NULL) || (ptr == NULL))
 978                 return -EINVAL;
 979
 980         if (*handle != NULL) {
 981                 OBD_FREE(*handle, strlen(*handle) + 1);
 982                 *handle = NULL;
 983         }
 984
 985         tail = strchr(ptr, ',');
 986         if (tail == NULL)
 987                 length = strlen(ptr);
 988         else
 989                 length = tail - ptr;
 990
 991         OBD_ALLOC(*handle, length + 1);
 992         if (*handle == NULL)
 993                 return -ENOMEM;
 994
 995         memcpy(*handle, ptr, length);
 996         (*handle)[length] = '\0';
 997
 998         return 0;
 999 }
1000
1001 /* Collect multiple values for mgsnid specifiers */
1002 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
1003 {
1004         lnet_nid_t nid;
1005         char *tail = *ptr;
1006         char *mgsnid;
1007         int   length;
1008         int   oldlen = 0;
1009
1010         /* Find end of nidlist */
1011         while (class_parse_nid_quiet(tail, &nid, &tail) == 0) {}
1012         length = tail - *ptr;
1013         if (length == 0) {
1014                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
1015                 return -EINVAL;
1016         }
1017
1018         if (lmd->lmd_mgs != NULL)
1019                 oldlen = strlen(lmd->lmd_mgs) + 1;
1020
1021         OBD_ALLOC(mgsnid, oldlen + length + 1);
1022         if (mgsnid == NULL)
1023                 return -ENOMEM;
1024
1025         if (lmd->lmd_mgs != NULL) {
1026                 /* Multiple mgsnid= are taken to mean failover locations */
1027                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
1028                 mgsnid[oldlen - 1] = ':';
1029                 OBD_FREE(lmd->lmd_mgs, oldlen);
1030         }
1031         memcpy(mgsnid + oldlen, *ptr, length);
1032         mgsnid[oldlen + length] = '\0';
1033         lmd->lmd_mgs = mgsnid;
1034         *ptr = tail;
1035
1036         return 0;
1037 }
1038
1039 /** Parse mount line options
1040  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
1041  * dev is passed as device=uml1:/lustre by mount.lustre
1042  */
1043 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
1044 {
1045         char *s1, *s2, *s3, *devname = NULL;
1046         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
1047         int rc = 0;
1048         ENTRY;
1049
1050         LASSERT(lmd);
1051         if (!options) {
1052                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
1053                                    "/sbin/mount.lustre is installed.\n");
1054                 RETURN(-EINVAL);
1055         }
1056
1057         /* Options should be a string - try to detect old lmd data */
1058         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
1059                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
1060                                    "/sbin/mount.lustre.  Please install "
1061                                    "version %s\n", LUSTRE_VERSION_STRING);
1062                 RETURN(-EINVAL);
1063         }
1064         lmd->lmd_magic = LMD_MAGIC;
1065
1066         OBD_ALLOC(lmd->lmd_params, LMD_PARAMS_MAXLEN);
1067         if (lmd->lmd_params == NULL)
1068                 RETURN(-ENOMEM);
1069         lmd->lmd_params[0] = '\0';
1070
1071         /* Set default flags here */
1072
1073         s1 = options;
1074         while (*s1) {
1075                 int clear = 0;
1076                 int time_min = OBD_RECOVERY_TIME_MIN;
1077
1078                 /* Skip whitespace and extra commas */
1079                 while (*s1 == ' ' || *s1 == ',')
1080                         s1++;
1081                 s3 = s1;
1082
1083                 /* Client options are parsed in ll_options: eg. flock,
1084                    user_xattr, acl */
1085
1086                 /* Parse non-ldiskfs options here. Rather than modifying
1087                    ldiskfs, we just zero these out here */
1088                 if (strncmp(s1, "abort_recov", 11) == 0) {
1089                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
1090                         clear++;
1091                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
1092                         lmd->lmd_recovery_time_soft = max_t(int,
1093                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
1094                         clear++;
1095                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
1096                         lmd->lmd_recovery_time_hard = max_t(int,
1097                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
1098                         clear++;
1099                 } else if (strncmp(s1, "noir", 4) == 0) {
1100                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
1101                         clear++;
1102                 } else if (strncmp(s1, "nosvc", 5) == 0) {
1103                         lmd->lmd_flags |= LMD_FLG_NOSVC;
1104                         clear++;
1105                 } else if (strncmp(s1, "nomgs", 5) == 0) {
1106                         lmd->lmd_flags |= LMD_FLG_NOMGS;
1107                         clear++;
1108                 } else if (strncmp(s1, "noscrub", 7) == 0) {
1109                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
1110                         clear++;
1111                 } else if (strncmp(s1, PARAM_MGSNODE,
1112                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
1113                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
1114                         /* Assume the next mount opt is the first
1115                            invalid nid we get to. */
1116                         rc = lmd_parse_mgs(lmd, &s2);
1117                         if (rc)
1118                                 goto invalid;
1119                         s3 = s2;
1120                         clear++;
1121                 } else if (strncmp(s1, "writeconf", 9) == 0) {
1122                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
1123                         clear++;
1124                 } else if (strncmp(s1, "update", 6) == 0) {
1125                         lmd->lmd_flags |= LMD_FLG_UPDATE;
1126                         clear++;
1127                 } else if (strncmp(s1, "virgin", 6) == 0) {
1128                         lmd->lmd_flags |= LMD_FLG_VIRGIN;
1129                         clear++;
1130                 } else if (strncmp(s1, "noprimnode", 10) == 0) {
1131                         lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
1132                         clear++;
1133                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
1134                         rc = lmd_parse_mgssec(lmd, s1 + 7);
1135                         if (rc)
1136                                 goto invalid;
1137                         clear++;
1138                 /* ost exclusion list */
1139                 } else if (strncmp(s1, "exclude=", 8) == 0) {
1140                         rc = lmd_make_exclusion(lmd, s1 + 7);
1141                         if (rc)
1142                                 goto invalid;
1143                         clear++;
1144                 } else if (strncmp(s1, "mgs", 3) == 0) {
1145                         /* We are an MGS */
1146                         lmd->lmd_flags |= LMD_FLG_MGS;
1147                         clear++;
1148                 } else if (strncmp(s1, "svname=", 7) == 0) {
1149                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
1150                         if (rc)
1151                                 goto invalid;
1152                         clear++;
1153                 } else if (strncmp(s1, "param=", 6) == 0) {
1154                         size_t length, params_length;
1155                         char *tail = strchr(s1 + 6, ',');
1156                         if (tail == NULL) {
1157                                 length = strlen(s1);
1158                         } else {
1159                                 lnet_nid_t nid;
1160                                 char      *param_str = tail + 1;
1161                                 int        supplementary = 1;
1162
1163                                 while (class_parse_nid_quiet(param_str, &nid,
1164                                                              &param_str) == 0) {
1165                                         supplementary = 0;
1166                                 }
1167                                 length = param_str - s1 - supplementary;
1168                         }
1169                         length -= 6;
1170                         params_length = strlen(lmd->lmd_params);
1171                         if (params_length + length + 1 >= LMD_PARAMS_MAXLEN)
1172                                 RETURN(-E2BIG);
1173                         strncat(lmd->lmd_params, s1 + 6, length);
1174                         lmd->lmd_params[params_length + length] = '\0';
1175                         strlcat(lmd->lmd_params, " ", LMD_PARAMS_MAXLEN);
1176                         s3 = s1 + 6 + length;
1177                         clear++;
1178                 } else if (strncmp(s1, "osd=", 4) == 0) {
1179                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
1180                         if (rc)
1181                                 goto invalid;
1182                         clear++;
1183                 }
1184                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
1185                    end of the options. */
1186                 else if (strncmp(s1, "device=", 7) == 0) {
1187                         devname = s1 + 7;
1188                         /* terminate options right before device.  device
1189                            must be the last one. */
1190                         *s1 = '\0';
1191                         break;
1192                 }
1193
1194                 /* Find next opt */
1195                 s2 = strchr(s3, ',');
1196                 if (s2 == NULL) {
1197                         if (clear)
1198                                 *s1 = '\0';
1199                         break;
1200                 }
1201                 s2++;
1202                 if (clear)
1203                         memmove(s1, s2, strlen(s2) + 1);
1204                 else
1205                         s1 = s2;
1206         }
1207
1208         if (!devname) {
1209                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
1210                                    "(need mount option 'device=...')\n");
1211                 goto invalid;
1212         }
1213
1214         s1 = strstr(devname, ":/");
1215         if (s1) {
1216                 ++s1;
1217                 lmd->lmd_flags |= LMD_FLG_CLIENT;
1218                 /* Remove leading /s from fsname */
1219                 while (*++s1 == '/') ;
1220                 /* Freed in lustre_free_lsi */
1221                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
1222                 if (!lmd->lmd_profile)
1223                         RETURN(-ENOMEM);
1224                 sprintf(lmd->lmd_profile, "%s-client", s1);
1225         }
1226
1227         /* Freed in lustre_free_lsi */
1228         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
1229         if (!lmd->lmd_dev)
1230                 RETURN(-ENOMEM);
1231         strcpy(lmd->lmd_dev, devname);
1232
1233         /* Save mount options */
1234         s1 = options + strlen(options) - 1;
1235         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
1236                 *s1-- = 0;
1237         if (*options != 0) {
1238                 /* Freed in lustre_free_lsi */
1239                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
1240                 if (!lmd->lmd_opts)
1241                         RETURN(-ENOMEM);
1242                 strcpy(lmd->lmd_opts, options);
1243         }
1244
1245         lmd_print(lmd);
1246         lmd->lmd_magic = LMD_MAGIC;
1247
1248         RETURN(rc);
1249
1250 invalid:
1251         CERROR("Bad mount options %s\n", options);
1252         RETURN(-EINVAL);
1253 }
1254
1255 struct lustre_mount_data2 {
1256         void *lmd2_data;
1257         struct vfsmount *lmd2_mnt;
1258 };
1259
1260 /** This is the entry point for the mount call into Lustre.
1261  * This is called when a server or client is mounted,
1262  * and this is where we start setting things up.
1263  * @param data Mount options (e.g. -o flock,abort_recov)
1264  */
1265 static int lustre_fill_super(struct super_block *sb, void *data, int silent)
1266 {
1267         struct lustre_mount_data *lmd;
1268         struct lustre_mount_data2 *lmd2 = data;
1269         struct lustre_sb_info *lsi;
1270         int rc;
1271         ENTRY;
1272
1273         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
1274
1275         lsi = lustre_init_lsi(sb);
1276         if (!lsi)
1277                 RETURN(-ENOMEM);
1278         lmd = lsi->lsi_lmd;
1279
1280         /*
1281          * Disable lockdep during mount, because mount locking patterns are
1282          * `special'.
1283          */
1284         lockdep_off();
1285
1286         /*
1287          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
1288          */
1289         obd_zombie_barrier();
1290
1291         /* Figure out the lmd from the mount options */
1292         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
1293                 lustre_put_lsi(sb);
1294                 GOTO(out, rc = -EINVAL);
1295         }
1296
1297         if (lmd_is_client(lmd)) {
1298                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
1299                 if (client_fill_super == NULL)
1300                         request_module("lustre");
1301                 if (client_fill_super == NULL) {
1302                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
1303                                            "client mount! Is the 'lustre' "
1304                                            "module loaded?\n");
1305                         lustre_put_lsi(sb);
1306                         rc = -ENODEV;
1307                 } else {
1308                         rc = lustre_start_mgc(sb);
1309                         if (rc) {
1310                                 lustre_put_lsi(sb);
1311                                 GOTO(out, rc);
1312                         }
1313                         /* Connect and start */
1314                         /* (should always be ll_fill_super) */
1315                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
1316                         /* c_f_s will call lustre_common_put_super on failure */
1317                 }
1318         } else {
1319 #ifdef HAVE_SERVER_SUPPORT
1320                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
1321                 rc = server_fill_super(sb);
1322                 /* s_f_s calls lustre_start_mgc after the mount because we need
1323                    the MGS nids which are stored on disk.  Plus, we may
1324                    need to start the MGS first. */
1325                 /* s_f_s will call server_put_super on failure */
1326 #else
1327                 CERROR("This is client-side-only module, "
1328                        "cannot handle server mount.\n");
1329                 rc = -EINVAL;
1330 #endif
1331         }
1332
1333         /* If error happens in fill_super() call, @lsi will be killed there.
1334          * This is why we do not put it here. */
1335         GOTO(out, rc);
1336 out:
1337         if (rc) {
1338                 CERROR("Unable to mount %s (%d)\n",
1339                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
1340         } else {
1341                 CDEBUG(D_SUPER, "Mount %s complete\n",
1342                        lmd->lmd_dev);
1343         }
1344         lockdep_on();
1345         return rc;
1346 }
1347
1348
1349 /* We can't call ll_fill_super by name because it lives in a module that
1350    must be loaded after this one. */
1351 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
1352                                                   struct vfsmount *mnt))
1353 {
1354         client_fill_super = cfs;
1355 }
1356 EXPORT_SYMBOL(lustre_register_client_fill_super);
1357
1358 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
1359 {
1360         kill_super_cb = cfs;
1361 }
1362 EXPORT_SYMBOL(lustre_register_kill_super_cb);
1363
1364 /***************** FS registration ******************/
1365 #ifdef HAVE_FSTYPE_MOUNT
1366 static struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
1367                                    const char *devname, void *data)
1368 {
1369         struct lustre_mount_data2 lmd2 = { data, NULL };
1370
1371         return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
1372 }
1373 #else
1374 static int lustre_get_sb(struct file_system_type *fs_type, int flags,
1375                          const char *devname, void *data, struct vfsmount *mnt)
1376 {
1377         struct lustre_mount_data2 lmd2 = { data, mnt };
1378
1379         return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
1380 }
1381 #endif
1382
1383 static void lustre_kill_super(struct super_block *sb)
1384 {
1385         struct lustre_sb_info *lsi = s2lsi(sb);
1386
1387         if (kill_super_cb && lsi && !IS_SERVER(lsi))
1388                 (*kill_super_cb)(sb);
1389
1390         kill_anon_super(sb);
1391 }
1392
1393 /** Register the "lustre" fs type
1394  */
1395 static struct file_system_type lustre_fs_type = {
1396         .owner        = THIS_MODULE,
1397         .name         = "lustre",
1398 #ifdef HAVE_FSTYPE_MOUNT
1399         .mount        = lustre_mount,
1400 #else
1401         .get_sb       = lustre_get_sb,
1402 #endif
1403         .kill_sb      = lustre_kill_super,
1404         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
1405                         FS_HAS_FIEMAP | FS_RENAME_DOES_D_MOVE,
1406 };
1407 MODULE_ALIAS_FS("lustre");
1408
1409 int lustre_register_fs(void)
1410 {
1411         return register_filesystem(&lustre_fs_type);
1412 }
1413
1414 int lustre_unregister_fs(void)
1415 {
1416         return unregister_filesystem(&lustre_fs_type);
1417 }