kernel/drivers/staging/lustre/lustre/obdclass/obd_mount.c

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