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