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