lustre/obdclass/obd_mount.c

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