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/server 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 #define PRINT_MASK D_SUPER|D_CONFIG
  48
  49 #include <obd.h>
  50 #include <lvfs.h>
  51 #include <lustre_fsfilt.h>
  52 #include <obd_class.h>
  53 #include <lustre/lustre_user.h>
  54 #include <linux/version.h>
  55 #include <lustre_log.h>
  56 #include <lustre_disk.h>
  57 #include <lustre_param.h>
  58 #ifdef HAVE_KERNEL_LOCKED
  59 #include <linux/smp_lock.h>
  60 #endif
  61
  62 static int (*client_fill_super)(struct super_block *sb,
  63                                 struct vfsmount *mnt) = NULL;
  64 static void (*kill_super_cb)(struct super_block *sb) = NULL;
  65
  66 /*********** mount lookup *********/
  67
  68 DEFINE_MUTEX(lustre_mount_info_lock);
  69 static CFS_LIST_HEAD(server_mount_info_list);
  70
  71 static struct lustre_mount_info *server_find_mount(const char *name)
  72 {
  73         cfs_list_t *tmp;
  74         struct lustre_mount_info *lmi;
  75         ENTRY;
  76
  77         cfs_list_for_each(tmp, &server_mount_info_list) {
  78                 lmi = cfs_list_entry(tmp, struct lustre_mount_info,
  79                                      lmi_list_chain);
  80                 if (strcmp(name, lmi->lmi_name) == 0)
  81                         RETURN(lmi);
  82         }
  83         RETURN(NULL);
  84 }
  85
  86 /* we must register an obd for a mount before we call the setup routine.
  87    *_setup will call lustre_get_mount to get the mnt struct
  88    by obd_name, since we can't pass the pointer to setup. */
  89 static int server_register_mount(const char *name, struct super_block *sb,
  90                           struct vfsmount *mnt)
  91 {
  92         struct lustre_mount_info *lmi;
  93         char *name_cp;
  94         ENTRY;
  95
  96         LASSERT(sb);
  97
  98         OBD_ALLOC(lmi, sizeof(*lmi));
  99         if (!lmi)
 100                 RETURN(-ENOMEM);
 101         OBD_ALLOC(name_cp, strlen(name) + 1);
 102         if (!name_cp) {
 103                 OBD_FREE(lmi, sizeof(*lmi));
 104                 RETURN(-ENOMEM);
 105         }
 106         strcpy(name_cp, name);
 107
 108         mutex_lock(&lustre_mount_info_lock);
 109
 110         if (server_find_mount(name)) {
 111                 mutex_unlock(&lustre_mount_info_lock);
 112                 OBD_FREE(lmi, sizeof(*lmi));
 113                 OBD_FREE(name_cp, strlen(name) + 1);
 114                 CERROR("Already registered %s\n", name);
 115                 RETURN(-EEXIST);
 116         }
 117         lmi->lmi_name = name_cp;
 118         lmi->lmi_sb = sb;
 119         lmi->lmi_mnt = mnt;
 120         cfs_list_add(&lmi->lmi_list_chain, &server_mount_info_list);
 121
 122         mutex_unlock(&lustre_mount_info_lock);
 123
 124         CDEBUG(D_MOUNT, "reg_mnt %p from %s\n", lmi->lmi_mnt, name);
 125
 126         RETURN(0);
 127 }
 128
 129 /* when an obd no longer needs a mount */
 130 static int server_deregister_mount(const char *name)
 131 {
 132         struct lustre_mount_info *lmi;
 133         ENTRY;
 134
 135         mutex_lock(&lustre_mount_info_lock);
 136         lmi = server_find_mount(name);
 137         if (!lmi) {
 138                 mutex_unlock(&lustre_mount_info_lock);
 139                 CERROR("%s not registered\n", name);
 140                 RETURN(-ENOENT);
 141         }
 142
 143         CDEBUG(D_MOUNT, "dereg_mnt %p from %s\n", lmi->lmi_mnt, name);
 144
 145         OBD_FREE(lmi->lmi_name, strlen(lmi->lmi_name) + 1);
 146         cfs_list_del(&lmi->lmi_list_chain);
 147         OBD_FREE(lmi, sizeof(*lmi));
 148         mutex_unlock(&lustre_mount_info_lock);
 149
 150         RETURN(0);
 151 }
 152
 153 /* obd's look up a registered mount using their obdname. This is just
 154    for initial obd setup to find the mount struct.  It should not be
 155    called every time you want to mntget. */
 156 struct lustre_mount_info *server_get_mount(const char *name)
 157 {
 158         struct lustre_mount_info *lmi;
 159         struct lustre_sb_info *lsi;
 160         ENTRY;
 161
 162         mutex_lock(&lustre_mount_info_lock);
 163         lmi = server_find_mount(name);
 164         mutex_unlock(&lustre_mount_info_lock);
 165         if (!lmi) {
 166                 CERROR("Can't find mount for %s\n", name);
 167                 RETURN(NULL);
 168         }
 169         lsi = s2lsi(lmi->lmi_sb);
 170
 171         cfs_atomic_inc(&lsi->lsi_mounts);
 172
 173         CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d\n", lmi->lmi_mnt,
 174                name, cfs_atomic_read(&lsi->lsi_mounts));
 175
 176         RETURN(lmi);
 177 }
 178 EXPORT_SYMBOL(server_get_mount);
 179
 180 /*
 181  * Used by mdt to get mount_info from obdname.
 182  * There are no blocking when using the mount_info.
 183  * Do not use server_get_mount for this purpose.
 184  */
 185 struct lustre_mount_info *server_get_mount_2(const char *name)
 186 {
 187         struct lustre_mount_info *lmi;
 188         ENTRY;
 189
 190         mutex_lock(&lustre_mount_info_lock);
 191         lmi = server_find_mount(name);
 192         mutex_unlock(&lustre_mount_info_lock);
 193         if (!lmi)
 194                 CERROR("Can't find mount for %s\n", name);
 195
 196         RETURN(lmi);
 197 }
 198 EXPORT_SYMBOL(server_get_mount_2);
 199
 200 static int lustre_put_lsi(struct super_block *sb);
 201
 202 /* to be called from obd_cleanup methods */
 203 int server_put_mount(const char *name, struct vfsmount *mnt)
 204 {
 205         struct lustre_mount_info *lmi;
 206         struct lustre_sb_info *lsi;
 207         ENTRY;
 208
 209         mutex_lock(&lustre_mount_info_lock);
 210         lmi = server_find_mount(name);
 211         mutex_unlock(&lustre_mount_info_lock);
 212         if (!lmi) {
 213                 CERROR("Can't find mount for %s\n", name);
 214                 RETURN(-ENOENT);
 215         }
 216         lsi = s2lsi(lmi->lmi_sb);
 217
 218         CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d\n",
 219                lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts));
 220
 221         if (lustre_put_lsi(lmi->lmi_sb))
 222                 CDEBUG(D_MOUNT, "Last put of mnt %p from %s\n",
 223                        lmi->lmi_mnt, name);
 224
 225         /* this obd should never need the mount again */
 226         server_deregister_mount(name);
 227
 228         RETURN(0);
 229 }
 230 EXPORT_SYMBOL(server_put_mount);
 231
 232 /* Corresponding to server_get_mount_2 */
 233 int server_put_mount_2(const char *name, struct vfsmount *mnt)
 234 {
 235         ENTRY;
 236         RETURN(0);
 237 }
 238 EXPORT_SYMBOL(server_put_mount_2);
 239
 240 /**************** config llog ********************/
 241
 242 /** Get a config log from the MGS and process it.
 243  * This func is called for both clients and servers.
 244  * Continue to process new statements appended to the logs
 245  * (whenever the config lock is revoked) until lustre_end_log
 246  * is called.
 247  * @param sb The superblock is used by the MGC to write to the local copy of
 248  *   the config log
 249  * @param logname The name of the llog to replicate from the MGS
 250  * @param cfg Since the same mgc may be used to follow multiple config logs
 251  *   (e.g. ost1, ost2, client), the config_llog_instance keeps the state for
 252  *   this log, and is added to the mgc's list of logs to follow.
 253  */
 254 int lustre_process_log(struct super_block *sb, char *logname,
 255                      struct config_llog_instance *cfg)
 256 {
 257         struct lustre_cfg *lcfg;
 258         struct lustre_cfg_bufs *bufs;
 259         struct lustre_sb_info *lsi = s2lsi(sb);
 260         struct obd_device *mgc = lsi->lsi_mgc;
 261         int rc;
 262         ENTRY;
 263
 264         LASSERT(mgc);
 265         LASSERT(cfg);
 266
 267         OBD_ALLOC_PTR(bufs);
 268         if (bufs == NULL)
 269                 RETURN(-ENOMEM);
 270
 271         /* mgc_process_config */
 272         lustre_cfg_bufs_reset(bufs, mgc->obd_name);
 273         lustre_cfg_bufs_set_string(bufs, 1, logname);
 274         lustre_cfg_bufs_set(bufs, 2, cfg, sizeof(*cfg));
 275         lustre_cfg_bufs_set(bufs, 3, &sb, sizeof(sb));
 276         lcfg = lustre_cfg_new(LCFG_LOG_START, bufs);
 277         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 278         lustre_cfg_free(lcfg);
 279
 280         OBD_FREE_PTR(bufs);
 281
 282         if (rc == -EINVAL)
 283                 LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
 284                                    "failed from the MGS (%d).  Make sure this "
 285                                    "client and the MGS are running compatible "
 286                                    "versions of Lustre.\n",
 287                                    mgc->obd_name, logname, rc);
 288
 289         if (rc)
 290                 LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
 291                                    "failed (%d). This may be the result of "
 292                                    "communication errors between this node and "
 293                                    "the MGS, a bad configuration, or other "
 294                                    "errors. See the syslog for more "
 295                                    "information.\n", mgc->obd_name, logname,
 296                                    rc);
 297
 298         /* class_obd_list(); */
 299         RETURN(rc);
 300 }
 301 EXPORT_SYMBOL(lustre_process_log);
 302
 303 /* Stop watching this config log for updates */
 304 int lustre_end_log(struct super_block *sb, char *logname,
 305                        struct config_llog_instance *cfg)
 306 {
 307         struct lustre_cfg *lcfg;
 308         struct lustre_cfg_bufs bufs;
 309         struct lustre_sb_info *lsi = s2lsi(sb);
 310         struct obd_device *mgc = lsi->lsi_mgc;
 311         int rc;
 312         ENTRY;
 313
 314         if (!mgc)
 315                 RETURN(-ENOENT);
 316
 317         /* mgc_process_config */
 318         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
 319         lustre_cfg_bufs_set_string(&bufs, 1, logname);
 320         if (cfg)
 321                 lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
 322         lcfg = lustre_cfg_new(LCFG_LOG_END, &bufs);
 323         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 324         lustre_cfg_free(lcfg);
 325         RETURN(rc);
 326 }
 327 EXPORT_SYMBOL(lustre_end_log);
 328
 329 /**************** obd start *******************/
 330
 331 /** lustre_cfg_bufs are a holdover from 1.4; we can still set these up from
 332  * lctl (and do for echo cli/srv.
 333  */
 334 int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
 335             char *s1, char *s2, char *s3, char *s4)
 336 {
 337         struct lustre_cfg_bufs bufs;
 338         struct lustre_cfg    * lcfg = NULL;
 339         int rc;
 340
 341         CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
 342                cmd, s1, s2, s3, s4);
 343
 344         lustre_cfg_bufs_reset(&bufs, cfgname);
 345         if (s1)
 346                 lustre_cfg_bufs_set_string(&bufs, 1, s1);
 347         if (s2)
 348                 lustre_cfg_bufs_set_string(&bufs, 2, s2);
 349         if (s3)
 350                 lustre_cfg_bufs_set_string(&bufs, 3, s3);
 351         if (s4)
 352                 lustre_cfg_bufs_set_string(&bufs, 4, s4);
 353
 354         lcfg = lustre_cfg_new(cmd, &bufs);
 355         lcfg->lcfg_nid = nid;
 356         rc = class_process_config(lcfg);
 357         lustre_cfg_free(lcfg);
 358         return(rc);
 359 }
 360 EXPORT_SYMBOL(do_lcfg);
 361
 362 /** Call class_attach and class_setup.  These methods in turn call
 363  * obd type-specific methods.
 364  */
 365 static int lustre_start_simple(char *obdname, char *type, char *uuid,
 366                                char *s1, char *s2, char *s3, char *s4)
 367 {
 368         int rc;
 369         CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
 370
 371         rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, 0, 0);
 372         if (rc) {
 373                 CERROR("%s attach error %d\n", obdname, rc);
 374                 return(rc);
 375         }
 376         rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, s3, s4);
 377         if (rc) {
 378                 CERROR("%s setup error %d\n", obdname, rc);
 379                 do_lcfg(obdname, 0, LCFG_DETACH, 0, 0, 0, 0);
 380         }
 381         return rc;
 382 }
 383
 384 /* Set up a MGS to serve startup logs */
 385 static int server_start_mgs(struct super_block *sb)
 386 {
 387         struct lustre_sb_info    *lsi = s2lsi(sb);
 388         struct vfsmount          *mnt = lsi->lsi_srv_mnt;
 389         struct lustre_mount_info *lmi;
 390         int    rc = 0;
 391         ENTRY;
 392
 393         /* It is impossible to have more than 1 MGS per node, since
 394            MGC wouldn't know which to connect to */
 395         lmi = server_find_mount(LUSTRE_MGS_OBDNAME);
 396         if (lmi) {
 397                 lsi = s2lsi(lmi->lmi_sb);
 398                 LCONSOLE_ERROR_MSG(0x15d, "The MGS service was already started"
 399                                    " from server\n");
 400                 RETURN(-EALREADY);
 401         }
 402
 403         CDEBUG(D_CONFIG, "Start MGS service %s\n", LUSTRE_MGS_OBDNAME);
 404
 405         rc = server_register_mount(LUSTRE_MGS_OBDNAME, sb, mnt);
 406
 407         if (!rc) {
 408                 rc = lustre_start_simple(LUSTRE_MGS_OBDNAME, LUSTRE_MGS_NAME,
 409                                          LUSTRE_MGS_OBDNAME, 0, 0,
 410                                          lsi->lsi_osd_obdname, 0);
 411                 /* Do NOT call server_deregister_mount() here. This leads to
 412                  * inability cleanup cleanly and free lsi and other stuff when
 413                  * mgs calls server_put_mount() in error handling case. -umka */
 414         }
 415
 416         if (rc)
 417                 LCONSOLE_ERROR_MSG(0x15e, "Failed to start MGS '%s' (%d). "
 418                                    "Is the 'mgs' module loaded?\n",
 419                                    LUSTRE_MGS_OBDNAME, rc);
 420         RETURN(rc);
 421 }
 422
 423 static int server_stop_mgs(struct super_block *sb)
 424 {
 425         struct obd_device *obd;
 426         int rc;
 427         ENTRY;
 428
 429         CDEBUG(D_MOUNT, "Stop MGS service %s\n", LUSTRE_MGS_OBDNAME);
 430
 431         /* There better be only one MGS */
 432         obd = class_name2obd(LUSTRE_MGS_OBDNAME);
 433         if (!obd) {
 434                 CDEBUG(D_CONFIG, "mgs %s not running\n", LUSTRE_MGS_OBDNAME);
 435                 RETURN(-EALREADY);
 436         }
 437
 438         /* The MGS should always stop when we say so */
 439         obd->obd_force = 1;
 440         rc = class_manual_cleanup(obd);
 441         RETURN(rc);
 442 }
 443
 444 DEFINE_MUTEX(mgc_start_lock);
 445
 446 /** Set up a mgc obd to process startup logs
 447  *
 448  * \param sb [in] super block of the mgc obd
 449  *
 450  * \retval 0 success, otherwise error code
 451  */
 452 static int lustre_start_mgc(struct super_block *sb)
 453 {
 454         struct obd_connect_data *data = NULL;
 455         struct lustre_sb_info *lsi = s2lsi(sb);
 456         struct obd_device *obd;
 457         struct obd_export *exp;
 458         struct obd_uuid *uuid;
 459         class_uuid_t uuidc;
 460         lnet_nid_t nid;
 461         char *mgcname = NULL, *niduuid = NULL, *mgssec = NULL;
 462         char *ptr;
 463         int recov_bk;
 464         int rc = 0, i = 0, j, len;
 465         ENTRY;
 466
 467         LASSERT(lsi->lsi_lmd);
 468
 469         /* Find the first non-lo MGS nid for our MGC name */
 470         if (IS_SERVER(lsi)) {
 471                 /* mount -o mgsnode=nid */
 472                 ptr = lsi->lsi_lmd->lmd_mgs;
 473                 if (lsi->lsi_lmd->lmd_mgs &&
 474                     (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
 475                         i++;
 476                 } else if (IS_MGS(lsi)) {
 477                         lnet_process_id_t id;
 478                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 479                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 480                                         continue;
 481                                 nid = id.nid;
 482                                 i++;
 483                                 break;
 484                         }
 485                 }
 486         } else { /* client */
 487                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 488                 ptr = lsi->lsi_lmd->lmd_dev;
 489                 if (class_parse_nid(ptr, &nid, &ptr) == 0)
 490                         i++;
 491         }
 492         if (i == 0) {
 493                 CERROR("No valid MGS nids found.\n");
 494                 RETURN(-EINVAL);
 495         }
 496
 497         mutex_lock(&mgc_start_lock);
 498
 499         len = strlen(LUSTRE_MGC_OBDNAME) + strlen(libcfs_nid2str(nid)) + 1;
 500         OBD_ALLOC(mgcname, len);
 501         OBD_ALLOC(niduuid, len + 2);
 502         if (!mgcname || !niduuid)
 503                 GOTO(out_free, rc = -ENOMEM);
 504         sprintf(mgcname, "%s%s", LUSTRE_MGC_OBDNAME, libcfs_nid2str(nid));
 505
 506         mgssec = lsi->lsi_lmd->lmd_mgssec ? lsi->lsi_lmd->lmd_mgssec : "";
 507
 508         OBD_ALLOC_PTR(data);
 509         if (data == NULL)
 510                 GOTO(out_free, rc = -ENOMEM);
 511
 512         obd = class_name2obd(mgcname);
 513         if (obd && !obd->obd_stopping) {
 514                 rc = obd_set_info_async(NULL, obd->obd_self_export,
 515                                         strlen(KEY_MGSSEC), KEY_MGSSEC,
 516                                         strlen(mgssec), mgssec, NULL);
 517                 if (rc)
 518                         GOTO(out_free, rc);
 519
 520                 /* Re-using an existing MGC */
 521                 cfs_atomic_inc(&obd->u.cli.cl_mgc_refcount);
 522
 523                 /* IR compatibility check, only for clients */
 524                 if (lmd_is_client(lsi->lsi_lmd)) {
 525                         int has_ir;
 526                         int vallen = sizeof(*data);
 527                         __u32 *flags = &lsi->lsi_lmd->lmd_flags;
 528
 529                         rc = obd_get_info(NULL, obd->obd_self_export,
 530                                           strlen(KEY_CONN_DATA), KEY_CONN_DATA,
 531                                           &vallen, data, NULL);
 532                         LASSERT(rc == 0);
 533                         has_ir = OCD_HAS_FLAG(data, IMP_RECOV);
 534                         if (has_ir ^ !(*flags & LMD_FLG_NOIR)) {
 535                                 /* LMD_FLG_NOIR is for test purpose only */
 536                                 LCONSOLE_WARN(
 537                                     "Trying to mount a client with IR setting "
 538                                     "not compatible with current mgc. "
 539                                     "Force to use current mgc setting that is "
 540                                     "IR %s.\n",
 541                                     has_ir ? "enabled" : "disabled");
 542                                 if (has_ir)
 543                                         *flags &= ~LMD_FLG_NOIR;
 544                                 else
 545                                         *flags |= LMD_FLG_NOIR;
 546                         }
 547                 }
 548
 549                 recov_bk = 0;
 550                 /* If we are restarting the MGS, don't try to keep the MGC's
 551                    old connection, or registration will fail. */
 552                 if (IS_MGS(lsi)) {
 553                         CDEBUG(D_MOUNT, "New MGS with live MGC\n");
 554                         recov_bk = 1;
 555                 }
 556
 557                 /* Try all connections, but only once (again).
 558                    We don't want to block another target from starting
 559                    (using its local copy of the log), but we do want to connect
 560                    if at all possible. */
 561                 recov_bk++;
 562                 CDEBUG(D_MOUNT, "%s: Set MGC reconnect %d\n", mgcname,recov_bk);
 563                 rc = obd_set_info_async(NULL, obd->obd_self_export,
 564                                         sizeof(KEY_INIT_RECOV_BACKUP),
 565                                         KEY_INIT_RECOV_BACKUP,
 566                                         sizeof(recov_bk), &recov_bk, NULL);
 567                 GOTO(out, rc = 0);
 568         }
 569
 570         CDEBUG(D_MOUNT, "Start MGC '%s'\n", mgcname);
 571
 572         /* Add the primary nids for the MGS */
 573         i = 0;
 574         sprintf(niduuid, "%s_%x", mgcname, i);
 575         if (IS_SERVER(lsi)) {
 576                 ptr = lsi->lsi_lmd->lmd_mgs;
 577                 if (IS_MGS(lsi)) {
 578                         /* Use local nids (including LO) */
 579                         lnet_process_id_t id;
 580                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 581                                 rc = do_lcfg(mgcname, id.nid,
 582                                              LCFG_ADD_UUID, niduuid, 0,0,0);
 583                         }
 584                 } else {
 585                         /* Use mgsnode= nids */
 586                         /* mount -o mgsnode=nid */
 587                         if (lsi->lsi_lmd->lmd_mgs) {
 588                                 ptr = lsi->lsi_lmd->lmd_mgs;
 589                         } else if (class_find_param(ptr, PARAM_MGSNODE,
 590                                                     &ptr) != 0) {
 591                                 CERROR("No MGS nids given.\n");
 592                                 GOTO(out_free, rc = -EINVAL);
 593                         }
 594                         while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 595                                 rc = do_lcfg(mgcname, nid,
 596                                              LCFG_ADD_UUID, niduuid, 0,0,0);
 597                                 i++;
 598                         }
 599                 }
 600         } else { /* client */
 601                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 602                 ptr = lsi->lsi_lmd->lmd_dev;
 603                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 604                         rc = do_lcfg(mgcname, nid,
 605                                      LCFG_ADD_UUID, niduuid, 0,0,0);
 606                         i++;
 607                         /* Stop at the first failover nid */
 608                         if (*ptr == ':')
 609                                 break;
 610                 }
 611         }
 612         if (i == 0) {
 613                 CERROR("No valid MGS nids found.\n");
 614                 GOTO(out_free, rc = -EINVAL);
 615         }
 616         lsi->lsi_lmd->lmd_mgs_failnodes = 1;
 617
 618         /* Random uuid for MGC allows easier reconnects */
 619         OBD_ALLOC_PTR(uuid);
 620         ll_generate_random_uuid(uuidc);
 621         class_uuid_unparse(uuidc, uuid);
 622
 623         /* Start the MGC */
 624         rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
 625                                  (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
 626                                  niduuid, 0, 0);
 627         OBD_FREE_PTR(uuid);
 628         if (rc)
 629                 GOTO(out_free, rc);
 630
 631         /* Add any failover MGS nids */
 632         i = 1;
 633         while (ptr && ((*ptr == ':' ||
 634                class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0))) {
 635                 /* New failover node */
 636                 sprintf(niduuid, "%s_%x", mgcname, i);
 637                 j = 0;
 638                 while (class_parse_nid_quiet(ptr, &nid, &ptr) == 0) {
 639                         j++;
 640                         rc = do_lcfg(mgcname, nid,
 641                                      LCFG_ADD_UUID, niduuid, 0,0,0);
 642                         if (*ptr == ':')
 643                                 break;
 644                 }
 645                 if (j > 0) {
 646                         rc = do_lcfg(mgcname, 0, LCFG_ADD_CONN,
 647                                      niduuid, 0, 0, 0);
 648                         i++;
 649                 } else {
 650                         /* at ":/fsname" */
 651                         break;
 652                 }
 653         }
 654         lsi->lsi_lmd->lmd_mgs_failnodes = i;
 655
 656         obd = class_name2obd(mgcname);
 657         if (!obd) {
 658                 CERROR("Can't find mgcobd %s\n", mgcname);
 659                 GOTO(out_free, rc = -ENOTCONN);
 660         }
 661
 662         rc = obd_set_info_async(NULL, obd->obd_self_export,
 663                                 strlen(KEY_MGSSEC), KEY_MGSSEC,
 664                                 strlen(mgssec), mgssec, NULL);
 665         if (rc)
 666                 GOTO(out_free, rc);
 667
 668         /* Keep a refcount of servers/clients who started with "mount",
 669            so we know when we can get rid of the mgc. */
 670         cfs_atomic_set(&obd->u.cli.cl_mgc_refcount, 1);
 671
 672         /* Try all connections, but only once. */
 673         recov_bk = 1;
 674         rc = obd_set_info_async(NULL, obd->obd_self_export,
 675                                 sizeof(KEY_INIT_RECOV_BACKUP),
 676                                 KEY_INIT_RECOV_BACKUP,
 677                                 sizeof(recov_bk), &recov_bk, NULL);
 678         if (rc)
 679                 /* nonfatal */
 680                 CWARN("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
 681
 682         /* We connect to the MGS at setup, and don't disconnect until cleanup */
 683         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
 684                                   OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV |
 685                                   OBD_CONNECT_LVB_TYPE;
 686
 687 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 2, 50, 0)
 688         data->ocd_connect_flags |= OBD_CONNECT_MNE_SWAB;
 689 #else
 690 #warning "LU-1644: Remove old OBD_CONNECT_MNE_SWAB fixup and imp_need_mne_swab"
 691 #endif
 692
 693         if (lmd_is_client(lsi->lsi_lmd) &&
 694             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
 695                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
 696         data->ocd_version = LUSTRE_VERSION_CODE;
 697         rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
 698         if (rc) {
 699                 CERROR("connect failed %d\n", rc);
 700                 GOTO(out, rc);
 701         }
 702
 703         obd->u.cli.cl_mgc_mgsexp = exp;
 704
 705 out:
 706         /* Keep the mgc info in the sb. Note that many lsi's can point
 707            to the same mgc.*/
 708         lsi->lsi_mgc = obd;
 709 out_free:
 710         mutex_unlock(&mgc_start_lock);
 711
 712         if (data)
 713                 OBD_FREE_PTR(data);
 714         if (mgcname)
 715                 OBD_FREE(mgcname, len);
 716         if (niduuid)
 717                 OBD_FREE(niduuid, len + 2);
 718         RETURN(rc);
 719 }
 720
 721 static int lustre_stop_mgc(struct super_block *sb)
 722 {
 723         struct lustre_sb_info *lsi = s2lsi(sb);
 724         struct obd_device *obd;
 725         char *niduuid = 0, *ptr = 0;
 726         int i, rc = 0, len = 0;
 727         ENTRY;
 728
 729         if (!lsi)
 730                 RETURN(-ENOENT);
 731         obd = lsi->lsi_mgc;
 732         if (!obd)
 733                 RETURN(-ENOENT);
 734         lsi->lsi_mgc = NULL;
 735
 736         mutex_lock(&mgc_start_lock);
 737         LASSERT(cfs_atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
 738         if (!cfs_atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 739                 /* This is not fatal, every client that stops
 740                    will call in here. */
 741                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 742                        cfs_atomic_read(&obd->u.cli.cl_mgc_refcount));
 743                 GOTO(out, rc = -EBUSY);
 744         }
 745
 746         /* The MGC has no recoverable data in any case.
 747          * force shotdown set in umount_begin */
 748         obd->obd_no_recov = 1;
 749
 750         if (obd->u.cli.cl_mgc_mgsexp) {
 751                 /* An error is not fatal, if we are unable to send the
 752                    disconnect mgs ping evictor cleans up the export */
 753                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 754                 if (rc)
 755                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 756         }
 757
 758         /* Save the obdname for cleaning the nid uuids, which are
 759            obdname_XX */
 760         len = strlen(obd->obd_name) + 6;
 761         OBD_ALLOC(niduuid, len);
 762         if (niduuid) {
 763                 strcpy(niduuid, obd->obd_name);
 764                 ptr = niduuid + strlen(niduuid);
 765         }
 766
 767         rc = class_manual_cleanup(obd);
 768         if (rc)
 769                 GOTO(out, rc);
 770
 771         /* Clean the nid uuids */
 772         if (!niduuid)
 773                 GOTO(out, rc = -ENOMEM);
 774
 775         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 776                 sprintf(ptr, "_%x", i);
 777                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 778                              niduuid, 0, 0, 0);
 779                 if (rc)
 780                         CERROR("del MDC UUID %s failed: rc = %d\n",
 781                                niduuid, rc);
 782         }
 783 out:
 784         if (niduuid)
 785                 OBD_FREE(niduuid, len);
 786
 787         /* class_import_put will get rid of the additional connections */
 788         mutex_unlock(&mgc_start_lock);
 789         RETURN(rc);
 790 }
 791
 792 /* Since there's only one mgc per node, we have to change it's fs to get
 793    access to the right disk. */
 794 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
 795 {
 796         struct lustre_sb_info *lsi = s2lsi(sb);
 797         int rc;
 798         ENTRY;
 799
 800         CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
 801
 802         /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
 803         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 804                                 sizeof(KEY_SET_FS), KEY_SET_FS,
 805                                 sizeof(*sb), sb, NULL);
 806         if (rc) {
 807                 CERROR("can't set_fs %d\n", rc);
 808         }
 809
 810         RETURN(rc);
 811 }
 812
 813 static int server_mgc_clear_fs(struct obd_device *mgc)
 814 {
 815         int rc;
 816         ENTRY;
 817
 818         CDEBUG(D_MOUNT, "Unassign mgc disk\n");
 819
 820         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 821                                 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
 822                                 0, NULL, NULL);
 823         RETURN(rc);
 824 }
 825
 826 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
 827  * @param [in] svname server name including type and index
 828  * @param [out] fsname Buffer to copy filesystem name prefix into.
 829  *  Must have at least 'strlen(fsname) + 1' chars.
 830  * @param [out] endptr if endptr isn't NULL it is set to end of fsname
 831  * rc < 0  on error
 832  */
 833 int server_name2fsname(char *svname, char *fsname, char **endptr)
 834 {
 835         char *dash = strrchr(svname, '-');
 836         if (!dash) {
 837                 dash = strrchr(svname, ':');
 838                 if (!dash)
 839                         return -EINVAL;
 840         }
 841
 842         /* interpret <fsname>-MDTXXXXX-mdc as mdt, the better way is to pass
 843          * in the fsname, then determine the server index */
 844         if (!strcmp(LUSTRE_MDC_NAME, dash + 1)) {
 845                 dash--;
 846                 for (; dash > svname && *dash != '-' && *dash != ':'; dash--)
 847                         ;
 848                 if (dash == svname)
 849                         return -EINVAL;
 850         }
 851
 852         if (fsname != NULL) {
 853                 strncpy(fsname, svname, dash - svname);
 854                 fsname[dash - svname] = '\0';
 855         }
 856
 857         if (endptr != NULL)
 858                 *endptr = dash;
 859
 860         return 0;
 861 }
 862 EXPORT_SYMBOL(server_name2fsname);
 863
 864 static int is_mdc_device(char *devname)
 865 {
 866         char *ptr;
 867         ptr = strrchr(devname, '-');
 868         if (ptr != NULL && strcmp(ptr, "-mdc") == 0)
 869                 return 1;
 870         return 0;
 871 }
 872
 873 static int inline tgt_is_mdt0(char *tgtname)
 874 {
 875         __u32 idx;
 876         int   type;
 877
 878         type = server_name2index(tgtname, &idx, NULL);
 879         if (type != LDD_F_SV_TYPE_MDT)
 880                 return 0;
 881
 882         return (idx == 0) ? 1 :0;
 883 }
 884
 885 static int inline is_mdc_for_mdt0(char *devname)
 886 {
 887         char   *ptr;
 888
 889         if (!is_mdc_device(devname))
 890                 return 0;
 891
 892         ptr = strrchr(devname, '-');
 893         if (ptr == NULL)
 894                 return 0;
 895
 896         *ptr = 0;
 897         if (tgt_is_mdt0(devname)) {
 898                 *ptr = '-';
 899                 return 1;
 900         }
 901         *ptr = '-';
 902         return 0;
 903 }
 904
 905 /**
 906  * Convert OST/MDT name(fsname-OSTxxxx) to a lwp name
 907  * (fsname-MDT0000-lwp-OSTxxxx)
 908  **/
 909 int tgt_name2lwpname(char *svname, char *lwpname)
 910 {
 911         char    *fsname, *tgt;
 912         int      rc;
 913         ENTRY;
 914
 915         OBD_ALLOC(fsname, MTI_NAME_MAXLEN);
 916         if (fsname == NULL)
 917                 RETURN(-ENOMEM);
 918
 919         rc = server_name2fsname(svname, fsname, &tgt);
 920         if (rc != 0) {
 921                 CERROR("%s: failed to get fsname from svname. %d\n",
 922                        svname, rc);
 923                 GOTO(cleanup, rc);
 924         }
 925
 926         if (*tgt != '-' && *tgt != ':') {
 927                 CERROR("%s: invalid svname name!\n", svname);
 928                 GOTO(cleanup, rc = -EINVAL);
 929         }
 930
 931         tgt++;
 932         if (strncmp(tgt, "OST", 3) != 0 && strncmp(tgt, "MDT", 3) != 0) {
 933                 CERROR("%s is not an OST or MDT target!\n", svname);
 934                 GOTO(cleanup, rc = -EINVAL);
 935         }
 936         sprintf(lwpname, "%s-MDT0000-%s-%s", fsname, LUSTRE_LWP_NAME, tgt);
 937 cleanup:
 938         if (fsname != NULL)
 939                 OBD_FREE(fsname, MTI_NAME_MAXLEN);
 940         RETURN(rc);
 941 }
 942 EXPORT_SYMBOL(tgt_name2lwpname);
 943
 944 static CFS_LIST_HEAD(lwp_register_list);
 945 DEFINE_MUTEX(lwp_register_list_lock);
 946
 947 int lustre_register_lwp_item(char *lwpname, struct obd_export **exp,
 948                              register_lwp_cb cb_func, void *cb_data)
 949 {
 950         struct obd_device        *lwp;
 951         struct lwp_register_item *lri;
 952         ENTRY;
 953
 954         LASSERTF(strlen(lwpname) < MTI_NAME_MAXLEN, "lwpname is too long %s\n",
 955                  lwpname);
 956         LASSERT(exp != NULL && *exp == NULL);
 957
 958         OBD_ALLOC_PTR(lri);
 959         if (lri == NULL)
 960                 RETURN(-ENOMEM);
 961
 962         mutex_lock(&lwp_register_list_lock);
 963
 964         lwp = class_name2obd(lwpname);
 965         if (lwp != NULL && lwp->obd_set_up == 1) {
 966                 struct obd_uuid *uuid;
 967
 968                 OBD_ALLOC_PTR(uuid);
 969                 if (uuid == NULL) {
 970                         mutex_unlock(&lwp_register_list_lock);
 971                         OBD_FREE_PTR(lri);
 972                         RETURN(-ENOMEM);
 973                 }
 974                 memcpy(uuid->uuid, lwpname, strlen(lwpname));
 975                 *exp = cfs_hash_lookup(lwp->obd_uuid_hash, uuid);
 976                 OBD_FREE_PTR(uuid);
 977         }
 978
 979         memcpy(lri->lri_name, lwpname, strlen(lwpname));
 980         lri->lri_exp = exp;
 981         lri->lri_cb_func = cb_func;
 982         lri->lri_cb_data = cb_data;
 983         CFS_INIT_LIST_HEAD(&lri->lri_list);
 984         cfs_list_add(&lri->lri_list, &lwp_register_list);
 985
 986         if (*exp != NULL && cb_func != NULL)
 987                 cb_func(cb_data);
 988
 989         mutex_unlock(&lwp_register_list_lock);
 990         RETURN(0);
 991 }
 992 EXPORT_SYMBOL(lustre_register_lwp_item);
 993
 994 void lustre_deregister_lwp_item(struct obd_export **exp)
 995 {
 996         struct lwp_register_item *lri, *tmp;
 997
 998         mutex_lock(&lwp_register_list_lock);
 999         cfs_list_for_each_entry_safe(lri, tmp, &lwp_register_list, lri_list) {
1000                 if (exp == lri->lri_exp) {
1001                         if (*exp)
1002                                 class_export_put(*exp);
1003                         cfs_list_del(&lri->lri_list);
1004                         OBD_FREE_PTR(lri);
1005                         break;
1006                 }
1007         }
1008         mutex_unlock(&lwp_register_list_lock);
1009 }
1010 EXPORT_SYMBOL(lustre_deregister_lwp_item);
1011
1012 static void lustre_notify_lwp_list(struct obd_export *exp)
1013 {
1014         struct lwp_register_item *lri, *tmp;
1015         LASSERT(exp != NULL);
1016
1017         mutex_lock(&lwp_register_list_lock);
1018         cfs_list_for_each_entry_safe(lri, tmp, &lwp_register_list, lri_list) {
1019                 if (strcmp(exp->exp_obd->obd_name, lri->lri_name))
1020                         continue;
1021                 if (*lri->lri_exp != NULL)
1022                         continue;
1023                 *lri->lri_exp = class_export_get(exp);
1024                 if (lri->lri_cb_func != NULL)
1025                         lri->lri_cb_func(lri->lri_cb_data);
1026         }
1027         mutex_unlock(&lwp_register_list_lock);
1028 }
1029
1030 static int lustre_lwp_connect(struct obd_device *lwp)
1031 {
1032         struct lu_env            env;
1033         struct lu_context        session_ctx;
1034         struct obd_export       *exp;
1035         struct obd_uuid         *uuid = NULL;
1036         struct obd_connect_data *data = NULL;
1037         int                      rc;
1038         ENTRY;
1039
1040         /* log has been fully processed, let clients connect */
1041         rc = lu_env_init(&env, lwp->obd_lu_dev->ld_type->ldt_ctx_tags);
1042         if (rc != 0)
1043                 RETURN(rc);
1044
1045         lu_context_init(&session_ctx, LCT_SESSION);
1046         session_ctx.lc_thread = NULL;
1047         lu_context_enter(&session_ctx);
1048         env.le_ses = &session_ctx;
1049
1050         OBD_ALLOC_PTR(data);
1051         if (data == NULL)
1052                 GOTO(out, rc = -ENOMEM);
1053
1054         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX;
1055         data->ocd_version = LUSTRE_VERSION_CODE;
1056         data->ocd_connect_flags |= OBD_CONNECT_MDS_MDS | OBD_CONNECT_FID |
1057                                    OBD_CONNECT_AT | OBD_CONNECT_LRU_RESIZE |
1058                                    OBD_CONNECT_FULL20 | OBD_CONNECT_LVB_TYPE |
1059                                    OBD_CONNECT_LIGHTWEIGHT |
1060                                    OBD_CONNECT_PINGLESS;
1061         OBD_ALLOC_PTR(uuid);
1062         if (uuid == NULL)
1063                 GOTO(out, rc = -ENOMEM);
1064
1065         if (strlen(lwp->obd_name) > sizeof(uuid->uuid)) {
1066                 CERROR("%s: Too long lwp name %s, max_size is %d\n",
1067                        lwp->obd_name, lwp->obd_name, (int)sizeof(uuid->uuid));
1068                 GOTO(out, rc = -EINVAL);
1069         }
1070
1071         /* Use lwp name as the uuid, so we find the export by lwp name later */
1072         memcpy(uuid->uuid, lwp->obd_name, strlen(lwp->obd_name));
1073         rc = obd_connect(&env, &exp, lwp, uuid, data, NULL);
1074         if (rc != 0)
1075                 CERROR("%s: connect failed: rc = %d\n", lwp->obd_name, rc);
1076         else
1077                 lustre_notify_lwp_list(exp);
1078
1079 out:
1080         if (data != NULL)
1081                 OBD_FREE_PTR(data);
1082         if (uuid != NULL)
1083                 OBD_FREE_PTR(uuid);
1084
1085         lu_env_fini(&env);
1086         lu_context_exit(&session_ctx);
1087         lu_context_fini(&session_ctx);
1088
1089         RETURN(rc);
1090 }
1091
1092 /**
1093  * lwp is used by slaves (Non-MDT0 targets) to manage the connection
1094  * to MDT0.
1095  **/
1096 static int lustre_lwp_setup(struct lustre_cfg *lcfg, struct lustre_sb_info *lsi)
1097 {
1098         struct obd_connect_data *data = NULL;
1099         struct obd_device       *obd;
1100         char                    *lwpname = NULL;
1101         char                    *lwpuuid = NULL;
1102         int                      rc;
1103         ENTRY;
1104
1105         rc = class_add_uuid(lustre_cfg_string(lcfg, 1),
1106                             lcfg->lcfg_nid);
1107         if (rc) {
1108                 CERROR("%s: Can't add uuid: rc =%d\n", lsi->lsi_svname, rc);
1109                 GOTO(out, rc);
1110         }
1111
1112         OBD_ALLOC(lwpname, MTI_NAME_MAXLEN);
1113         if (lwpname == NULL)
1114                 GOTO(out, rc = -ENOMEM);
1115
1116         rc = tgt_name2lwpname(lsi->lsi_svname, lwpname);
1117         if (rc != 0) {
1118                 CERROR("%s: failed to generate lwp name. %d\n",
1119                        lsi->lsi_svname, rc);
1120                 GOTO(out, rc);
1121         }
1122
1123         OBD_ALLOC(lwpuuid, MTI_NAME_MAXLEN);
1124         if (lwpuuid == NULL)
1125                 GOTO(out, rc = -ENOMEM);
1126
1127         sprintf(lwpuuid, "%s_UUID", lwpname);
1128         rc = lustre_start_simple(lwpname, LUSTRE_LWP_NAME,
1129                                  lwpuuid, lustre_cfg_string(lcfg, 1),
1130                                  0, 0, 0);
1131         if (rc) {
1132                 CERROR("%s: setup up failed: rc %d\n", lwpname, rc);
1133                 GOTO(out, rc);
1134         }
1135
1136         obd = class_name2obd(lwpname);
1137         LASSERT(obd != NULL);
1138
1139         rc = lustre_lwp_connect(obd);
1140         if (rc != 0)
1141                 CERROR("%s: connect failed: rc = %d\n", lwpname, rc);
1142 out:
1143         if (data != NULL)
1144                 OBD_FREE_PTR(data);
1145         if (lwpname != NULL)
1146                 OBD_FREE(lwpname, MTI_NAME_MAXLEN);
1147         if (lwpuuid != NULL)
1148                 OBD_FREE(lwpuuid, MTI_NAME_MAXLEN);
1149
1150         RETURN(rc);
1151 }
1152
1153 /* the caller is responsible for memory free */
1154 static struct obd_device *lustre_find_lwp(struct lustre_sb_info *lsi,
1155                                           char **lwpname, char **logname)
1156 {
1157         struct obd_device       *lwp;
1158         int                      rc = 0;
1159         ENTRY;
1160
1161         LASSERT(lwpname != NULL);
1162         LASSERT(IS_OST(lsi) || IS_MDT(lsi));
1163
1164         OBD_ALLOC(*lwpname, MTI_NAME_MAXLEN);
1165         if (*lwpname == NULL)
1166                 RETURN(ERR_PTR(-ENOMEM));
1167
1168         if (logname != NULL) {
1169                 OBD_ALLOC(*logname, MTI_NAME_MAXLEN);
1170                 if (*logname == NULL)
1171                         GOTO(out, rc = -ENOMEM);
1172                 rc = server_name2fsname(lsi->lsi_svname, *lwpname, NULL);
1173                 if (rc != 0) {
1174                         CERROR("%s: failed to get fsname from svname. %d\n",
1175                                lsi->lsi_svname, rc);
1176                         GOTO(out, rc = -EINVAL);
1177                 }
1178                 sprintf(*logname, "%s-client", *lwpname);
1179         }
1180
1181         rc = tgt_name2lwpname(lsi->lsi_svname, *lwpname);
1182         if (rc != 0) {
1183                 CERROR("%s: failed to generate lwp name. %d\n",
1184                        lsi->lsi_svname, rc);
1185                 GOTO(out, rc = -EINVAL);
1186         }
1187
1188         lwp = class_name2obd(*lwpname);
1189
1190 out:
1191         if (rc != 0) {
1192                 if (*lwpname != NULL) {
1193                         OBD_FREE(*lwpname, MTI_NAME_MAXLEN);
1194                         *lwpname = NULL;
1195                 }
1196                 if (logname != NULL && *logname != NULL) {
1197                         OBD_FREE(*logname, MTI_NAME_MAXLEN);
1198                         *logname = NULL;
1199                 }
1200                 lwp = ERR_PTR(rc);
1201         }
1202
1203         RETURN(lwp != NULL ? lwp : ERR_PTR(-ENOENT));
1204 }
1205
1206 static int lustre_lwp_add_conn(struct lustre_cfg *cfg,
1207                                struct lustre_sb_info *lsi)
1208 {
1209         struct lustre_cfg_bufs *bufs = NULL;
1210         struct lustre_cfg      *lcfg = NULL;
1211         char                   *lwpname = NULL;
1212         struct obd_device      *lwp;
1213         int                     rc;
1214         ENTRY;
1215
1216         lwp = lustre_find_lwp(lsi, &lwpname, NULL);
1217         if (IS_ERR(lwp)) {
1218                 CERROR("%s: can't find lwp device.\n", lsi->lsi_svname);
1219                 GOTO(out, rc = PTR_ERR(lwp));
1220         }
1221         LASSERT(lwpname != NULL);
1222
1223         OBD_ALLOC_PTR(bufs);
1224         if (bufs == NULL)
1225                 GOTO(out, rc = -ENOMEM);
1226
1227         lustre_cfg_bufs_reset(bufs, lwpname);
1228         lustre_cfg_bufs_set_string(bufs, 1,
1229                                    lustre_cfg_string(cfg, 1));
1230
1231         lcfg = lustre_cfg_new(LCFG_ADD_CONN, bufs);
1232
1233         rc = class_add_conn(lwp, lcfg);
1234         if (rc)
1235                 CERROR("%s: can't add conn: rc = %d\n", lwpname, rc);
1236
1237 out:
1238         if (bufs != NULL)
1239                 OBD_FREE_PTR(bufs);
1240         if (lcfg != NULL)
1241                 lustre_cfg_free(lcfg);
1242         if (lwpname != NULL)
1243                 OBD_FREE(lwpname, MTI_NAME_MAXLEN);
1244         RETURN(rc);
1245 }
1246
1247 /**
1248  * Retrieve MDT nids from the client log, then start the lwp device.
1249  * there are only two scenarios which would include mdt nid.
1250  * 1.
1251  * marker   5 (flags=0x01, v2.1.54.0) lustre-MDT0000  'add mdc' xxx-
1252  * add_uuid  nid=192.168.122.162@tcp(0x20000c0a87aa2)  0:  1:192.168.122.162@tcp
1253  * attach    0:lustre-MDT0000-mdc  1:mdc  2:lustre-clilmv_UUID
1254  * setup     0:lustre-MDT0000-mdc  1:lustre-MDT0000_UUID  2:192.168.122.162@tcp
1255  * add_uuid  nid=192.168.172.1@tcp(0x20000c0a8ac01)  0:  1:192.168.172.1@tcp
1256  * add_conn  0:lustre-MDT0000-mdc  1:192.168.172.1@tcp
1257  * modify_mdc_tgts add 0:lustre-clilmv  1:lustre-MDT0000_UUID xxxx
1258  * marker   5 (flags=0x02, v2.1.54.0) lustre-MDT0000  'add mdc' xxxx-
1259  * 2.
1260  * marker   7 (flags=0x01, v2.1.54.0) lustre-MDT0000  'add failnid' xxxx-
1261  * add_uuid  nid=192.168.122.2@tcp(0x20000c0a87a02)  0:  1:192.168.122.2@tcp
1262  * add_conn  0:lustre-MDT0000-mdc  1:192.168.122.2@tcp
1263  * marker   7 (flags=0x02, v2.1.54.0) lustre-MDT0000  'add failnid' xxxx-
1264 **/
1265 static int client_lwp_config_process(const struct lu_env *env,
1266                                      struct llog_handle *handle,
1267                                      struct llog_rec_hdr *rec, void *data)
1268 {
1269         struct config_llog_instance *clli = data;
1270         int                          cfg_len = rec->lrh_len;
1271         char                        *cfg_buf = (char *) (rec + 1);
1272         struct lustre_cfg           *lcfg = NULL;
1273         struct lustre_sb_info       *lsi;
1274         int                          rc = 0, swab = 0;
1275         ENTRY;
1276
1277         if (rec->lrh_type != OBD_CFG_REC) {
1278                 CERROR("Unknown llog record type %#x encountered\n",
1279                        rec->lrh_type);
1280                 RETURN(-EINVAL);
1281         }
1282
1283         LASSERT(clli->cfg_sb != NULL);
1284         lsi = s2lsi(clli->cfg_sb);
1285
1286         lcfg = (struct lustre_cfg *)cfg_buf;
1287         if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION)) {
1288                 lustre_swab_lustre_cfg(lcfg);
1289                 swab = 1;
1290         }
1291
1292         rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
1293         if (rc)
1294                 GOTO(out, rc);
1295
1296         switch (lcfg->lcfg_command) {
1297         case LCFG_MARKER: {
1298                 struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
1299
1300                 lustre_swab_cfg_marker(marker, swab,
1301                                        LUSTRE_CFG_BUFLEN(lcfg, 1));
1302                 if (marker->cm_flags & CM_SKIP ||
1303                     marker->cm_flags & CM_EXCLUDE)
1304                         GOTO(out, rc = 0);
1305
1306                 if (!tgt_is_mdt0(marker->cm_tgtname))
1307                         GOTO(out, rc = 0);
1308
1309                 if(!strncmp(marker->cm_comment, "add mdc", 7) ||
1310                    !strncmp(marker->cm_comment, "add failnid", 11)) {
1311                         if (marker->cm_flags & CM_START) {
1312                                 clli->cfg_flags = CFG_F_MARKER;
1313                                 /* This hack is to differentiate the
1314                                  * ADD_UUID is come from "add mdc" record
1315                                  * or from "add failnid" record. */
1316                                 if (!strncmp(marker->cm_comment,
1317                                              "add failnid", 11))
1318                                         clli->cfg_flags |= CFG_F_SKIP;
1319                         } else if (marker->cm_flags & CM_END) {
1320                                 clli->cfg_flags = 0;
1321                         }
1322                 }
1323                 break;
1324         }
1325         case LCFG_ADD_UUID: {
1326                 if (clli->cfg_flags == CFG_F_MARKER) {
1327                         rc = lustre_lwp_setup(lcfg, lsi);
1328                         /* XXX: process only the first nid as
1329                          * we don't need another instance of lwp */
1330                         clli->cfg_flags |= CFG_F_SKIP;
1331                 } else if (clli->cfg_flags == (CFG_F_MARKER | CFG_F_SKIP)) {
1332                         rc = class_add_uuid(lustre_cfg_string(lcfg, 1),
1333                                         lcfg->lcfg_nid);
1334                         if (rc)
1335                                 CERROR("%s: Fail to add uuid, rc:%d\n",
1336                                        lsi->lsi_svname, rc);
1337                 }
1338                 break;
1339         }
1340         case LCFG_ADD_CONN: {
1341                 if (is_mdc_for_mdt0(lustre_cfg_string(lcfg, 0)))
1342                         rc = lustre_lwp_add_conn(lcfg, lsi);
1343                 break;
1344         }
1345         default:
1346                 break;
1347         }
1348 out:
1349         RETURN(rc);
1350 }
1351
1352 static int lustre_disconnect_lwp(struct super_block *sb)
1353 {
1354         struct lustre_sb_info           *lsi = s2lsi(sb);
1355         struct obd_device               *lwp;
1356         char                            *lwpname = NULL;
1357         char                            *logname = NULL;
1358         struct lustre_cfg               *lcfg = NULL;
1359         struct lustre_cfg_bufs          *bufs = NULL;
1360         struct config_llog_instance     *cfg = NULL;
1361         int                              rc;
1362         ENTRY;
1363
1364         lwp = lustre_find_lwp(lsi, &lwpname, &logname);
1365         if (IS_ERR(lwp) && PTR_ERR(lwp) != -ENOENT)
1366                 GOTO(out, rc = PTR_ERR(lwp));
1367
1368         LASSERT(lwpname != NULL);
1369         LASSERT(logname != NULL);
1370
1371         OBD_ALLOC_PTR(cfg);
1372         if (cfg == NULL)
1373                 GOTO(out, rc = -ENOMEM);
1374
1375         /* end log first */
1376         cfg->cfg_instance = sb;
1377         rc = lustre_end_log(sb, logname, cfg);
1378         if (rc != 0) {
1379                 CERROR("%s: Can't end config log %s.\n", lwpname, logname);
1380                 GOTO(out, rc);
1381         }
1382
1383         if (PTR_ERR(lwp) == -ENOENT) {
1384                 CDEBUG(D_CONFIG, "%s: lwp device wasn't started.\n",
1385                        lsi->lsi_svname);
1386                 GOTO(out, rc = 0);
1387         }
1388
1389         OBD_ALLOC_PTR(bufs);
1390         if (bufs == NULL)
1391                 GOTO(out, rc = -ENOMEM);
1392
1393         lustre_cfg_bufs_reset(bufs, lwp->obd_name);
1394         lustre_cfg_bufs_set_string(bufs, 1, NULL);
1395         lcfg = lustre_cfg_new(LCFG_CLEANUP, bufs);
1396         if (!lcfg)
1397                 GOTO(out, rc = -ENOMEM);
1398
1399         /* Disconnect import first. NULL is passed for the '@env', since
1400          * it will not be used. */
1401         rc = lwp->obd_lu_dev->ld_ops->ldo_process_config(NULL, lwp->obd_lu_dev,
1402                                                          lcfg);
1403 out:
1404         if (lcfg)
1405                 lustre_cfg_free(lcfg);
1406         if (bufs)
1407                 OBD_FREE_PTR(bufs);
1408         if (cfg)
1409                 OBD_FREE_PTR(cfg);
1410         if (lwpname)
1411                 OBD_FREE(lwpname, MTI_NAME_MAXLEN);
1412         if (logname)
1413                 OBD_FREE(logname, MTI_NAME_MAXLEN);
1414         RETURN(rc);
1415 }
1416
1417 /**
1418  * Stop the lwp for an OST/MDT target.
1419  **/
1420 static int lustre_stop_lwp(struct super_block *sb)
1421 {
1422         struct lustre_sb_info   *lsi = s2lsi(sb);
1423         struct obd_device       *lwp = NULL;
1424         char                    *lwpname = NULL;
1425         int                      rc = 0;
1426         ENTRY;
1427
1428         lwp = lustre_find_lwp(lsi, &lwpname, NULL);
1429         if (IS_ERR(lwp)) {
1430                 CDEBUG(PTR_ERR(lwp) == -ENOENT ? D_CONFIG : D_ERROR,
1431                        "%s: lwp wasn't started.\n", lsi->lsi_svname);
1432                 GOTO(out, rc = 0);
1433         }
1434
1435         lwp->obd_force = 1;
1436         rc = class_manual_cleanup(lwp);
1437
1438 out:
1439         if (lwpname != NULL)
1440                 OBD_FREE(lwpname, MTI_NAME_MAXLEN);
1441         RETURN(rc);
1442 }
1443
1444 /**
1445  * Start the lwp(fsname-MDT0000-lwp-OSTxxxx) for an OST or MDT target,
1446  * which would be used to establish connection from OST to MDT0.
1447  **/
1448 static int lustre_start_lwp(struct super_block *sb)
1449 {
1450         struct lustre_sb_info       *lsi = s2lsi(sb);
1451         struct config_llog_instance *cfg = NULL;
1452         struct obd_device           *lwp;
1453         char                        *lwpname = NULL;
1454         char                        *logname = NULL;
1455         int                          rc;
1456         ENTRY;
1457
1458         lwp = lustre_find_lwp(lsi, &lwpname, &logname);
1459
1460         /* the lwp device already stared */
1461         if (lwp && !IS_ERR(lwp))
1462                 GOTO(out, rc = 0);
1463
1464         if (PTR_ERR(lwp) != -ENOENT)
1465                 GOTO(out, rc = PTR_ERR(lwp));
1466
1467         LASSERT(lwpname != NULL);
1468         LASSERT(logname != NULL);
1469
1470         OBD_ALLOC_PTR(cfg);
1471         if (cfg == NULL)
1472                 GOTO(out, rc = -ENOMEM);
1473
1474         cfg->cfg_callback = client_lwp_config_process;
1475         cfg->cfg_instance = sb;
1476
1477         rc = lustre_process_log(sb, logname, cfg);
1478 out:
1479         if (lwpname != NULL)
1480                 OBD_FREE(lwpname, MTI_NAME_MAXLEN);
1481         if (logname != NULL)
1482                 OBD_FREE(logname, MTI_NAME_MAXLEN);
1483         if (cfg != NULL)
1484                 OBD_FREE_PTR(cfg);
1485         RETURN(rc);
1486 }
1487
1488 DEFINE_MUTEX(server_start_lock);
1489
1490 /* Stop MDS/OSS if nobody is using them */
1491 static int server_stop_servers(int lsiflags)
1492 {
1493         struct obd_device *obd = NULL;
1494         struct obd_type *type = NULL;
1495         int rc = 0;
1496         ENTRY;
1497
1498         mutex_lock(&server_start_lock);
1499
1500         /* Either an MDT or an OST or neither  */
1501         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
1502         if ((lsiflags & LDD_F_SV_TYPE_MDT) &&
1503             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
1504                 type = class_search_type(LUSTRE_MDT_NAME);
1505         }
1506        /* if this was an OST, and there are no more OST's, clean up the OSS */
1507         if ((lsiflags & LDD_F_SV_TYPE_OST) &&
1508             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
1509                 type = class_search_type(LUSTRE_OST_NAME);
1510         }
1511
1512         if (obd && (!type || !type->typ_refcnt)) {
1513                 int err;
1514                 obd->obd_force = 1;
1515                 /* obd_fail doesn't mean much on a server obd */
1516                 err = class_manual_cleanup(obd);
1517                 if (!rc)
1518                         rc = err;
1519         }
1520
1521         mutex_unlock(&server_start_lock);
1522
1523         RETURN(rc);
1524 }
1525
1526 int server_mti_print(char *title, struct mgs_target_info *mti)
1527 {
1528         PRINT_CMD(PRINT_MASK, "mti %s\n", title);
1529         PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
1530         PRINT_CMD(PRINT_MASK, "fs:     %s\n", mti->mti_fsname);
1531         PRINT_CMD(PRINT_MASK, "uuid:   %s\n", mti->mti_uuid);
1532         PRINT_CMD(PRINT_MASK, "ver: %d  flags: %#x\n",
1533                   mti->mti_config_ver, mti->mti_flags);
1534         return(0);
1535 }
1536
1537 /**
1538  * Get service name (svname) from string
1539  * rc < 0 on error
1540  * if endptr isn't NULL it is set to end of fsname *
1541  */
1542 int server_name2svname(char *label, char *svname, char **endptr)
1543 {
1544         int rc;
1545         char *dash;
1546
1547         /* We use server_name2fsname() just for parsing */
1548         rc = server_name2fsname(label, NULL, &dash);
1549         if (rc != 0)
1550                 return rc;
1551
1552         if (*dash != '-')
1553                 return -1;
1554
1555         strncpy(svname, dash + 1, MTI_NAME_MAXLEN);
1556
1557         return 0;
1558 }
1559 EXPORT_SYMBOL(server_name2svname);
1560
1561
1562 /* Get the index from the obd name.
1563    rc = server type, or
1564    rc < 0  on error
1565    if endptr isn't NULL it is set to end of name */
1566 int server_name2index(char *svname, __u32 *idx, char **endptr)
1567 {
1568         unsigned long index;
1569         int rc;
1570         char *dash;
1571
1572         /* We use server_name2fsname() just for parsing */
1573         rc = server_name2fsname(svname, NULL, &dash);
1574         if (rc != 0)
1575                 return rc;
1576
1577         if (*dash != '-')
1578                 return -EINVAL;
1579
1580         dash++;
1581
1582         if (strncmp(dash, "MDT", 3) == 0)
1583                 rc = LDD_F_SV_TYPE_MDT;
1584         else if (strncmp(dash, "OST", 3) == 0)
1585                 rc = LDD_F_SV_TYPE_OST;
1586         else
1587                 return -EINVAL;
1588
1589         dash += 3;
1590
1591         if (strcmp(dash, "all") == 0)
1592                 return rc | LDD_F_SV_ALL;
1593
1594         index = simple_strtoul(dash, endptr, 16);
1595         *idx = index;
1596
1597         return rc;
1598 }
1599 EXPORT_SYMBOL(server_name2index);
1600
1601 /* Generate data for registration */
1602 static int server_lsi2mti(struct lustre_sb_info *lsi,
1603                           struct mgs_target_info *mti)
1604 {
1605         lnet_process_id_t id;
1606         int rc, i = 0;
1607         ENTRY;
1608
1609         if (!IS_SERVER(lsi))
1610                 RETURN(-EINVAL);
1611
1612         strncpy(mti->mti_svname, lsi->lsi_svname, sizeof(mti->mti_svname));
1613
1614         mti->mti_nid_count = 0;
1615         while (LNetGetId(i++, &id) != -ENOENT) {
1616                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
1617                         continue;
1618
1619                 /* server use --servicenode param, only allow specified
1620                  * nids be registered */
1621                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) != 0 &&
1622                     class_match_nid(lsi->lsi_lmd->lmd_params,
1623                                     PARAM_FAILNODE, id.nid) < 1)
1624                         continue;
1625
1626                 /* match specified network */
1627                 if (!class_match_net(lsi->lsi_lmd->lmd_params,
1628                                      PARAM_NETWORK, LNET_NIDNET(id.nid)))
1629                         continue;
1630
1631                 mti->mti_nids[mti->mti_nid_count] = id.nid;
1632                 mti->mti_nid_count++;
1633                 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
1634                         CWARN("Only using first %d nids for %s\n",
1635                               mti->mti_nid_count, mti->mti_svname);
1636                         break;
1637                 }
1638         }
1639
1640         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
1641         mti->mti_config_ver = 0;
1642
1643         rc = server_name2fsname(lsi->lsi_svname, mti->mti_fsname, NULL);
1644         if (rc != 0)
1645                 return rc;
1646
1647         rc = server_name2index(lsi->lsi_svname, &mti->mti_stripe_index, NULL);
1648         if (rc < 0)
1649                 return rc;
1650         /* Orion requires index to be set */
1651         LASSERT(!(rc & LDD_F_NEED_INDEX));
1652         /* keep only LDD flags */
1653         mti->mti_flags = lsi->lsi_flags & LDD_F_MASK;
1654         if (mti->mti_flags & (LDD_F_WRITECONF | LDD_F_VIRGIN))
1655                 mti->mti_flags |= LDD_F_UPDATE;
1656         strncpy(mti->mti_params, lsi->lsi_lmd->lmd_params,
1657                 sizeof(mti->mti_params));
1658         return 0;
1659 }
1660
1661 /* Register an old or new target with the MGS. If needed MGS will construct
1662    startup logs and assign index */
1663 static int server_register_target(struct lustre_sb_info *lsi)
1664 {
1665         struct obd_device *mgc = lsi->lsi_mgc;
1666         struct mgs_target_info *mti = NULL;
1667         bool writeconf;
1668         int rc;
1669         ENTRY;
1670
1671         LASSERT(mgc);
1672
1673         if (!IS_SERVER(lsi))
1674                 RETURN(-EINVAL);
1675
1676         OBD_ALLOC_PTR(mti);
1677         if (!mti)
1678                 RETURN(-ENOMEM);
1679
1680         rc = server_lsi2mti(lsi, mti);
1681         if (rc)
1682                 GOTO(out, rc);
1683
1684         CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
1685                mti->mti_svname, mti->mti_fsname,
1686                libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
1687                mti->mti_flags);
1688
1689         /* if write_conf is true, the registration must succeed */
1690         writeconf = !!(lsi->lsi_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE));
1691         mti->mti_flags |= LDD_F_OPC_REG;
1692
1693         /* Register the target */
1694         /* FIXME use mgc_process_config instead */
1695         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1696                                 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1697                                 sizeof(*mti), mti, NULL);
1698         if (rc) {
1699                 if (mti->mti_flags & LDD_F_ERROR) {
1700                         LCONSOLE_ERROR_MSG(0x160,
1701                                 "The MGS is refusing to allow this "
1702                                 "server (%s) to start. Please see messages"
1703                                 " on the MGS node.\n", lsi->lsi_svname);
1704                 } else if (writeconf) {
1705                         LCONSOLE_ERROR_MSG(0x15f,
1706                                 "Communication to the MGS return error %d. "
1707                                 "Is the MGS running?\n", rc);
1708                 } else {
1709                         CERROR("Cannot talk to the MGS: %d, not fatal\n", rc);
1710                         /* reset the error code for non-fatal error. */
1711                         rc = 0;
1712                 }
1713                 GOTO(out, rc);
1714         }
1715
1716 out:
1717         if (mti)
1718                 OBD_FREE_PTR(mti);
1719         RETURN(rc);
1720 }
1721
1722 /**
1723  * Notify the MGS that this target is ready.
1724  * Used by IR - if the MGS receives this message, it will notify clients.
1725  */
1726 static int server_notify_target(struct super_block *sb, struct obd_device *obd)
1727 {
1728         struct lustre_sb_info *lsi = s2lsi(sb);
1729         struct obd_device *mgc = lsi->lsi_mgc;
1730         struct mgs_target_info *mti = NULL;
1731         int rc;
1732         ENTRY;
1733
1734         LASSERT(mgc);
1735
1736         if (!(IS_SERVER(lsi)))
1737                 RETURN(-EINVAL);
1738
1739         OBD_ALLOC_PTR(mti);
1740         if (!mti)
1741                 RETURN(-ENOMEM);
1742         rc = server_lsi2mti(lsi, mti);
1743         if (rc)
1744                 GOTO(out, rc);
1745
1746         mti->mti_instance = obd->u.obt.obt_instance;
1747         mti->mti_flags |= LDD_F_OPC_READY;
1748
1749         /* FIXME use mgc_process_config instead */
1750         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1751                                 sizeof(KEY_REGISTER_TARGET),
1752                                 KEY_REGISTER_TARGET,
1753                                 sizeof(*mti), mti, NULL);
1754
1755         /* Imperative recovery: if the mgs informs us to use IR? */
1756         if (!rc && !(mti->mti_flags & LDD_F_ERROR) &&
1757             (mti->mti_flags & LDD_F_IR_CAPABLE))
1758                 lsi->lsi_flags |= LDD_F_IR_CAPABLE;
1759
1760 out:
1761         if (mti)
1762                 OBD_FREE_PTR(mti);
1763         RETURN(rc);
1764
1765 }
1766
1767 /** Start server targets: MDTs and OSTs
1768  */
1769 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1770 {
1771         struct obd_device *obd;
1772         struct lustre_sb_info *lsi = s2lsi(sb);
1773         struct config_llog_instance cfg;
1774         struct lu_env env;
1775         struct lu_device *dev;
1776         int rc;
1777         ENTRY;
1778
1779         CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_svname);
1780
1781         if (IS_MDT(lsi)) {
1782                 /* make sure the MDS is started */
1783                 mutex_lock(&server_start_lock);
1784                 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1785                 if (!obd) {
1786                         rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1787                                                  LUSTRE_MDS_NAME,
1788                                                  LUSTRE_MDS_OBDNAME"_uuid",
1789                                                  0, 0, 0, 0);
1790                         if (rc) {
1791                                 mutex_unlock(&server_start_lock);
1792                                 CERROR("failed to start MDS: %d\n", rc);
1793                                 RETURN(rc);
1794                         }
1795                 }
1796                 mutex_unlock(&server_start_lock);
1797         }
1798
1799         /* If we're an OST, make sure the global OSS is running */
1800         if (IS_OST(lsi)) {
1801                 /* make sure OSS is started */
1802                 mutex_lock(&server_start_lock);
1803                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1804                 if (!obd) {
1805                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1806                                                  LUSTRE_OSS_NAME,
1807                                                  LUSTRE_OSS_OBDNAME"_uuid",
1808                                                  0, 0, 0, 0);
1809                         if (rc) {
1810                                 mutex_unlock(&server_start_lock);
1811                                 CERROR("failed to start OSS: %d\n", rc);
1812                                 RETURN(rc);
1813                         }
1814                 }
1815                 mutex_unlock(&server_start_lock);
1816         }
1817
1818         /* Set the mgc fs to our server disk.  This allows the MGC to
1819          * read and write configs locally, in case it can't talk to the MGS. */
1820         if (lsi->lsi_srv_mnt) {
1821                 rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1822                 if (rc)
1823                         GOTO(out_stop_service, rc);
1824         }
1825
1826         /* Register with MGS */
1827         rc = server_register_target(lsi);
1828         if (rc)
1829                 GOTO(out_mgc, rc);
1830
1831         /* Let the target look up the mount using the target's name
1832            (we can't pass the sb or mnt through class_process_config.) */
1833         rc = server_register_mount(lsi->lsi_svname, sb, mnt);
1834         if (rc)
1835                 GOTO(out_mgc, rc);
1836
1837         /* Start targets using the llog named for the target */
1838         memset(&cfg, 0, sizeof(cfg));
1839         cfg.cfg_callback = class_config_llog_handler;
1840         rc = lustre_process_log(sb, lsi->lsi_svname, &cfg);
1841         if (rc) {
1842                 CERROR("failed to start server %s: %d\n",
1843                        lsi->lsi_svname, rc);
1844                 /* Do NOT call server_deregister_mount() here. This makes it
1845                  * impossible to find mount later in cleanup time and leaves
1846                  * @lsi and othder stuff leaked. -umka */
1847                 GOTO(out_mgc, rc);
1848         }
1849
1850         obd = class_name2obd(lsi->lsi_svname);
1851         if (!obd) {
1852                 CERROR("no server named %s was started\n", lsi->lsi_svname);
1853                 GOTO(out_mgc, rc = -ENXIO);
1854         }
1855
1856         if (IS_OST(lsi) || IS_MDT(lsi)) {
1857                 rc = lustre_start_lwp(sb);
1858                 if (rc) {
1859                         CERROR("%s: failed to start LWP: %d\n",
1860                                lsi->lsi_svname, rc);
1861                         GOTO(out_mgc, rc);
1862                 }
1863         }
1864
1865         server_notify_target(sb, obd);
1866
1867         /* calculate recovery timeout, do it after lustre_process_log */
1868         server_calc_timeout(lsi, obd);
1869
1870         /* log has been fully processed */
1871         obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1872
1873         /* log has been fully processed, let clients connect */
1874         dev = obd->obd_lu_dev;
1875         if (dev && dev->ld_ops->ldo_prepare) {
1876                 rc = lu_env_init(&env, dev->ld_type->ldt_ctx_tags);
1877                 if (rc == 0) {
1878                         struct lu_context  session_ctx;
1879
1880                         lu_context_init(&session_ctx, LCT_SESSION);
1881                         session_ctx.lc_thread = NULL;
1882                         lu_context_enter(&session_ctx);
1883                         env.le_ses = &session_ctx;
1884
1885                         dev->ld_ops->ldo_prepare(&env, NULL, dev);
1886
1887                         lu_env_fini(&env);
1888                         lu_context_exit(&session_ctx);
1889                         lu_context_fini(&session_ctx);
1890                 }
1891         }
1892
1893         /* abort recovery only on the complete stack:
1894          * many devices can be involved */
1895         if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1896             (OBP(obd, iocontrol))) {
1897                 obd_iocontrol(OBD_IOC_ABORT_RECOVERY, obd->obd_self_export, 0,
1898                               NULL, NULL);
1899         }
1900
1901 out_mgc:
1902         /* Release the mgc fs for others to use */
1903         if (lsi->lsi_srv_mnt)
1904                 server_mgc_clear_fs(lsi->lsi_mgc);
1905
1906 out_stop_service:
1907         if (rc != 0)
1908                 server_stop_servers(lsi->lsi_flags);
1909
1910         RETURN(rc);
1911 }
1912
1913 /***************** lustre superblock **************/
1914
1915 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1916 {
1917         struct lustre_sb_info *lsi;
1918         ENTRY;
1919
1920         OBD_ALLOC_PTR(lsi);
1921         if (!lsi)
1922                 RETURN(NULL);
1923         OBD_ALLOC_PTR(lsi->lsi_lmd);
1924         if (!lsi->lsi_lmd) {
1925                 OBD_FREE_PTR(lsi);
1926                 RETURN(NULL);
1927         }
1928
1929         lsi->lsi_lmd->lmd_exclude_count = 0;
1930         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
1931         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
1932         s2lsi_nocast(sb) = lsi;
1933         /* we take 1 extra ref for our setup */
1934         cfs_atomic_set(&lsi->lsi_mounts, 1);
1935
1936         /* Default umount style */
1937         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1938
1939         RETURN(lsi);
1940 }
1941
1942 static int lustre_free_lsi(struct super_block *sb)
1943 {
1944         struct lustre_sb_info *lsi = s2lsi(sb);
1945         ENTRY;
1946
1947         LASSERT(lsi != NULL);
1948         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
1949
1950         /* someone didn't call server_put_mount. */
1951         LASSERT(cfs_atomic_read(&lsi->lsi_mounts) == 0);
1952
1953         if (lsi->lsi_lmd != NULL) {
1954                 if (lsi->lsi_lmd->lmd_dev != NULL)
1955                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
1956                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
1957                 if (lsi->lsi_lmd->lmd_profile != NULL)
1958                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
1959                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
1960                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
1961                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
1962                                  strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
1963                 if (lsi->lsi_lmd->lmd_opts != NULL)
1964                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
1965                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
1966                 if (lsi->lsi_lmd->lmd_exclude_count)
1967                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1968                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1969                                  lsi->lsi_lmd->lmd_exclude_count);
1970                 if (lsi->lsi_lmd->lmd_mgs != NULL)
1971                         OBD_FREE(lsi->lsi_lmd->lmd_mgs,
1972                                  strlen(lsi->lsi_lmd->lmd_mgs) + 1);
1973                 if (lsi->lsi_lmd->lmd_osd_type != NULL)
1974                         OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
1975                                  strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
1976                 if (lsi->lsi_lmd->lmd_params != NULL)
1977                         OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
1978
1979                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1980         }
1981
1982         LASSERT(lsi->lsi_llsbi == NULL);
1983         OBD_FREE(lsi, sizeof(*lsi));
1984         s2lsi_nocast(sb) = NULL;
1985
1986         RETURN(0);
1987 }
1988
1989 /* The lsi has one reference for every server that is using the disk -
1990    e.g. MDT, MGS, and potentially MGC */
1991 static int lustre_put_lsi(struct super_block *sb)
1992 {
1993         struct lustre_sb_info *lsi = s2lsi(sb);
1994         ENTRY;
1995
1996         LASSERT(lsi != NULL);
1997
1998         CDEBUG(D_MOUNT, "put %p %d\n", sb, cfs_atomic_read(&lsi->lsi_mounts));
1999         if (cfs_atomic_dec_and_test(&lsi->lsi_mounts)) {
2000                 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
2001                         obd_disconnect(lsi->lsi_osd_exp);
2002                         /* wait till OSD is gone */
2003                         obd_zombie_barrier();
2004                 }
2005                 lustre_free_lsi(sb);
2006                 RETURN(1);
2007         }
2008         RETURN(0);
2009 }
2010
2011 static int lsi_prepare(struct lustre_sb_info *lsi)
2012 {
2013         __u32 index;
2014         int rc;
2015         ENTRY;
2016
2017         LASSERT(lsi);
2018         LASSERT(lsi->lsi_lmd);
2019
2020         /* The server name is given as a mount line option */
2021         if (lsi->lsi_lmd->lmd_profile == NULL) {
2022                 LCONSOLE_ERROR("Can't determine server name\n");
2023                 RETURN(-EINVAL);
2024         }
2025
2026         if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname))
2027                 RETURN(-ENAMETOOLONG);
2028
2029         strcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile);
2030
2031         /* Determine osd type */
2032         if (lsi->lsi_lmd->lmd_osd_type != NULL) {
2033                 if (strlen(lsi->lsi_lmd->lmd_osd_type) >=
2034                            sizeof(lsi->lsi_osd_type))
2035                         RETURN(-ENAMETOOLONG);
2036
2037                 strcpy(lsi->lsi_osd_type, lsi->lsi_lmd->lmd_osd_type);
2038         } else {
2039                 strcpy(lsi->lsi_osd_type, LUSTRE_OSD_LDISKFS_NAME);
2040         }
2041
2042         /* XXX: a temp. solution for components using fsfilt
2043          *      to be removed in one of the subsequent patches */
2044         if (!strcmp(lsi->lsi_lmd->lmd_osd_type, "osd-ldiskfs")) {
2045                 strcpy(lsi->lsi_fstype, "ldiskfs");
2046         } else {
2047                 strcpy(lsi->lsi_fstype, lsi->lsi_lmd->lmd_osd_type);
2048         }
2049
2050         /* Determine server type */
2051         rc = server_name2index(lsi->lsi_svname, &index, NULL);
2052         if (rc < 0) {
2053                 if (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) {
2054                         /* Assume we're a bare MGS */
2055                         rc = 0;
2056                         lsi->lsi_lmd->lmd_flags |= LMD_FLG_NOSVC;
2057                 } else {
2058                         LCONSOLE_ERROR("Can't determine server type of '%s'\n",
2059                                        lsi->lsi_svname);
2060                         RETURN(rc);
2061                 }
2062         }
2063         lsi->lsi_flags |= rc;
2064
2065         /* Add mount line flags that used to be in ldd:
2066          * writeconf, mgs, anything else?
2067          */
2068         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_WRITECONF) ?
2069                 LDD_F_WRITECONF : 0;
2070         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_VIRGIN) ?
2071                 LDD_F_VIRGIN : 0;
2072         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) ?
2073                 LDD_F_SV_TYPE_MGS : 0;
2074         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) ?
2075                 LDD_F_NO_PRIMNODE : 0;
2076
2077         RETURN(0);
2078 }
2079
2080 /*************** server mount ******************/
2081
2082 /** Start the shutdown of servers at umount.
2083  */
2084 static void server_put_super(struct super_block *sb)
2085 {
2086         struct lustre_sb_info *lsi = s2lsi(sb);
2087         struct obd_device     *obd;
2088         char *tmpname, *extraname = NULL;
2089         int tmpname_sz;
2090         int lsiflags = lsi->lsi_flags;
2091         ENTRY;
2092
2093         LASSERT(IS_SERVER(lsi));
2094
2095         tmpname_sz = strlen(lsi->lsi_svname) + 1;
2096         OBD_ALLOC(tmpname, tmpname_sz);
2097         memcpy(tmpname, lsi->lsi_svname, tmpname_sz);
2098         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
2099         if (IS_MDT(lsi) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
2100                 snprintf(tmpname, tmpname_sz, "MGS");
2101
2102         /* disconnect the lwp first to drain off the inflight request */
2103         if (IS_OST(lsi) || IS_MDT(lsi)) {
2104                 int     rc;
2105
2106                 rc = lustre_disconnect_lwp(sb);
2107                 if (rc && rc != ETIMEDOUT)
2108                         CERROR("%s: failed to disconnect lwp. (rc=%d)\n",
2109                                tmpname, rc);
2110         }
2111
2112         /* Stop the target */
2113         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
2114             (IS_MDT(lsi) || IS_OST(lsi))) {
2115                 struct lustre_profile *lprof = NULL;
2116
2117                 /* tell the mgc to drop the config log */
2118                 lustre_end_log(sb, lsi->lsi_svname, NULL);
2119
2120                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
2121                    If there are any setup/cleanup errors, save the lov
2122                    name for safety cleanup later. */
2123                 lprof = class_get_profile(lsi->lsi_svname);
2124                 if (lprof && lprof->lp_dt) {
2125                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
2126                         strcpy(extraname, lprof->lp_dt);
2127                 }
2128
2129                 obd = class_name2obd(lsi->lsi_svname);
2130                 if (obd) {
2131                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
2132                         if (lsiflags & LSI_UMOUNT_FAILOVER)
2133                                 obd->obd_fail = 1;
2134                         /* We can't seem to give an error return code
2135                          * to .put_super, so we better make sure we clean up! */
2136                         obd->obd_force = 1;
2137                         class_manual_cleanup(obd);
2138                 } else {
2139                         CERROR("no obd %s\n", lsi->lsi_svname);
2140                         server_deregister_mount(lsi->lsi_svname);
2141                 }
2142         }
2143
2144         /* If they wanted the mgs to stop separately from the mdt, they
2145            should have put it on a different device. */
2146         if (IS_MGS(lsi)) {
2147                 /* if MDS start with --nomgs, don't stop MGS then */
2148                 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
2149                         server_stop_mgs(sb);
2150         }
2151
2152         if (IS_OST(lsi) || IS_MDT(lsi)) {
2153                 if (lustre_stop_lwp(sb) < 0)
2154                         CERROR("%s: failed to stop lwp!\n", tmpname);
2155         }
2156
2157         /* Clean the mgc and sb */
2158         lustre_common_put_super(sb);
2159
2160         /* wait till all in-progress cleanups are done
2161          * specifically we're interested in ofd cleanup
2162          * as it pins OSS */
2163         obd_zombie_barrier();
2164
2165         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
2166            until the target is really gone so that our type refcount check
2167            is right. */
2168         server_stop_servers(lsiflags);
2169
2170         /* In case of startup or cleanup err, stop related obds */
2171         if (extraname) {
2172                 obd = class_name2obd(extraname);
2173                 if (obd) {
2174                         CWARN("Cleaning orphaned obd %s\n", extraname);
2175                         obd->obd_force = 1;
2176                         class_manual_cleanup(obd);
2177                 }
2178                 OBD_FREE(extraname, strlen(extraname) + 1);
2179         }
2180
2181         LCONSOLE_WARN("server umount %s complete\n", tmpname);
2182         OBD_FREE(tmpname, tmpname_sz);
2183         EXIT;
2184 }
2185
2186 /** Called only for 'umount -f'
2187  */
2188 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
2189 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
2190 {
2191         struct super_block *sb = vfsmnt->mnt_sb;
2192 #else
2193 static void server_umount_begin(struct super_block *sb)
2194 {
2195 #endif
2196         struct lustre_sb_info *lsi = s2lsi(sb);
2197         ENTRY;
2198
2199 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
2200         if (!(flags & MNT_FORCE)) {
2201                 EXIT;
2202                 return;
2203         }
2204 #endif
2205
2206         CDEBUG(D_MOUNT, "umount -f\n");
2207         /* umount = failover
2208            umount -f = force
2209            no third way to do non-force, non-failover */
2210         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
2211         EXIT;
2212 }
2213
2214 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
2215 {
2216         struct super_block *sb = dentry->d_sb;
2217         struct lustre_sb_info *lsi = s2lsi(sb);
2218         struct obd_statfs statfs;
2219         int rc;
2220         ENTRY;
2221
2222         if (lsi->lsi_dt_dev) {
2223                 rc = dt_statfs(NULL, lsi->lsi_dt_dev, &statfs);
2224                 if (rc == 0) {
2225                         statfs_unpack(buf, &statfs);
2226                         buf->f_type = sb->s_magic;
2227                         RETURN(0);
2228                 }
2229         }
2230
2231         /* just return 0 */
2232         buf->f_type = sb->s_magic;
2233         buf->f_bsize = sb->s_blocksize;
2234         buf->f_blocks = 1;
2235         buf->f_bfree = 0;
2236         buf->f_bavail = 0;
2237         buf->f_files = 1;
2238         buf->f_ffree = 0;
2239         buf->f_namelen = NAME_MAX;
2240         RETURN(0);
2241 }
2242
2243 /** The operations we support directly on the superblock:
2244  * mount, umount, and df.
2245  */
2246 static struct super_operations server_ops =
2247 {
2248         .put_super      = server_put_super,
2249         .umount_begin   = server_umount_begin, /* umount -f */
2250         .statfs         = server_statfs,
2251 };
2252
2253 #define log2(n) ffz(~(n))
2254 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
2255
2256 static int server_fill_super_common(struct super_block *sb)
2257 {
2258         struct inode *root = 0;
2259         ENTRY;
2260
2261         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
2262
2263         sb->s_blocksize = 4096;
2264         sb->s_blocksize_bits = log2(sb->s_blocksize);
2265         sb->s_magic = LUSTRE_SUPER_MAGIC;
2266         sb->s_maxbytes = 0; /* we don't allow file IO on server mountpoints */
2267         sb->s_flags |= MS_RDONLY;
2268         sb->s_op = &server_ops;
2269
2270         root = new_inode(sb);
2271         if (!root) {
2272                 CERROR("Can't make root inode\n");
2273                 RETURN(-EIO);
2274         }
2275
2276         /* returns -EIO for every operation */
2277         /* make_bad_inode(root); -- badness - can't umount */
2278         /* apparently we need to be a directory for the mount to finish */
2279         root->i_mode = S_IFDIR;
2280
2281         sb->s_root = d_make_root(root);
2282         if (!sb->s_root) {
2283                 CERROR("%s: can't make root dentry\n", sb->s_id);
2284                 RETURN(-EIO);
2285         }
2286
2287         RETURN(0);
2288 }
2289
2290 static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags)
2291 {
2292         struct lustre_mount_data *lmd = lsi->lsi_lmd;
2293         struct obd_device        *obd;
2294         struct dt_device_param    p;
2295         char                      flagstr[16];
2296         int                       rc;
2297         ENTRY;
2298
2299         CDEBUG(D_MOUNT,
2300                "Attempting to start %s, type=%s, lsifl=%x, mountfl=%lx\n",
2301                lsi->lsi_svname, lsi->lsi_osd_type, lsi->lsi_flags, mflags);
2302
2303         sprintf(lsi->lsi_osd_obdname, "%s-osd", lsi->lsi_svname);
2304         strcpy(lsi->lsi_osd_uuid, lsi->lsi_osd_obdname);
2305         strcat(lsi->lsi_osd_uuid, "_UUID");
2306         sprintf(flagstr, "%lu:%lu", mflags, (unsigned long) lmd->lmd_flags);
2307
2308         obd = class_name2obd(lsi->lsi_osd_obdname);
2309         if (obd == NULL) {
2310                 rc = lustre_start_simple(lsi->lsi_osd_obdname,
2311                                 lsi->lsi_osd_type,
2312                                 lsi->lsi_osd_uuid, lmd->lmd_dev,
2313                                 flagstr, lsi->lsi_lmd->lmd_opts,
2314                                 lsi->lsi_svname);
2315                 if (rc)
2316                         GOTO(out, rc);
2317                 obd = class_name2obd(lsi->lsi_osd_obdname);
2318                 LASSERT(obd);
2319         }
2320
2321         rc = obd_connect(NULL, &lsi->lsi_osd_exp, obd, &obd->obd_uuid, NULL, NULL);
2322         if (rc) {
2323                 obd->obd_force = 1;
2324                 class_manual_cleanup(obd);
2325                 lsi->lsi_dt_dev = NULL;
2326         }
2327
2328         /* XXX: to keep support old components relying on lsi_srv_mnt
2329          *      we get this info from OSD just started */
2330         LASSERT(obd->obd_lu_dev);
2331         lsi->lsi_dt_dev = lu2dt_dev(obd->obd_lu_dev);
2332         LASSERT(lsi->lsi_dt_dev);
2333
2334         dt_conf_get(NULL, lsi->lsi_dt_dev, &p);
2335
2336         lsi->lsi_srv_mnt = p.ddp_mnt;
2337
2338 out:
2339         RETURN(rc);
2340 }
2341
2342 /** Fill in the superblock info for a Lustre server.
2343  * Mount the device with the correct options.
2344  * Read the on-disk config file.
2345  * Start the services.
2346  */
2347 static int server_fill_super(struct super_block *sb)
2348 {
2349         struct lustre_sb_info *lsi = s2lsi(sb);
2350         int rc;
2351         ENTRY;
2352
2353         rc = lsi_prepare(lsi);
2354         if (rc)
2355                 RETURN(rc);
2356
2357         /* Start low level OSD */
2358         rc = osd_start(lsi, sb->s_flags);
2359         if (rc) {
2360                 CERROR("Unable to start osd on %s: %d\n",
2361                        lsi->lsi_lmd->lmd_dev, rc);
2362                 lustre_put_lsi(sb);
2363                 RETURN(rc);
2364         }
2365
2366         CDEBUG(D_MOUNT, "Found service %s on device %s\n",
2367                lsi->lsi_svname, lsi->lsi_lmd->lmd_dev);
2368
2369         if (class_name2obd(lsi->lsi_svname)) {
2370                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
2371                                    "running. Double-mount may have compromised"
2372                                    " the disk journal.\n",
2373                                    lsi->lsi_svname);
2374                 lustre_put_lsi(sb);
2375                 RETURN(-EALREADY);
2376         }
2377
2378         /* Start MGS before MGC */
2379         if (IS_MGS(lsi) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
2380                 rc = server_start_mgs(sb);
2381                 if (rc)
2382                         GOTO(out_mnt, rc);
2383         }
2384
2385         /* Start MGC before servers */
2386         rc = lustre_start_mgc(sb);
2387         if (rc)
2388                 GOTO(out_mnt, rc);
2389
2390         /* Set up all obd devices for service */
2391         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
2392                         (IS_OST(lsi) || IS_MDT(lsi))) {
2393                 rc = server_start_targets(sb, lsi->lsi_srv_mnt);
2394                 if (rc < 0) {
2395                         CERROR("Unable to start targets: %d\n", rc);
2396                         GOTO(out_mnt, rc);
2397                 }
2398         /* FIXME overmount client here,
2399            or can we just start a client log and client_fill_super on this sb?
2400            We need to make sure server_put_super gets called too - ll_put_super
2401            calls lustre_common_put_super; check there for LSI_SERVER flag,
2402            call s_p_s if so.
2403            Probably should start client from new thread so we can return.
2404            Client will not finish until all servers are connected.
2405            Note - MGS-only server does NOT get a client, since there is no
2406            lustre fs associated - the MGS is for all lustre fs's */
2407         }
2408
2409         rc = server_fill_super_common(sb);
2410         if (rc)
2411                 GOTO(out_mnt, rc);
2412
2413         RETURN(0);
2414 out_mnt:
2415         /* We jump here in case of failure while starting targets or MGS.
2416          * In this case we can't just put @mnt and have to do real cleanup
2417          * with stoping targets, etc. */
2418         server_put_super(sb);
2419         return rc;
2420 }
2421
2422 /*
2423  * Calculate timeout value for a target.
2424  */
2425 void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
2426 {
2427         struct lustre_mount_data *lmd;
2428         int soft = 0;
2429         int hard = 0;
2430         int factor = 0;
2431         bool has_ir = !!(lsi->lsi_flags & LDD_F_IR_CAPABLE);
2432         int min = OBD_RECOVERY_TIME_MIN;
2433
2434         LASSERT(IS_SERVER(lsi));
2435
2436         lmd = lsi->lsi_lmd;
2437         if (lmd) {
2438                 soft   = lmd->lmd_recovery_time_soft;
2439                 hard   = lmd->lmd_recovery_time_hard;
2440                 has_ir = has_ir && !(lmd->lmd_flags & LMD_FLG_NOIR);
2441                 obd->obd_no_ir = !has_ir;
2442         }
2443
2444         if (soft == 0)
2445                 soft = OBD_RECOVERY_TIME_SOFT;
2446         if (hard == 0)
2447                 hard = OBD_RECOVERY_TIME_HARD;
2448
2449         /* target may have ir_factor configured. */
2450         factor = OBD_IR_FACTOR_DEFAULT;
2451         if (obd->obd_recovery_ir_factor)
2452                 factor = obd->obd_recovery_ir_factor;
2453
2454         if (has_ir) {
2455                 int new_soft = soft;
2456                 int new_hard = hard;
2457
2458                 /* adjust timeout value by imperative recovery */
2459
2460                 new_soft = (soft * factor) / OBD_IR_FACTOR_MAX;
2461                 new_hard = (hard * factor) / OBD_IR_FACTOR_MAX;
2462
2463                 /* make sure the timeout is not too short */
2464                 new_soft = max(min, new_soft);
2465                 new_hard = max(new_soft, new_hard);
2466
2467                 LCONSOLE_INFO("%s: Imperative Recovery enabled, recovery "
2468                               "window shrunk from %d-%d down to %d-%d\n",
2469                               obd->obd_name, soft, hard, new_soft, new_hard);
2470
2471                 soft = new_soft;
2472                 hard = new_hard;
2473         }
2474
2475         /* we're done */
2476         obd->obd_recovery_timeout   = max(obd->obd_recovery_timeout, soft);
2477         obd->obd_recovery_time_hard = hard;
2478         obd->obd_recovery_ir_factor = factor;
2479 }
2480 EXPORT_SYMBOL(server_calc_timeout);
2481
2482 /*************** mount common betweeen server and client ***************/
2483
2484 /* Common umount */
2485 int lustre_common_put_super(struct super_block *sb)
2486 {
2487         int rc;
2488         ENTRY;
2489
2490         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
2491
2492         /* Drop a ref to the MGC */
2493         rc = lustre_stop_mgc(sb);
2494         if (rc && (rc != -ENOENT)) {
2495                 if (rc != -EBUSY) {
2496                         CERROR("Can't stop MGC: %d\n", rc);
2497                         RETURN(rc);
2498                 }
2499                 /* BUSY just means that there's some other obd that
2500                    needs the mgc.  Let him clean it up. */
2501                 CDEBUG(D_MOUNT, "MGC still in use\n");
2502         }
2503         /* Drop a ref to the mounted disk */
2504         lustre_put_lsi(sb);
2505         lu_types_stop();
2506         RETURN(rc);
2507 }
2508 EXPORT_SYMBOL(lustre_common_put_super);
2509
2510 static void lmd_print(struct lustre_mount_data *lmd)
2511 {
2512         int i;
2513
2514         PRINT_CMD(PRINT_MASK, "  mount data:\n");
2515         if (lmd_is_client(lmd))
2516                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
2517         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
2518         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
2519
2520         if (lmd->lmd_opts)
2521                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
2522
2523         if (lmd->lmd_recovery_time_soft)
2524                 PRINT_CMD(PRINT_MASK, "recovery time soft: %d\n",
2525                           lmd->lmd_recovery_time_soft);
2526
2527         if (lmd->lmd_recovery_time_hard)
2528                 PRINT_CMD(PRINT_MASK, "recovery time hard: %d\n",
2529                           lmd->lmd_recovery_time_hard);
2530
2531         for (i = 0; i < lmd->lmd_exclude_count; i++) {
2532                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
2533                           lmd->lmd_exclude[i]);
2534         }
2535 }
2536
2537 /* Is this server on the exclusion list */
2538 int lustre_check_exclusion(struct super_block *sb, char *svname)
2539 {
2540         struct lustre_sb_info *lsi = s2lsi(sb);
2541         struct lustre_mount_data *lmd = lsi->lsi_lmd;
2542         __u32 index;
2543         int i, rc;
2544         ENTRY;
2545
2546         rc = server_name2index(svname, &index, NULL);
2547         if (rc != LDD_F_SV_TYPE_OST)
2548                 /* Only exclude OSTs */
2549                 RETURN(0);
2550
2551         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
2552                index, lmd->lmd_exclude_count, lmd->lmd_dev);
2553
2554         for(i = 0; i < lmd->lmd_exclude_count; i++) {
2555                 if (index == lmd->lmd_exclude[i]) {
2556                         CWARN("Excluding %s (on exclusion list)\n", svname);
2557                         RETURN(1);
2558                 }
2559         }
2560         RETURN(0);
2561 }
2562
2563 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
2564 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
2565 {
2566         char *s1 = ptr, *s2;
2567         __u32 index, *exclude_list;
2568         int rc = 0, devmax;
2569         ENTRY;
2570
2571         /* The shortest an ost name can be is 8 chars: -OST0000.
2572            We don't actually know the fsname at this time, so in fact
2573            a user could specify any fsname. */
2574         devmax = strlen(ptr) / 8 + 1;
2575
2576         /* temp storage until we figure out how many we have */
2577         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
2578         if (!exclude_list)
2579                 RETURN(-ENOMEM);
2580
2581         /* we enter this fn pointing at the '=' */
2582         while (*s1 && *s1 != ' ' && *s1 != ',') {
2583                 s1++;
2584                 rc = server_name2index(s1, &index, &s2);
2585                 if (rc < 0) {
2586                         CERROR("Can't parse server name '%s'\n", s1);
2587                         break;
2588                 }
2589                 if (rc == LDD_F_SV_TYPE_OST)
2590                         exclude_list[lmd->lmd_exclude_count++] = index;
2591                 else
2592                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
2593                 s1 = s2;
2594                 /* now we are pointing at ':' (next exclude)
2595                    or ',' (end of excludes) */
2596                 if (lmd->lmd_exclude_count >= devmax)
2597                         break;
2598         }
2599         if (rc >= 0) /* non-err */
2600                 rc = 0;
2601
2602         if (lmd->lmd_exclude_count) {
2603                 /* permanent, freed in lustre_free_lsi */
2604                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
2605                           lmd->lmd_exclude_count);
2606                 if (lmd->lmd_exclude) {
2607                         memcpy(lmd->lmd_exclude, exclude_list,
2608                                sizeof(index) * lmd->lmd_exclude_count);
2609                 } else {
2610                         rc = -ENOMEM;
2611                         lmd->lmd_exclude_count = 0;
2612                 }
2613         }
2614         OBD_FREE(exclude_list, sizeof(index) * devmax);
2615         RETURN(rc);
2616 }
2617
2618 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
2619 {
2620         char   *tail;
2621         int     length;
2622
2623         if (lmd->lmd_mgssec != NULL) {
2624                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
2625                 lmd->lmd_mgssec = NULL;
2626         }
2627
2628         tail = strchr(ptr, ',');
2629         if (tail == NULL)
2630                 length = strlen(ptr);
2631         else
2632                 length = tail - ptr;
2633
2634         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
2635         if (lmd->lmd_mgssec == NULL)
2636                 return -ENOMEM;
2637
2638         memcpy(lmd->lmd_mgssec, ptr, length);
2639         lmd->lmd_mgssec[length] = '\0';
2640         return 0;
2641 }
2642
2643 static int lmd_parse_string(char **handle, char *ptr)
2644 {
2645         char   *tail;
2646         int     length;
2647
2648         if ((handle == NULL) || (ptr == NULL))
2649                 return -EINVAL;
2650
2651         if (*handle != NULL) {
2652                 OBD_FREE(*handle, strlen(*handle) + 1);
2653                 *handle = NULL;
2654         }
2655
2656         tail = strchr(ptr, ',');
2657         if (tail == NULL)
2658                 length = strlen(ptr);
2659         else
2660                 length = tail - ptr;
2661
2662         OBD_ALLOC(*handle, length + 1);
2663         if (*handle == NULL)
2664                 return -ENOMEM;
2665
2666         memcpy(*handle, ptr, length);
2667         (*handle)[length] = '\0';
2668
2669         return 0;
2670 }
2671
2672 /* Collect multiple values for mgsnid specifiers */
2673 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
2674 {
2675         lnet_nid_t nid;
2676         char *tail = *ptr;
2677         char *mgsnid;
2678         int   length;
2679         int   oldlen = 0;
2680
2681         /* Find end of nidlist */
2682         while (class_parse_nid_quiet(tail, &nid, &tail) == 0) {}
2683         length = tail - *ptr;
2684         if (length == 0) {
2685                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
2686                 return -EINVAL;
2687         }
2688
2689         if (lmd->lmd_mgs != NULL)
2690                 oldlen = strlen(lmd->lmd_mgs) + 1;
2691
2692         OBD_ALLOC(mgsnid, oldlen + length + 1);
2693         if (mgsnid == NULL)
2694                 return -ENOMEM;
2695
2696         if (lmd->lmd_mgs != NULL) {
2697                 /* Multiple mgsnid= are taken to mean failover locations */
2698                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
2699                 mgsnid[oldlen - 1] = ':';
2700                 OBD_FREE(lmd->lmd_mgs, oldlen);
2701         }
2702         memcpy(mgsnid + oldlen, *ptr, length);
2703         mgsnid[oldlen + length] = '\0';
2704         lmd->lmd_mgs = mgsnid;
2705         *ptr = tail;
2706
2707         return 0;
2708 }
2709
2710 /** Parse mount line options
2711  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
2712  * dev is passed as device=uml1:/lustre by mount.lustre
2713  */
2714 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
2715 {
2716         char *s1, *s2, *devname = NULL;
2717         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
2718         int rc = 0;
2719         ENTRY;
2720
2721         LASSERT(lmd);
2722         if (!options) {
2723                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
2724                                    "/sbin/mount.lustre is installed.\n");
2725                 RETURN(-EINVAL);
2726         }
2727
2728         /* Options should be a string - try to detect old lmd data */
2729         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
2730                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
2731                                    "/sbin/mount.lustre.  Please install "
2732                                    "version %s\n", LUSTRE_VERSION_STRING);
2733                 RETURN(-EINVAL);
2734         }
2735         lmd->lmd_magic = LMD_MAGIC;
2736
2737         OBD_ALLOC(lmd->lmd_params, 4096);
2738         if (lmd->lmd_params == NULL)
2739                 RETURN(-ENOMEM);
2740         lmd->lmd_params[0] = '\0';
2741
2742         /* Set default flags here */
2743
2744         s1 = options;
2745         while (*s1) {
2746                 int clear = 0;
2747                 int time_min = OBD_RECOVERY_TIME_MIN;
2748
2749                 /* Skip whitespace and extra commas */
2750                 while (*s1 == ' ' || *s1 == ',')
2751                         s1++;
2752
2753                 /* Client options are parsed in ll_options: eg. flock,
2754                    user_xattr, acl */
2755
2756                 /* Parse non-ldiskfs options here. Rather than modifying
2757                    ldiskfs, we just zero these out here */
2758                 if (strncmp(s1, "abort_recov", 11) == 0) {
2759                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
2760                         clear++;
2761                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
2762                         lmd->lmd_recovery_time_soft = max_t(int,
2763                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2764                         clear++;
2765                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
2766                         lmd->lmd_recovery_time_hard = max_t(int,
2767                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2768                         clear++;
2769                 } else if (strncmp(s1, "noir", 4) == 0) {
2770                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
2771                         clear++;
2772                 } else if (strncmp(s1, "nosvc", 5) == 0) {
2773                         lmd->lmd_flags |= LMD_FLG_NOSVC;
2774                         clear++;
2775                 } else if (strncmp(s1, "nomgs", 5) == 0) {
2776                         lmd->lmd_flags |= LMD_FLG_NOMGS;
2777                         clear++;
2778                 } else if (strncmp(s1, "noscrub", 7) == 0) {
2779                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
2780                         clear++;
2781                 } else if (strncmp(s1, PARAM_MGSNODE,
2782                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
2783                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
2784                         /* Assume the next mount opt is the first
2785                            invalid nid we get to. */
2786                         rc = lmd_parse_mgs(lmd, &s2);
2787                         if (rc)
2788                                 goto invalid;
2789                         clear++;
2790                 } else if (strncmp(s1, "writeconf", 9) == 0) {
2791                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
2792                         clear++;
2793                 } else if (strncmp(s1, "virgin", 6) == 0) {
2794                         lmd->lmd_flags |= LMD_FLG_VIRGIN;
2795                         clear++;
2796                 } else if (strncmp(s1, "noprimnode", 10) == 0) {
2797                         lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
2798                         clear++;
2799                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
2800                         rc = lmd_parse_mgssec(lmd, s1 + 7);
2801                         if (rc)
2802                                 goto invalid;
2803                         clear++;
2804                 /* ost exclusion list */
2805                 } else if (strncmp(s1, "exclude=", 8) == 0) {
2806                         rc = lmd_make_exclusion(lmd, s1 + 7);
2807                         if (rc)
2808                                 goto invalid;
2809                         clear++;
2810                 } else if (strncmp(s1, "mgs", 3) == 0) {
2811                         /* We are an MGS */
2812                         lmd->lmd_flags |= LMD_FLG_MGS;
2813                         clear++;
2814                 } else if (strncmp(s1, "svname=", 7) == 0) {
2815                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
2816                         if (rc)
2817                                 goto invalid;
2818                         clear++;
2819                 } else if (strncmp(s1, "param=", 6) == 0) {
2820                         int length;
2821                         char *tail = strchr(s1 + 6, ',');
2822                         if (tail == NULL)
2823                                 length = strlen(s1);
2824                         else
2825                                 length = tail - s1;
2826                         length -= 6;
2827                         strncat(lmd->lmd_params, s1 + 6, length);
2828                         strcat(lmd->lmd_params, " ");
2829                         clear++;
2830                 } else if (strncmp(s1, "osd=", 4) == 0) {
2831                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
2832                         if (rc)
2833                                 goto invalid;
2834                         clear++;
2835                 }
2836                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
2837                    end of the options. */
2838                 else if (strncmp(s1, "device=", 7) == 0) {
2839                         devname = s1 + 7;
2840                         /* terminate options right before device.  device
2841                            must be the last one. */
2842                         *s1 = '\0';
2843                         break;
2844                 }
2845
2846                 /* Find next opt */
2847                 s2 = strchr(s1, ',');
2848                 if (s2 == NULL) {
2849                         if (clear)
2850                                 *s1 = '\0';
2851                         break;
2852                 }
2853                 s2++;
2854                 if (clear)
2855                         memmove(s1, s2, strlen(s2) + 1);
2856                 else
2857                         s1 = s2;
2858         }
2859
2860         if (!devname) {
2861                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
2862                                    "(need mount option 'device=...')\n");
2863                 goto invalid;
2864         }
2865
2866         s1 = strstr(devname, ":/");
2867         if (s1) {
2868                 ++s1;
2869                 lmd->lmd_flags |= LMD_FLG_CLIENT;
2870                 /* Remove leading /s from fsname */
2871                 while (*++s1 == '/') ;
2872                 /* Freed in lustre_free_lsi */
2873                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
2874                 if (!lmd->lmd_profile)
2875                         RETURN(-ENOMEM);
2876                 sprintf(lmd->lmd_profile, "%s-client", s1);
2877         }
2878
2879         /* Freed in lustre_free_lsi */
2880         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
2881         if (!lmd->lmd_dev)
2882                 RETURN(-ENOMEM);
2883         strcpy(lmd->lmd_dev, devname);
2884
2885         /* Save mount options */
2886         s1 = options + strlen(options) - 1;
2887         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
2888                 *s1-- = 0;
2889         if (*options != 0) {
2890                 /* Freed in lustre_free_lsi */
2891                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
2892                 if (!lmd->lmd_opts)
2893                         RETURN(-ENOMEM);
2894                 strcpy(lmd->lmd_opts, options);
2895         }
2896
2897         lmd_print(lmd);
2898         lmd->lmd_magic = LMD_MAGIC;
2899
2900         RETURN(rc);
2901
2902 invalid:
2903         CERROR("Bad mount options %s\n", options);
2904         RETURN(-EINVAL);
2905 }
2906
2907 struct lustre_mount_data2 {
2908         void *lmd2_data;
2909         struct vfsmount *lmd2_mnt;
2910 };
2911
2912 /** This is the entry point for the mount call into Lustre.
2913  * This is called when a server or client is mounted,
2914  * and this is where we start setting things up.
2915  * @param data Mount options (e.g. -o flock,abort_recov)
2916  */
2917 int lustre_fill_super(struct super_block *sb, void *data, int silent)
2918 {
2919         struct lustre_mount_data *lmd;
2920         struct lustre_mount_data2 *lmd2 = data;
2921         struct lustre_sb_info *lsi;
2922         int rc;
2923         ENTRY;
2924
2925         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
2926
2927         lsi = lustre_init_lsi(sb);
2928         if (!lsi)
2929                 RETURN(-ENOMEM);
2930         lmd = lsi->lsi_lmd;
2931
2932         /*
2933          * Disable lockdep during mount, because mount locking patterns are
2934          * `special'.
2935          */
2936         lockdep_off();
2937
2938         /*
2939          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
2940          */
2941         obd_zombie_barrier();
2942
2943         /* Figure out the lmd from the mount options */
2944         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
2945                 lustre_put_lsi(sb);
2946                 GOTO(out, rc = -EINVAL);
2947         }
2948
2949         if (lmd_is_client(lmd)) {
2950                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
2951                 if (!client_fill_super) {
2952                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
2953                                            "client mount! Is the 'lustre' "
2954                                            "module loaded?\n");
2955                         lustre_put_lsi(sb);
2956                         rc = -ENODEV;
2957                 } else {
2958                         rc = lustre_start_mgc(sb);
2959                         if (rc) {
2960                                 lustre_put_lsi(sb);
2961                                 GOTO(out, rc);
2962                         }
2963                         /* Connect and start */
2964                         /* (should always be ll_fill_super) */
2965                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
2966                         /* c_f_s will call lustre_common_put_super on failure */
2967                 }
2968         } else {
2969                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
2970                 rc = server_fill_super(sb);
2971                 /* s_f_s calls lustre_start_mgc after the mount because we need
2972                    the MGS nids which are stored on disk.  Plus, we may
2973                    need to start the MGS first. */
2974                 /* s_f_s will call server_put_super on failure */
2975         }
2976
2977         /* If error happens in fill_super() call, @lsi will be killed there.
2978          * This is why we do not put it here. */
2979         GOTO(out, rc);
2980 out:
2981         if (rc) {
2982                 CERROR("Unable to mount %s (%d)\n",
2983                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
2984         } else {
2985                 CDEBUG(D_SUPER, "Mount %s complete\n",
2986                        lmd->lmd_dev);
2987         }
2988         lockdep_on();
2989         return rc;
2990 }
2991
2992
2993 /* We can't call ll_fill_super by name because it lives in a module that
2994    must be loaded after this one. */
2995 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
2996                                                   struct vfsmount *mnt))
2997 {
2998         client_fill_super = cfs;
2999 }
3000 EXPORT_SYMBOL(lustre_register_client_fill_super);
3001
3002 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
3003 {
3004         kill_super_cb = cfs;
3005 }
3006 EXPORT_SYMBOL(lustre_register_kill_super_cb);
3007
3008 /***************** FS registration ******************/
3009 #ifdef HAVE_FSTYPE_MOUNT
3010 struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
3011                                 const char *devname, void *data)
3012 {
3013         struct lustre_mount_data2 lmd2 = { data, NULL };
3014
3015         return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
3016 }
3017 #else
3018 int lustre_get_sb(struct file_system_type *fs_type, int flags,
3019                   const char *devname, void * data, struct vfsmount *mnt)
3020 {
3021         struct lustre_mount_data2 lmd2 = { data, mnt };
3022
3023         return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
3024 }
3025 #endif
3026
3027 void lustre_kill_super(struct super_block *sb)
3028 {
3029         struct lustre_sb_info *lsi = s2lsi(sb);
3030
3031         if (kill_super_cb && lsi && !IS_SERVER(lsi))
3032                 (*kill_super_cb)(sb);
3033
3034         kill_anon_super(sb);
3035 }
3036
3037 /** Register the "lustre" fs type
3038  */
3039 struct file_system_type lustre_fs_type = {
3040         .owner        = THIS_MODULE,
3041         .name         = "lustre",
3042 #ifdef HAVE_FSTYPE_MOUNT
3043         .mount        = lustre_mount,
3044 #else
3045         .get_sb       = lustre_get_sb,
3046 #endif
3047         .kill_sb      = lustre_kill_super,
3048         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
3049                         FS_HAS_FIEMAP | FS_RENAME_DOES_D_MOVE,
3050 };
3051
3052 int lustre_register_fs(void)
3053 {
3054         return register_filesystem(&lustre_fs_type);
3055 }
3056
3057 int lustre_unregister_fs(void)
3058 {
3059         return unregister_filesystem(&lustre_fs_type);
3060 }
3061
3062 EXPORT_SYMBOL(server_mti_print);