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