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, Whamcloud, Inc.
  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 CFS_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         cfs_mutex_lock(&lustre_mount_info_lock);
 109
 110         if (server_find_mount(name)) {
 111                 cfs_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         cfs_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         cfs_mutex_lock(&lustre_mount_info_lock);
 136         lmi = server_find_mount(name);
 137         if (!lmi) {
 138                 cfs_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         cfs_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         cfs_mutex_lock(&lustre_mount_info_lock);
 163         lmi = server_find_mount(name);
 164         cfs_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         cfs_mutex_lock(&lustre_mount_info_lock);
 191         lmi = server_find_mount(name);
 192         cfs_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         cfs_mutex_lock(&lustre_mount_info_lock);
 210         lmi = server_find_mount(name);
 211         cfs_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 CFS_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         cfs_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
 686 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 2, 50, 0)
 687         data->ocd_connect_flags |= OBD_CONNECT_MNE_SWAB;
 688 #else
 689 #warning "LU-1644: Remove old OBD_CONNECT_MNE_SWAB fixup and imp_need_mne_swab"
 690 #endif
 691
 692         if (lmd_is_client(lsi->lsi_lmd) &&
 693             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
 694                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
 695         data->ocd_version = LUSTRE_VERSION_CODE;
 696         rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
 697         if (rc) {
 698                 CERROR("connect failed %d\n", rc);
 699                 GOTO(out, rc);
 700         }
 701
 702         obd->u.cli.cl_mgc_mgsexp = exp;
 703
 704 out:
 705         /* Keep the mgc info in the sb. Note that many lsi's can point
 706            to the same mgc.*/
 707         lsi->lsi_mgc = obd;
 708 out_free:
 709         cfs_mutex_unlock(&mgc_start_lock);
 710
 711         if (data)
 712                 OBD_FREE_PTR(data);
 713         if (mgcname)
 714                 OBD_FREE(mgcname, len);
 715         if (niduuid)
 716                 OBD_FREE(niduuid, len + 2);
 717         RETURN(rc);
 718 }
 719
 720 static int lustre_stop_mgc(struct super_block *sb)
 721 {
 722         struct lustre_sb_info *lsi = s2lsi(sb);
 723         struct obd_device *obd;
 724         char *niduuid = 0, *ptr = 0;
 725         int i, rc = 0, len = 0;
 726         ENTRY;
 727
 728         if (!lsi)
 729                 RETURN(-ENOENT);
 730         obd = lsi->lsi_mgc;
 731         if (!obd)
 732                 RETURN(-ENOENT);
 733         lsi->lsi_mgc = NULL;
 734
 735         cfs_mutex_lock(&mgc_start_lock);
 736         LASSERT(cfs_atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
 737         if (!cfs_atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 738                 /* This is not fatal, every client that stops
 739                    will call in here. */
 740                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 741                        cfs_atomic_read(&obd->u.cli.cl_mgc_refcount));
 742                 GOTO(out, rc = -EBUSY);
 743         }
 744
 745         /* The MGC has no recoverable data in any case.
 746          * force shotdown set in umount_begin */
 747         obd->obd_no_recov = 1;
 748
 749         if (obd->u.cli.cl_mgc_mgsexp) {
 750                 /* An error is not fatal, if we are unable to send the
 751                    disconnect mgs ping evictor cleans up the export */
 752                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 753                 if (rc)
 754                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 755         }
 756
 757         /* Save the obdname for cleaning the nid uuids, which are
 758            obdname_XX */
 759         len = strlen(obd->obd_name) + 6;
 760         OBD_ALLOC(niduuid, len);
 761         if (niduuid) {
 762                 strcpy(niduuid, obd->obd_name);
 763                 ptr = niduuid + strlen(niduuid);
 764         }
 765
 766         rc = class_manual_cleanup(obd);
 767         if (rc)
 768                 GOTO(out, rc);
 769
 770         /* Clean the nid uuids */
 771         if (!niduuid)
 772                 GOTO(out, rc = -ENOMEM);
 773
 774         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 775                 sprintf(ptr, "_%x", i);
 776                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 777                              niduuid, 0, 0, 0);
 778                 if (rc)
 779                         CERROR("del MDC UUID %s failed: rc = %d\n",
 780                                niduuid, rc);
 781         }
 782 out:
 783         if (niduuid)
 784                 OBD_FREE(niduuid, len);
 785
 786         /* class_import_put will get rid of the additional connections */
 787         cfs_mutex_unlock(&mgc_start_lock);
 788         RETURN(rc);
 789 }
 790
 791 /* Since there's only one mgc per node, we have to change it's fs to get
 792    access to the right disk. */
 793 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
 794 {
 795         struct lustre_sb_info *lsi = s2lsi(sb);
 796         int rc;
 797         ENTRY;
 798
 799         CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
 800
 801         /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
 802         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 803                                 sizeof(KEY_SET_FS), KEY_SET_FS,
 804                                 sizeof(*sb), sb, NULL);
 805         if (rc) {
 806                 CERROR("can't set_fs %d\n", rc);
 807         }
 808
 809         RETURN(rc);
 810 }
 811
 812 static int server_mgc_clear_fs(struct obd_device *mgc)
 813 {
 814         int rc;
 815         ENTRY;
 816
 817         CDEBUG(D_MOUNT, "Unassign mgc disk\n");
 818
 819         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 820                                 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
 821                                 0, NULL, NULL);
 822         RETURN(rc);
 823 }
 824
 825 CFS_DEFINE_MUTEX(server_start_lock);
 826
 827 /* Stop MDS/OSS if nobody is using them */
 828 static int server_stop_servers(int lsiflags)
 829 {
 830         struct obd_device *obd = NULL;
 831         struct obd_type *type = NULL;
 832         int rc = 0;
 833         ENTRY;
 834
 835         cfs_mutex_lock(&server_start_lock);
 836
 837         /* Either an MDT or an OST or neither  */
 838         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
 839         if ((lsiflags & LDD_F_SV_TYPE_MDT) &&
 840             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
 841                 /*FIXME pre-rename, should eventually be LUSTRE_MDT_NAME*/
 842                 type = class_search_type(LUSTRE_MDS_NAME);
 843         }
 844         /* if this was an OST, and there are no more OST's, clean up the OSS */
 845         if ((lsiflags & LDD_F_SV_TYPE_OST) &&
 846             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
 847                 type = class_search_type(LUSTRE_OST_NAME);
 848         }
 849
 850         if (obd && (!type || !type->typ_refcnt)) {
 851                 int err;
 852                 obd->obd_force = 1;
 853                 /* obd_fail doesn't mean much on a server obd */
 854                 err = class_manual_cleanup(obd);
 855                 if (!rc)
 856                         rc = err;
 857         }
 858
 859         cfs_mutex_unlock(&server_start_lock);
 860
 861         RETURN(rc);
 862 }
 863
 864 int server_mti_print(char *title, struct mgs_target_info *mti)
 865 {
 866         PRINT_CMD(PRINT_MASK, "mti %s\n", title);
 867         PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
 868         PRINT_CMD(PRINT_MASK, "fs:     %s\n", mti->mti_fsname);
 869         PRINT_CMD(PRINT_MASK, "uuid:   %s\n", mti->mti_uuid);
 870         PRINT_CMD(PRINT_MASK, "ver: %d  flags: %#x\n",
 871                   mti->mti_config_ver, mti->mti_flags);
 872         return(0);
 873 }
 874
 875 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
 876  * @param [in] svname server name including type and index
 877  * @param [out] fsname Buffer to copy filesystem name prefix into.
 878  *  Must have at least 'strlen(fsname) + 1' chars.
 879  * @param [out] endptr if endptr isn't NULL it is set to end of fsname
 880  * rc < 0  on error
 881  */
 882 static int server_name2fsname(char *svname, char *fsname, char **endptr)
 883 {
 884         char *p;
 885
 886         p = strstr(svname, "-OST");
 887         if (p == NULL)
 888                 p = strstr(svname, "-MDT");
 889         if (p == NULL)
 890                 return -1;
 891
 892         if (fsname) {
 893                 strncpy(fsname, svname, p - svname);
 894                 fsname[p - svname] = '\0';
 895         }
 896
 897         if (endptr != NULL)
 898                 *endptr = p;
 899
 900         return 0;
 901 }
 902
 903 /**
 904  * Get service name (svname) from string
 905  * rc < 0 on error
 906  * if endptr isn't NULL it is set to end of fsname *
 907  */
 908 int server_name2svname(char *label, char *svname, char **endptr)
 909 {
 910         int rc;
 911         char *dash;
 912
 913         /* We use server_name2fsname() just for parsing */
 914         rc = server_name2fsname(label, NULL, &dash);
 915         if (rc != 0)
 916                 return rc;
 917
 918         if (*dash != '-')
 919                 return -1;
 920
 921         strncpy(svname, dash + 1, MTI_NAME_MAXLEN);
 922
 923         return 0;
 924 }
 925 EXPORT_SYMBOL(server_name2svname);
 926
 927
 928 /* Get the index from the obd name.
 929    rc = server type, or
 930    rc < 0  on error
 931    if endptr isn't NULL it is set to end of name */
 932 int server_name2index(char *svname, __u32 *idx, char **endptr)
 933 {
 934         unsigned long index;
 935         int rc;
 936         char *dash;
 937
 938         /* We use server_name2fsname() just for parsing */
 939         rc = server_name2fsname(svname, NULL, &dash);
 940         if (rc != 0)
 941                 return rc;
 942
 943         if (*dash != '-')
 944                 return -EINVAL;
 945
 946         dash++;
 947
 948         if (strncmp(dash, "MDT", 3) == 0)
 949                 rc = LDD_F_SV_TYPE_MDT;
 950         else if (strncmp(dash, "OST", 3) == 0)
 951                 rc = LDD_F_SV_TYPE_OST;
 952         else
 953                 return -EINVAL;
 954
 955         dash += 3;
 956
 957         if (strcmp(dash, "all") == 0)
 958                 return rc | LDD_F_SV_ALL;
 959
 960         index = simple_strtoul(dash, endptr, 16);
 961         *idx = index;
 962
 963         return rc;
 964 }
 965 EXPORT_SYMBOL(server_name2index);
 966
 967 /* Generate data for registration */
 968 static int server_lsi2mti(struct lustre_sb_info *lsi,
 969                           struct mgs_target_info *mti)
 970 {
 971         lnet_process_id_t id;
 972         int rc, i = 0;
 973         ENTRY;
 974
 975         if (!IS_SERVER(lsi))
 976                 RETURN(-EINVAL);
 977
 978         strncpy(mti->mti_svname, lsi->lsi_svname, sizeof(mti->mti_svname));
 979
 980         mti->mti_nid_count = 0;
 981         while (LNetGetId(i++, &id) != -ENOENT) {
 982                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 983                         continue;
 984
 985                 /* server use --servicenode param, only allow specified
 986                  * nids be registered */
 987                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) != 0 &&
 988                     class_match_nid(lsi->lsi_lmd->lmd_params,
 989                                     PARAM_FAILNODE, id.nid) < 1)
 990                         continue;
 991
 992                 /* match specified network */
 993                 if (!class_match_net(lsi->lsi_lmd->lmd_params,
 994                                      PARAM_NETWORK, LNET_NIDNET(id.nid)))
 995                         continue;
 996
 997                 mti->mti_nids[mti->mti_nid_count] = id.nid;
 998                 mti->mti_nid_count++;
 999                 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
1000                         CWARN("Only using first %d nids for %s\n",
1001                               mti->mti_nid_count, mti->mti_svname);
1002                         break;
1003                 }
1004         }
1005
1006         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
1007         mti->mti_config_ver = 0;
1008
1009         rc = server_name2fsname(lsi->lsi_svname, mti->mti_fsname, NULL);
1010         if (rc != 0)
1011                 return rc;
1012
1013         rc = server_name2index(lsi->lsi_svname, &mti->mti_stripe_index, NULL);
1014         if (rc < 0)
1015                 return rc;
1016         /* Orion requires index to be set */
1017         LASSERT(!(rc & LDD_F_NEED_INDEX));
1018         /* keep only LDD flags */
1019         mti->mti_flags = lsi->lsi_flags & LDD_F_MASK;
1020         mti->mti_flags |= LDD_F_UPDATE;
1021         strncpy(mti->mti_params, lsi->lsi_lmd->lmd_params,
1022                 sizeof(mti->mti_params));
1023         return 0;
1024 }
1025
1026 /* Register an old or new target with the MGS. If needed MGS will construct
1027    startup logs and assign index */
1028 static int server_register_target(struct lustre_sb_info *lsi)
1029 {
1030         struct obd_device *mgc = lsi->lsi_mgc;
1031         struct mgs_target_info *mti = NULL;
1032         bool writeconf;
1033         int rc;
1034         ENTRY;
1035
1036         LASSERT(mgc);
1037
1038         if (!IS_SERVER(lsi))
1039                 RETURN(-EINVAL);
1040
1041         OBD_ALLOC_PTR(mti);
1042         if (!mti)
1043                 RETURN(-ENOMEM);
1044
1045         rc = server_lsi2mti(lsi, mti);
1046         if (rc)
1047                 GOTO(out, rc);
1048
1049         CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
1050                mti->mti_svname, mti->mti_fsname,
1051                libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
1052                mti->mti_flags);
1053
1054         /* if write_conf is true, the registration must succeed */
1055         writeconf = !!(lsi->lsi_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE));
1056         mti->mti_flags |= LDD_F_OPC_REG;
1057
1058         /* Register the target */
1059         /* FIXME use mgc_process_config instead */
1060         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1061                                 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1062                                 sizeof(*mti), mti, NULL);
1063         if (rc) {
1064                 if (mti->mti_flags & LDD_F_ERROR) {
1065                         LCONSOLE_ERROR_MSG(0x160,
1066                                 "The MGS is refusing to allow this "
1067                                 "server (%s) to start. Please see messages"
1068                                 " on the MGS node.\n", lsi->lsi_svname);
1069                 } else if (writeconf) {
1070                         LCONSOLE_ERROR_MSG(0x15f,
1071                                 "Communication to the MGS return error %d. "
1072                                 "Is the MGS running?\n", rc);
1073                 } else {
1074                         CERROR("Cannot talk to the MGS: %d, not fatal\n", rc);
1075                         /* reset the error code for non-fatal error. */
1076                         rc = 0;
1077                 }
1078                 GOTO(out, rc);
1079         }
1080
1081 out:
1082         if (mti)
1083                 OBD_FREE_PTR(mti);
1084         RETURN(rc);
1085 }
1086
1087 /**
1088  * Notify the MGS that this target is ready.
1089  * Used by IR - if the MGS receives this message, it will notify clients.
1090  */
1091 static int server_notify_target(struct super_block *sb, struct obd_device *obd)
1092 {
1093         struct lustre_sb_info *lsi = s2lsi(sb);
1094         struct obd_device *mgc = lsi->lsi_mgc;
1095         struct mgs_target_info *mti = NULL;
1096         int rc;
1097         ENTRY;
1098
1099         LASSERT(mgc);
1100
1101         if (!(IS_SERVER(lsi)))
1102                 RETURN(-EINVAL);
1103
1104         OBD_ALLOC_PTR(mti);
1105         if (!mti)
1106                 RETURN(-ENOMEM);
1107         rc = server_lsi2mti(lsi, mti);
1108         if (rc)
1109                 GOTO(out, rc);
1110
1111         mti->mti_instance = obd->u.obt.obt_instance;
1112         mti->mti_flags |= LDD_F_OPC_READY;
1113
1114         /* FIXME use mgc_process_config instead */
1115         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1116                                 sizeof(KEY_REGISTER_TARGET),
1117                                 KEY_REGISTER_TARGET,
1118                                 sizeof(*mti), mti, NULL);
1119
1120         /* Imperative recovery: if the mgs informs us to use IR? */
1121         if (!rc && !(mti->mti_flags & LDD_F_ERROR) &&
1122             (mti->mti_flags & LDD_F_IR_CAPABLE))
1123                 lsi->lsi_flags |= LDD_F_IR_CAPABLE;
1124
1125 out:
1126         if (mti)
1127                 OBD_FREE_PTR(mti);
1128         RETURN(rc);
1129
1130 }
1131
1132 /** Start server targets: MDTs and OSTs
1133  */
1134 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1135 {
1136         struct obd_device *obd;
1137         struct lustre_sb_info *lsi = s2lsi(sb);
1138         struct config_llog_instance cfg;
1139         struct lu_env env;
1140         struct lu_device *dev;
1141         int rc;
1142         ENTRY;
1143
1144         CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_svname);
1145
1146 #if 0
1147         /* If we're an MDT, make sure the global MDS is running */
1148         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_MDT) {
1149                 /* make sure the MDS is started */
1150                 cfs_mutex_lock(&server_start_lock);
1151                 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1152                 if (!obd) {
1153                         rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1154                     /* FIXME pre-rename, should eventually be LUSTRE_MDS_NAME */
1155                                                  LUSTRE_MDT_NAME,
1156                                                  LUSTRE_MDS_OBDNAME"_uuid",
1157                                                  0, 0);
1158                         if (rc) {
1159                                 cfs_mutex_unlock(&server_start_lock);
1160                                 CERROR("failed to start MDS: %d\n", rc);
1161                                 RETURN(rc);
1162                         }
1163                 }
1164                 cfs_mutex_unlock(&server_start_lock);
1165         }
1166 #endif
1167
1168         /* If we're an OST, make sure the global OSS is running */
1169         if (IS_OST(lsi)) {
1170                 /* make sure OSS is started */
1171                 cfs_mutex_lock(&server_start_lock);
1172                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1173                 if (!obd) {
1174                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1175                                                  LUSTRE_OSS_NAME,
1176                                                  LUSTRE_OSS_OBDNAME"_uuid",
1177                                                  0, 0, 0, 0);
1178                         if (rc) {
1179                                 cfs_mutex_unlock(&server_start_lock);
1180                                 CERROR("failed to start OSS: %d\n", rc);
1181                                 RETURN(rc);
1182                         }
1183                 }
1184                 cfs_mutex_unlock(&server_start_lock);
1185         }
1186
1187         /* Set the mgc fs to our server disk.  This allows the MGC to
1188          * read and write configs locally, in case it can't talk to the MGS. */
1189         if (lsi->lsi_srv_mnt) {
1190                 rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1191                 if (rc)
1192                         RETURN(rc);
1193         }
1194
1195         /* Register with MGS */
1196         rc = server_register_target(lsi);
1197         if (rc)
1198                 GOTO(out_mgc, rc);
1199
1200         /* Let the target look up the mount using the target's name
1201            (we can't pass the sb or mnt through class_process_config.) */
1202         rc = server_register_mount(lsi->lsi_svname, sb, mnt);
1203         if (rc)
1204                 GOTO(out_mgc, rc);
1205
1206         /* Start targets using the llog named for the target */
1207         memset(&cfg, 0, sizeof(cfg));
1208         rc = lustre_process_log(sb, lsi->lsi_svname, &cfg);
1209         if (rc) {
1210                 CERROR("failed to start server %s: %d\n",
1211                        lsi->lsi_svname, rc);
1212                 /* Do NOT call server_deregister_mount() here. This makes it
1213                  * impossible to find mount later in cleanup time and leaves
1214                  * @lsi and othder stuff leaked. -umka */
1215                 GOTO(out_mgc, rc);
1216         }
1217
1218 out_mgc:
1219         /* Release the mgc fs for others to use */
1220         if (lsi->lsi_srv_mnt)
1221                 server_mgc_clear_fs(lsi->lsi_mgc);
1222
1223         if (!rc) {
1224                 obd = class_name2obd(lsi->lsi_svname);
1225                 if (!obd) {
1226                         CERROR("no server named %s was started\n",
1227                                lsi->lsi_svname);
1228                         RETURN(-ENXIO);
1229                 }
1230
1231                 server_notify_target(sb, obd);
1232
1233                 /* calculate recovery timeout, do it after lustre_process_log */
1234                 server_calc_timeout(lsi, obd);
1235
1236                 /* log has been fully processed */
1237                 obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1238
1239                 /* log has been fully processed, let clients connect */
1240                 dev = obd->obd_lu_dev;
1241                 if (dev && dev->ld_ops->ldo_prepare) {
1242                         rc = lu_env_init(&env, dev->ld_type->ldt_ctx_tags);
1243                         if (rc == 0) {
1244                                 struct lu_context  session_ctx;
1245
1246                                 lu_context_init(&session_ctx, LCT_SESSION);
1247                                 session_ctx.lc_thread = NULL;
1248                                 lu_context_enter(&session_ctx);
1249                                 env.le_ses = &session_ctx;
1250
1251                                 dev->ld_ops->ldo_prepare(&env, NULL, dev);
1252
1253                                 lu_env_fini(&env);
1254                                 lu_context_exit(&session_ctx);
1255                                 lu_context_fini(&session_ctx);
1256                         }
1257                 }
1258
1259                 /* abort recovery only on the complete stack:
1260                  * many devices can be involved */
1261                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1262                     (OBP(obd, iocontrol))) {
1263                         obd_iocontrol(OBD_IOC_ABORT_RECOVERY,
1264                                       obd->obd_self_export, 0, NULL, NULL);
1265                 }
1266         }
1267
1268         RETURN(rc);
1269 }
1270
1271 /***************** lustre superblock **************/
1272
1273 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1274 {
1275         struct lustre_sb_info *lsi;
1276         ENTRY;
1277
1278         OBD_ALLOC_PTR(lsi);
1279         if (!lsi)
1280                 RETURN(NULL);
1281         OBD_ALLOC_PTR(lsi->lsi_lmd);
1282         if (!lsi->lsi_lmd) {
1283                 OBD_FREE_PTR(lsi);
1284                 RETURN(NULL);
1285         }
1286
1287         lsi->lsi_lmd->lmd_exclude_count = 0;
1288         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
1289         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
1290         s2lsi_nocast(sb) = lsi;
1291         /* we take 1 extra ref for our setup */
1292         cfs_atomic_set(&lsi->lsi_mounts, 1);
1293
1294         /* Default umount style */
1295         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1296
1297         RETURN(lsi);
1298 }
1299
1300 static int lustre_free_lsi(struct super_block *sb)
1301 {
1302         struct lustre_sb_info *lsi = s2lsi(sb);
1303         ENTRY;
1304
1305         LASSERT(lsi != NULL);
1306         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
1307
1308         /* someone didn't call server_put_mount. */
1309         LASSERT(cfs_atomic_read(&lsi->lsi_mounts) == 0);
1310
1311         if (lsi->lsi_lmd != NULL) {
1312                 if (lsi->lsi_lmd->lmd_dev != NULL)
1313                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
1314                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
1315                 if (lsi->lsi_lmd->lmd_profile != NULL)
1316                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
1317                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
1318                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
1319                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
1320                                  strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
1321                 if (lsi->lsi_lmd->lmd_opts != NULL)
1322                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
1323                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
1324                 if (lsi->lsi_lmd->lmd_exclude_count)
1325                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1326                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1327                                  lsi->lsi_lmd->lmd_exclude_count);
1328                 if (lsi->lsi_lmd->lmd_mgs != NULL)
1329                         OBD_FREE(lsi->lsi_lmd->lmd_mgs,
1330                                  strlen(lsi->lsi_lmd->lmd_mgs) + 1);
1331                 if (lsi->lsi_lmd->lmd_osd_type != NULL)
1332                         OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
1333                                  strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
1334                 if (lsi->lsi_lmd->lmd_params != NULL)
1335                         OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
1336
1337                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1338         }
1339
1340         LASSERT(lsi->lsi_llsbi == NULL);
1341         OBD_FREE(lsi, sizeof(*lsi));
1342         s2lsi_nocast(sb) = NULL;
1343
1344         RETURN(0);
1345 }
1346
1347 /* The lsi has one reference for every server that is using the disk -
1348    e.g. MDT, MGS, and potentially MGC */
1349 static int lustre_put_lsi(struct super_block *sb)
1350 {
1351         struct lustre_sb_info *lsi = s2lsi(sb);
1352         ENTRY;
1353
1354         LASSERT(lsi != NULL);
1355
1356         CDEBUG(D_MOUNT, "put %p %d\n", sb, cfs_atomic_read(&lsi->lsi_mounts));
1357         if (cfs_atomic_dec_and_test(&lsi->lsi_mounts)) {
1358                 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
1359                         obd_disconnect(lsi->lsi_osd_exp);
1360                         /* wait till OSD is gone */
1361                         obd_zombie_barrier();
1362                 }
1363                 lustre_free_lsi(sb);
1364                 RETURN(1);
1365         }
1366         RETURN(0);
1367 }
1368
1369 static int lsi_prepare(struct lustre_sb_info *lsi)
1370 {
1371         __u32 index;
1372         int rc;
1373         ENTRY;
1374
1375         LASSERT(lsi);
1376         LASSERT(lsi->lsi_lmd);
1377
1378         /* The server name is given as a mount line option */
1379         if (lsi->lsi_lmd->lmd_profile == NULL) {
1380                 LCONSOLE_ERROR("Can't determine server name\n");
1381                 RETURN(-EINVAL);
1382         }
1383
1384         if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname))
1385                 RETURN(-ENAMETOOLONG);
1386
1387         strcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile);
1388
1389         /* Determine osd type */
1390         if (lsi->lsi_lmd->lmd_osd_type != NULL) {
1391                 if (strlen(lsi->lsi_lmd->lmd_osd_type) >=
1392                            sizeof(lsi->lsi_osd_type))
1393                         RETURN(-ENAMETOOLONG);
1394
1395                 strcpy(lsi->lsi_osd_type, lsi->lsi_lmd->lmd_osd_type);
1396         } else {
1397                 strcpy(lsi->lsi_osd_type, LUSTRE_OSD_LDISKFS_NAME);
1398         }
1399
1400         /* XXX: a temp. solution for components using fsfilt
1401          *      to be removed in one of the subsequent patches */
1402         if (!strcmp(lsi->lsi_lmd->lmd_osd_type, "osd-ldiskfs")) {
1403                 strcpy(lsi->lsi_fstype, "ldiskfs");
1404         } else {
1405                 strcpy(lsi->lsi_fstype, lsi->lsi_lmd->lmd_osd_type);
1406         }
1407
1408         /* Determine server type */
1409         rc = server_name2index(lsi->lsi_svname, &index, NULL);
1410         if (rc < 0) {
1411                 if (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) {
1412                         /* Assume we're a bare MGS */
1413                         rc = 0;
1414                         lsi->lsi_lmd->lmd_flags |= LMD_FLG_NOSVC;
1415                 } else {
1416                         LCONSOLE_ERROR("Can't determine server type of '%s'\n",
1417                                        lsi->lsi_svname);
1418                         RETURN(rc);
1419                 }
1420         }
1421         lsi->lsi_flags |= rc;
1422
1423         /* Add mount line flags that used to be in ldd:
1424          * writeconf, mgs, iam, anything else?
1425          */
1426         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_WRITECONF) ?
1427                 LDD_F_WRITECONF : 0;
1428         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_VIRGIN) ?
1429                 LDD_F_VIRGIN : 0;
1430         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) ?
1431                 LDD_F_SV_TYPE_MGS : 0;
1432         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_IAM) ?
1433                 LDD_F_IAM_DIR : 0;
1434         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) ?
1435                 LDD_F_NO_PRIMNODE : 0;
1436
1437         RETURN(0);
1438 }
1439
1440 /*************** server mount ******************/
1441
1442 /** Start the shutdown of servers at umount.
1443  */
1444 static void server_put_super(struct super_block *sb)
1445 {
1446         struct lustre_sb_info *lsi = s2lsi(sb);
1447         struct obd_device     *obd;
1448         char *tmpname, *extraname = NULL;
1449         int tmpname_sz;
1450         int lsiflags = lsi->lsi_flags;
1451         ENTRY;
1452
1453         LASSERT(IS_SERVER(lsi));
1454
1455         tmpname_sz = strlen(lsi->lsi_svname) + 1;
1456         OBD_ALLOC(tmpname, tmpname_sz);
1457         memcpy(tmpname, lsi->lsi_svname, tmpname_sz);
1458         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
1459         if (IS_MDT(lsi) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
1460                 snprintf(tmpname, tmpname_sz, "MGS");
1461
1462         /* Stop the target */
1463         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1464             (IS_MDT(lsi) || IS_OST(lsi))) {
1465                 struct lustre_profile *lprof = NULL;
1466
1467                 /* tell the mgc to drop the config log */
1468                 lustre_end_log(sb, lsi->lsi_svname, NULL);
1469
1470                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
1471                    If there are any setup/cleanup errors, save the lov
1472                    name for safety cleanup later. */
1473                 lprof = class_get_profile(lsi->lsi_svname);
1474                 if (lprof && lprof->lp_dt) {
1475                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
1476                         strcpy(extraname, lprof->lp_dt);
1477                 }
1478
1479                 obd = class_name2obd(lsi->lsi_svname);
1480                 if (obd) {
1481                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
1482                         if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
1483                                 obd->obd_fail = 1;
1484                         /* We can't seem to give an error return code
1485                          * to .put_super, so we better make sure we clean up! */
1486                         obd->obd_force = 1;
1487                         class_manual_cleanup(obd);
1488                 } else {
1489                         CERROR("no obd %s\n", lsi->lsi_svname);
1490                         server_deregister_mount(lsi->lsi_svname);
1491                 }
1492         }
1493
1494         /* If they wanted the mgs to stop separately from the mdt, they
1495            should have put it on a different device. */
1496         if (IS_MGS(lsi)) {
1497                 /* if MDS start with --nomgs, don't stop MGS then */
1498                 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
1499                         server_stop_mgs(sb);
1500         }
1501
1502         /* Clean the mgc and sb */
1503         lustre_common_put_super(sb);
1504
1505         /* wait till all in-progress cleanups are done
1506          * specifically we're interested in ofd cleanup
1507          * as it pins OSS */
1508         obd_zombie_barrier();
1509
1510         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
1511            until the target is really gone so that our type refcount check
1512            is right. */
1513         server_stop_servers(lsiflags);
1514
1515         /* In case of startup or cleanup err, stop related obds */
1516         if (extraname) {
1517                 obd = class_name2obd(extraname);
1518                 if (obd) {
1519                         CWARN("Cleaning orphaned obd %s\n", extraname);
1520                         obd->obd_force = 1;
1521                         class_manual_cleanup(obd);
1522                 }
1523                 OBD_FREE(extraname, strlen(extraname) + 1);
1524         }
1525
1526         LCONSOLE_WARN("server umount %s complete\n", tmpname);
1527         OBD_FREE(tmpname, tmpname_sz);
1528         EXIT;
1529 }
1530
1531 /** Called only for 'umount -f'
1532  */
1533 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1534 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
1535 {
1536         struct super_block *sb = vfsmnt->mnt_sb;
1537 #else
1538 static void server_umount_begin(struct super_block *sb)
1539 {
1540 #endif
1541         struct lustre_sb_info *lsi = s2lsi(sb);
1542         ENTRY;
1543
1544 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1545         if (!(flags & MNT_FORCE)) {
1546                 EXIT;
1547                 return;
1548         }
1549 #endif
1550
1551         CDEBUG(D_MOUNT, "umount -f\n");
1552         /* umount = failover
1553            umount -f = force
1554            no third way to do non-force, non-failover */
1555         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
1556         EXIT;
1557 }
1558
1559 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
1560 {
1561         struct super_block *sb = dentry->d_sb;
1562         struct lustre_sb_info *lsi = s2lsi(sb);
1563         struct obd_statfs statfs;
1564         int rc;
1565         ENTRY;
1566
1567         if (lsi->lsi_dt_dev) {
1568                 rc = dt_statfs(NULL, lsi->lsi_dt_dev, &statfs);
1569                 if (rc == 0) {
1570                         statfs_unpack(buf, &statfs);
1571                         buf->f_type = sb->s_magic;
1572                         RETURN(0);
1573                 }
1574         }
1575
1576         /* just return 0 */
1577         buf->f_type = sb->s_magic;
1578         buf->f_bsize = sb->s_blocksize;
1579         buf->f_blocks = 1;
1580         buf->f_bfree = 0;
1581         buf->f_bavail = 0;
1582         buf->f_files = 1;
1583         buf->f_ffree = 0;
1584         buf->f_namelen = NAME_MAX;
1585         RETURN(0);
1586 }
1587
1588 /** The operations we support directly on the superblock:
1589  * mount, umount, and df.
1590  */
1591 static struct super_operations server_ops =
1592 {
1593         .put_super      = server_put_super,
1594         .umount_begin   = server_umount_begin, /* umount -f */
1595         .statfs         = server_statfs,
1596 };
1597
1598 #define log2(n) cfs_ffz(~(n))
1599 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
1600
1601 static int server_fill_super_common(struct super_block *sb)
1602 {
1603         struct inode *root = 0;
1604         ENTRY;
1605
1606         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
1607
1608         sb->s_blocksize = 4096;
1609         sb->s_blocksize_bits = log2(sb->s_blocksize);
1610         sb->s_magic = LUSTRE_SUPER_MAGIC;
1611         sb->s_maxbytes = 0; /* we don't allow file IO on server mountpoints */
1612         sb->s_flags |= MS_RDONLY;
1613         sb->s_op = &server_ops;
1614
1615         root = new_inode(sb);
1616         if (!root) {
1617                 CERROR("Can't make root inode\n");
1618                 RETURN(-EIO);
1619         }
1620
1621         /* returns -EIO for every operation */
1622         /* make_bad_inode(root); -- badness - can't umount */
1623         /* apparently we need to be a directory for the mount to finish */
1624         root->i_mode = S_IFDIR;
1625
1626         sb->s_root = d_alloc_root(root);
1627         if (!sb->s_root) {
1628                 CERROR("Can't make root dentry\n");
1629                 iput(root);
1630                 RETURN(-EIO);
1631         }
1632
1633         RETURN(0);
1634 }
1635
1636 static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags)
1637 {
1638         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1639         struct obd_device        *obd;
1640         struct dt_device_param    p;
1641         char                      flagstr[16];
1642         int                       rc;
1643         ENTRY;
1644
1645         CDEBUG(D_MOUNT,
1646                "Attempting to start %s, type=%s, lsifl=%x, mountfl=%lx\n",
1647                lsi->lsi_svname, lsi->lsi_osd_type, lsi->lsi_flags, mflags);
1648
1649         sprintf(lsi->lsi_osd_obdname, "%s-osd", lsi->lsi_svname);
1650         strcpy(lsi->lsi_osd_uuid, lsi->lsi_osd_obdname);
1651         strcat(lsi->lsi_osd_uuid, "_UUID");
1652         sprintf(flagstr, "%lu:%lu", mflags, (unsigned long) lmd->lmd_flags);
1653
1654         obd = class_name2obd(lsi->lsi_osd_obdname);
1655         if (obd == NULL) {
1656                 rc = lustre_start_simple(lsi->lsi_osd_obdname,
1657                                 lsi->lsi_osd_type,
1658                                 lsi->lsi_osd_uuid, lmd->lmd_dev,
1659                                 flagstr, lsi->lsi_lmd->lmd_opts,
1660                                 lsi->lsi_svname);
1661                 if (rc)
1662                         GOTO(out, rc);
1663                 obd = class_name2obd(lsi->lsi_osd_obdname);
1664                 LASSERT(obd);
1665         }
1666
1667         rc = obd_connect(NULL, &lsi->lsi_osd_exp, obd, &obd->obd_uuid, NULL, NULL);
1668         if (rc) {
1669                 obd->obd_force = 1;
1670                 class_manual_cleanup(obd);
1671                 lsi->lsi_dt_dev = NULL;
1672         }
1673
1674         /* XXX: to keep support old components relying on lsi_srv_mnt
1675          *      we get this info from OSD just started */
1676         LASSERT(obd->obd_lu_dev);
1677         lsi->lsi_dt_dev = lu2dt_dev(obd->obd_lu_dev);
1678         LASSERT(lsi->lsi_dt_dev);
1679
1680         dt_conf_get(NULL, lsi->lsi_dt_dev, &p);
1681
1682         lsi->lsi_srv_mnt = p.ddp_mnt;
1683
1684 out:
1685         RETURN(rc);
1686 }
1687
1688 /** Fill in the superblock info for a Lustre server.
1689  * Mount the device with the correct options.
1690  * Read the on-disk config file.
1691  * Start the services.
1692  */
1693 static int server_fill_super(struct super_block *sb)
1694 {
1695         struct lustre_sb_info *lsi = s2lsi(sb);
1696         int rc;
1697         ENTRY;
1698
1699         rc = lsi_prepare(lsi);
1700         if (rc)
1701                 RETURN(rc);
1702
1703         /* Start low level OSD */
1704         rc = osd_start(lsi, sb->s_flags);
1705         if (rc) {
1706                 CERROR("Unable to start osd on %s: %d\n",
1707                        lsi->lsi_lmd->lmd_dev, rc);
1708                 lustre_put_lsi(sb);
1709                 RETURN(rc);
1710         }
1711
1712         CDEBUG(D_MOUNT, "Found service %s on device %s\n",
1713                lsi->lsi_svname, lsi->lsi_lmd->lmd_dev);
1714
1715         if (class_name2obd(lsi->lsi_svname)) {
1716                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
1717                                    "running. Double-mount may have compromised"
1718                                    " the disk journal.\n",
1719                                    lsi->lsi_svname);
1720                 lustre_put_lsi(sb);
1721                 RETURN(-EALREADY);
1722         }
1723
1724         /* Start MGS before MGC */
1725         if (IS_MGS(lsi) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
1726                 rc = server_start_mgs(sb);
1727                 if (rc)
1728                         GOTO(out_mnt, rc);
1729         }
1730
1731         /* Start MGC before servers */
1732         rc = lustre_start_mgc(sb);
1733         if (rc)
1734                 GOTO(out_mnt, rc);
1735
1736         /* Set up all obd devices for service */
1737         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1738                         (IS_OST(lsi) || IS_MDT(lsi))) {
1739                 rc = server_start_targets(sb, lsi->lsi_srv_mnt);
1740                 if (rc < 0) {
1741                         CERROR("Unable to start targets: %d\n", rc);
1742                         GOTO(out_mnt, rc);
1743                 }
1744         /* FIXME overmount client here,
1745            or can we just start a client log and client_fill_super on this sb?
1746            We need to make sure server_put_super gets called too - ll_put_super
1747            calls lustre_common_put_super; check there for LSI_SERVER flag,
1748            call s_p_s if so.
1749            Probably should start client from new thread so we can return.
1750            Client will not finish until all servers are connected.
1751            Note - MGS-only server does NOT get a client, since there is no
1752            lustre fs associated - the MGS is for all lustre fs's */
1753         }
1754
1755         rc = server_fill_super_common(sb);
1756         if (rc)
1757                 GOTO(out_mnt, rc);
1758
1759         RETURN(0);
1760 out_mnt:
1761         /* We jump here in case of failure while starting targets or MGS.
1762          * In this case we can't just put @mnt and have to do real cleanup
1763          * with stoping targets, etc. */
1764         server_put_super(sb);
1765         return rc;
1766 }
1767
1768 /*
1769  * Calculate timeout value for a target.
1770  */
1771 void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
1772 {
1773         struct lustre_mount_data *lmd;
1774         int soft = 0;
1775         int hard = 0;
1776         int factor = 0;
1777         bool has_ir = !!(lsi->lsi_flags & LDD_F_IR_CAPABLE);
1778         int min = OBD_RECOVERY_TIME_MIN;
1779
1780         LASSERT(IS_SERVER(lsi));
1781
1782         lmd = lsi->lsi_lmd;
1783         if (lmd) {
1784                 soft   = lmd->lmd_recovery_time_soft;
1785                 hard   = lmd->lmd_recovery_time_hard;
1786                 has_ir = has_ir && !(lmd->lmd_flags & LMD_FLG_NOIR);
1787                 obd->obd_no_ir = !has_ir;
1788         }
1789
1790         if (soft == 0)
1791                 soft = OBD_RECOVERY_TIME_SOFT;
1792         if (hard == 0)
1793                 hard = OBD_RECOVERY_TIME_HARD;
1794
1795         /* target may have ir_factor configured. */
1796         factor = OBD_IR_FACTOR_DEFAULT;
1797         if (obd->obd_recovery_ir_factor)
1798                 factor = obd->obd_recovery_ir_factor;
1799
1800         if (has_ir) {
1801                 int new_soft = soft;
1802                 int new_hard = hard;
1803
1804                 /* adjust timeout value by imperative recovery */
1805
1806                 new_soft = (soft * factor) / OBD_IR_FACTOR_MAX;
1807                 new_hard = (hard * factor) / OBD_IR_FACTOR_MAX;
1808
1809                 /* make sure the timeout is not too short */
1810                 new_soft = max(min, new_soft);
1811                 new_hard = max(new_soft, new_hard);
1812
1813                 LCONSOLE_INFO("%s: Imperative Recovery enabled, recovery "
1814                               "window shrunk from %d-%d down to %d-%d\n",
1815                               obd->obd_name, soft, hard, new_soft, new_hard);
1816
1817                 soft = new_soft;
1818                 hard = new_hard;
1819         }
1820
1821         /* we're done */
1822         obd->obd_recovery_timeout   = max(obd->obd_recovery_timeout, soft);
1823         obd->obd_recovery_time_hard = hard;
1824         obd->obd_recovery_ir_factor = factor;
1825 }
1826 EXPORT_SYMBOL(server_calc_timeout);
1827
1828 /*************** mount common betweeen server and client ***************/
1829
1830 /* Common umount */
1831 int lustre_common_put_super(struct super_block *sb)
1832 {
1833         int rc;
1834         ENTRY;
1835
1836         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
1837
1838         /* Drop a ref to the MGC */
1839         rc = lustre_stop_mgc(sb);
1840         if (rc && (rc != -ENOENT)) {
1841                 if (rc != -EBUSY) {
1842                         CERROR("Can't stop MGC: %d\n", rc);
1843                         RETURN(rc);
1844                 }
1845                 /* BUSY just means that there's some other obd that
1846                    needs the mgc.  Let him clean it up. */
1847                 CDEBUG(D_MOUNT, "MGC still in use\n");
1848         }
1849         /* Drop a ref to the mounted disk */
1850         lustre_put_lsi(sb);
1851         lu_types_stop();
1852         RETURN(rc);
1853 }
1854 EXPORT_SYMBOL(lustre_common_put_super);
1855
1856 static void lmd_print(struct lustre_mount_data *lmd)
1857 {
1858         int i;
1859
1860         PRINT_CMD(PRINT_MASK, "  mount data:\n");
1861         if (lmd_is_client(lmd))
1862                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
1863         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
1864         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
1865
1866         if (lmd->lmd_opts)
1867                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
1868
1869         if (lmd->lmd_recovery_time_soft)
1870                 PRINT_CMD(PRINT_MASK, "recovery time soft: %d\n",
1871                           lmd->lmd_recovery_time_soft);
1872
1873         if (lmd->lmd_recovery_time_hard)
1874                 PRINT_CMD(PRINT_MASK, "recovery time hard: %d\n",
1875                           lmd->lmd_recovery_time_hard);
1876
1877         for (i = 0; i < lmd->lmd_exclude_count; i++) {
1878                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
1879                           lmd->lmd_exclude[i]);
1880         }
1881 }
1882
1883 /* Is this server on the exclusion list */
1884 int lustre_check_exclusion(struct super_block *sb, char *svname)
1885 {
1886         struct lustre_sb_info *lsi = s2lsi(sb);
1887         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1888         __u32 index;
1889         int i, rc;
1890         ENTRY;
1891
1892         rc = server_name2index(svname, &index, NULL);
1893         if (rc != LDD_F_SV_TYPE_OST)
1894                 /* Only exclude OSTs */
1895                 RETURN(0);
1896
1897         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
1898                index, lmd->lmd_exclude_count, lmd->lmd_dev);
1899
1900         for(i = 0; i < lmd->lmd_exclude_count; i++) {
1901                 if (index == lmd->lmd_exclude[i]) {
1902                         CWARN("Excluding %s (on exclusion list)\n", svname);
1903                         RETURN(1);
1904                 }
1905         }
1906         RETURN(0);
1907 }
1908
1909 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
1910 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
1911 {
1912         char *s1 = ptr, *s2;
1913         __u32 index, *exclude_list;
1914         int rc = 0, devmax;
1915         ENTRY;
1916
1917         /* The shortest an ost name can be is 8 chars: -OST0000.
1918            We don't actually know the fsname at this time, so in fact
1919            a user could specify any fsname. */
1920         devmax = strlen(ptr) / 8 + 1;
1921
1922         /* temp storage until we figure out how many we have */
1923         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
1924         if (!exclude_list)
1925                 RETURN(-ENOMEM);
1926
1927         /* we enter this fn pointing at the '=' */
1928         while (*s1 && *s1 != ' ' && *s1 != ',') {
1929                 s1++;
1930                 rc = server_name2index(s1, &index, &s2);
1931                 if (rc < 0) {
1932                         CERROR("Can't parse server name '%s'\n", s1);
1933                         break;
1934                 }
1935                 if (rc == LDD_F_SV_TYPE_OST)
1936                         exclude_list[lmd->lmd_exclude_count++] = index;
1937                 else
1938                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
1939                 s1 = s2;
1940                 /* now we are pointing at ':' (next exclude)
1941                    or ',' (end of excludes) */
1942                 if (lmd->lmd_exclude_count >= devmax)
1943                         break;
1944         }
1945         if (rc >= 0) /* non-err */
1946                 rc = 0;
1947
1948         if (lmd->lmd_exclude_count) {
1949                 /* permanent, freed in lustre_free_lsi */
1950                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
1951                           lmd->lmd_exclude_count);
1952                 if (lmd->lmd_exclude) {
1953                         memcpy(lmd->lmd_exclude, exclude_list,
1954                                sizeof(index) * lmd->lmd_exclude_count);
1955                 } else {
1956                         rc = -ENOMEM;
1957                         lmd->lmd_exclude_count = 0;
1958                 }
1959         }
1960         OBD_FREE(exclude_list, sizeof(index) * devmax);
1961         RETURN(rc);
1962 }
1963
1964 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
1965 {
1966         char   *tail;
1967         int     length;
1968
1969         if (lmd->lmd_mgssec != NULL) {
1970                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
1971                 lmd->lmd_mgssec = NULL;
1972         }
1973
1974         tail = strchr(ptr, ',');
1975         if (tail == NULL)
1976                 length = strlen(ptr);
1977         else
1978                 length = tail - ptr;
1979
1980         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
1981         if (lmd->lmd_mgssec == NULL)
1982                 return -ENOMEM;
1983
1984         memcpy(lmd->lmd_mgssec, ptr, length);
1985         lmd->lmd_mgssec[length] = '\0';
1986         return 0;
1987 }
1988
1989 static int lmd_parse_string(char **handle, char *ptr)
1990 {
1991         char   *tail;
1992         int     length;
1993
1994         if ((handle == NULL) || (ptr == NULL))
1995                 return -EINVAL;
1996
1997         if (*handle != NULL) {
1998                 OBD_FREE(*handle, strlen(*handle) + 1);
1999                 *handle = NULL;
2000         }
2001
2002         tail = strchr(ptr, ',');
2003         if (tail == NULL)
2004                 length = strlen(ptr);
2005         else
2006                 length = tail - ptr;
2007
2008         OBD_ALLOC(*handle, length + 1);
2009         if (*handle == NULL)
2010                 return -ENOMEM;
2011
2012         memcpy(*handle, ptr, length);
2013         (*handle)[length] = '\0';
2014
2015         return 0;
2016 }
2017
2018 /* Collect multiple values for mgsnid specifiers */
2019 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
2020 {
2021         lnet_nid_t nid;
2022         char *tail = *ptr;
2023         char *mgsnid;
2024         int   length;
2025         int   oldlen = 0;
2026
2027         /* Find end of nidlist */
2028         while (class_parse_nid_quiet(tail, &nid, &tail) == 0) {}
2029         length = tail - *ptr;
2030         if (length == 0) {
2031                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
2032                 return -EINVAL;
2033         }
2034
2035         if (lmd->lmd_mgs != NULL)
2036                 oldlen = strlen(lmd->lmd_mgs) + 1;
2037
2038         OBD_ALLOC(mgsnid, oldlen + length + 1);
2039         if (mgsnid == NULL)
2040                 return -ENOMEM;
2041
2042         if (lmd->lmd_mgs != NULL) {
2043                 /* Multiple mgsnid= are taken to mean failover locations */
2044                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
2045                 mgsnid[oldlen - 1] = ':';
2046                 OBD_FREE(lmd->lmd_mgs, oldlen);
2047         }
2048         memcpy(mgsnid + oldlen, *ptr, length);
2049         mgsnid[oldlen + length] = '\0';
2050         lmd->lmd_mgs = mgsnid;
2051         *ptr = tail;
2052
2053         return 0;
2054 }
2055
2056 /** Parse mount line options
2057  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
2058  * dev is passed as device=uml1:/lustre by mount.lustre
2059  */
2060 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
2061 {
2062         char *s1, *s2, *devname = NULL;
2063         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
2064         int rc = 0;
2065         ENTRY;
2066
2067         LASSERT(lmd);
2068         if (!options) {
2069                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
2070                                    "/sbin/mount.lustre is installed.\n");
2071                 RETURN(-EINVAL);
2072         }
2073
2074         /* Options should be a string - try to detect old lmd data */
2075         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
2076                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
2077                                    "/sbin/mount.lustre.  Please install "
2078                                    "version %s\n", LUSTRE_VERSION_STRING);
2079                 RETURN(-EINVAL);
2080         }
2081         lmd->lmd_magic = LMD_MAGIC;
2082
2083         OBD_ALLOC(lmd->lmd_params, 4096);
2084         if (lmd->lmd_params == NULL)
2085                 RETURN(-ENOMEM);
2086         lmd->lmd_params[0] = '\0';
2087
2088         /* Set default flags here */
2089
2090         s1 = options;
2091         while (*s1) {
2092                 int clear = 0;
2093                 int time_min = OBD_RECOVERY_TIME_MIN;
2094
2095                 /* Skip whitespace and extra commas */
2096                 while (*s1 == ' ' || *s1 == ',')
2097                         s1++;
2098
2099                 /* Client options are parsed in ll_options: eg. flock,
2100                    user_xattr, acl */
2101
2102                 /* Parse non-ldiskfs options here. Rather than modifying
2103                    ldiskfs, we just zero these out here */
2104                 if (strncmp(s1, "abort_recov", 11) == 0) {
2105                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
2106                         clear++;
2107                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
2108                         lmd->lmd_recovery_time_soft = max_t(int,
2109                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2110                         clear++;
2111                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
2112                         lmd->lmd_recovery_time_hard = max_t(int,
2113                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2114                         clear++;
2115                 } else if (strncmp(s1, "noir", 4) == 0) {
2116                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
2117                         clear++;
2118                 } else if (strncmp(s1, "nosvc", 5) == 0) {
2119                         lmd->lmd_flags |= LMD_FLG_NOSVC;
2120                         clear++;
2121                 } else if (strncmp(s1, "nomgs", 5) == 0) {
2122                         lmd->lmd_flags |= LMD_FLG_NOMGS;
2123                         clear++;
2124                 } else if (strncmp(s1, "noscrub", 7) == 0) {
2125                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
2126                         clear++;
2127                 } else if (strncmp(s1, PARAM_MGSNODE,
2128                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
2129                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
2130                         /* Assume the next mount opt is the first
2131                            invalid nid we get to. */
2132                         rc = lmd_parse_mgs(lmd, &s2);
2133                         if (rc)
2134                                 goto invalid;
2135                         clear++;
2136                 } else if (strncmp(s1, "writeconf", 9) == 0) {
2137                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
2138                         clear++;
2139                 } else if (strncmp(s1, "virgin", 6) == 0) {
2140                         lmd->lmd_flags |= LMD_FLG_VIRGIN;
2141                         clear++;
2142                 } else if (strncmp(s1, "noprimnode", 10) == 0) {
2143                         lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
2144                         clear++;
2145                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
2146                         rc = lmd_parse_mgssec(lmd, s1 + 7);
2147                         if (rc)
2148                                 goto invalid;
2149                         clear++;
2150                 /* ost exclusion list */
2151                 } else if (strncmp(s1, "exclude=", 8) == 0) {
2152                         rc = lmd_make_exclusion(lmd, s1 + 7);
2153                         if (rc)
2154                                 goto invalid;
2155                         clear++;
2156                 } else if (strncmp(s1, "mgs", 3) == 0) {
2157                         /* We are an MGS */
2158                         lmd->lmd_flags |= LMD_FLG_MGS;
2159                         clear++;
2160                 } else if (strncmp(s1, "svname=", 7) == 0) {
2161                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
2162                         if (rc)
2163                                 goto invalid;
2164                         clear++;
2165                 } else if (strncmp(s1, "param=", 6) == 0) {
2166                         int length;
2167                         char *tail = strchr(s1 + 6, ',');
2168                         if (tail == NULL)
2169                                 length = strlen(s1);
2170                         else
2171                                 length = tail - s1;
2172                         length -= 6;
2173                         strncat(lmd->lmd_params, s1 + 6, length);
2174                         strcat(lmd->lmd_params, " ");
2175                         clear++;
2176                 } else if (strncmp(s1, "osd=", 4) == 0) {
2177                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
2178                         if (rc)
2179                                 goto invalid;
2180                         clear++;
2181                 }
2182                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
2183                    end of the options. */
2184                 else if (strncmp(s1, "device=", 7) == 0) {
2185                         devname = s1 + 7;
2186                         /* terminate options right before device.  device
2187                            must be the last one. */
2188                         *s1 = '\0';
2189                         break;
2190                 }
2191
2192                 /* Find next opt */
2193                 s2 = strchr(s1, ',');
2194                 if (s2 == NULL) {
2195                         if (clear)
2196                                 *s1 = '\0';
2197                         break;
2198                 }
2199                 s2++;
2200                 if (clear)
2201                         memmove(s1, s2, strlen(s2) + 1);
2202                 else
2203                         s1 = s2;
2204         }
2205
2206         if (!devname) {
2207                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
2208                                    "(need mount option 'device=...')\n");
2209                 goto invalid;
2210         }
2211
2212         s1 = strstr(devname, ":/");
2213         if (s1) {
2214                 ++s1;
2215                 lmd->lmd_flags |= LMD_FLG_CLIENT;
2216                 /* Remove leading /s from fsname */
2217                 while (*++s1 == '/') ;
2218                 /* Freed in lustre_free_lsi */
2219                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
2220                 if (!lmd->lmd_profile)
2221                         RETURN(-ENOMEM);
2222                 sprintf(lmd->lmd_profile, "%s-client", s1);
2223         }
2224
2225         /* Freed in lustre_free_lsi */
2226         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
2227         if (!lmd->lmd_dev)
2228                 RETURN(-ENOMEM);
2229         strcpy(lmd->lmd_dev, devname);
2230
2231         /* Save mount options */
2232         s1 = options + strlen(options) - 1;
2233         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
2234                 *s1-- = 0;
2235         if (*options != 0) {
2236                 /* Freed in lustre_free_lsi */
2237                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
2238                 if (!lmd->lmd_opts)
2239                         RETURN(-ENOMEM);
2240                 strcpy(lmd->lmd_opts, options);
2241         }
2242
2243         lmd_print(lmd);
2244         lmd->lmd_magic = LMD_MAGIC;
2245
2246         RETURN(rc);
2247
2248 invalid:
2249         CERROR("Bad mount options %s\n", options);
2250         RETURN(-EINVAL);
2251 }
2252
2253 struct lustre_mount_data2 {
2254         void *lmd2_data;
2255         struct vfsmount *lmd2_mnt;
2256 };
2257
2258 /** This is the entry point for the mount call into Lustre.
2259  * This is called when a server or client is mounted,
2260  * and this is where we start setting things up.
2261  * @param data Mount options (e.g. -o flock,abort_recov)
2262  */
2263 int lustre_fill_super(struct super_block *sb, void *data, int silent)
2264 {
2265         struct lustre_mount_data *lmd;
2266         struct lustre_mount_data2 *lmd2 = data;
2267         struct lustre_sb_info *lsi;
2268         int rc;
2269         ENTRY;
2270
2271         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
2272
2273         lsi = lustre_init_lsi(sb);
2274         if (!lsi)
2275                 RETURN(-ENOMEM);
2276         lmd = lsi->lsi_lmd;
2277
2278         /*
2279          * Disable lockdep during mount, because mount locking patterns are
2280          * `special'.
2281          */
2282         cfs_lockdep_off();
2283
2284         /*
2285          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
2286          */
2287         obd_zombie_barrier();
2288
2289         /* Figure out the lmd from the mount options */
2290         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
2291                 lustre_put_lsi(sb);
2292                 GOTO(out, rc = -EINVAL);
2293         }
2294
2295         if (lmd_is_client(lmd)) {
2296                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
2297                 if (!client_fill_super) {
2298                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
2299                                            "client mount! Is the 'lustre' "
2300                                            "module loaded?\n");
2301                         lustre_put_lsi(sb);
2302                         rc = -ENODEV;
2303                 } else {
2304                         rc = lustre_start_mgc(sb);
2305                         if (rc) {
2306                                 lustre_put_lsi(sb);
2307                                 GOTO(out, rc);
2308                         }
2309                         /* Connect and start */
2310                         /* (should always be ll_fill_super) */
2311                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
2312                         /* c_f_s will call lustre_common_put_super on failure */
2313                 }
2314         } else {
2315                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
2316                 rc = server_fill_super(sb);
2317                 /* s_f_s calls lustre_start_mgc after the mount because we need
2318                    the MGS nids which are stored on disk.  Plus, we may
2319                    need to start the MGS first. */
2320                 /* s_f_s will call server_put_super on failure */
2321         }
2322
2323         /* If error happens in fill_super() call, @lsi will be killed there.
2324          * This is why we do not put it here. */
2325         GOTO(out, rc);
2326 out:
2327         if (rc) {
2328                 CERROR("Unable to mount %s (%d)\n",
2329                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
2330         } else {
2331                 CDEBUG(D_SUPER, "Mount %s complete\n",
2332                        lmd->lmd_dev);
2333         }
2334         cfs_lockdep_on();
2335         return rc;
2336 }
2337
2338
2339 /* We can't call ll_fill_super by name because it lives in a module that
2340    must be loaded after this one. */
2341 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
2342                                                   struct vfsmount *mnt))
2343 {
2344         client_fill_super = cfs;
2345 }
2346 EXPORT_SYMBOL(lustre_register_client_fill_super);
2347
2348 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
2349 {
2350         kill_super_cb = cfs;
2351 }
2352 EXPORT_SYMBOL(lustre_register_kill_super_cb);
2353
2354 /***************** FS registration ******************/
2355 #ifdef HAVE_FSTYPE_MOUNT
2356 struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
2357                                 const char *devname, void *data)
2358 {
2359         struct lustre_mount_data2 lmd2 = { data, NULL };
2360
2361         return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
2362 }
2363 #else
2364 int lustre_get_sb(struct file_system_type *fs_type, int flags,
2365                   const char *devname, void * data, struct vfsmount *mnt)
2366 {
2367         struct lustre_mount_data2 lmd2 = { data, mnt };
2368
2369         return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
2370 }
2371 #endif
2372
2373 void lustre_kill_super(struct super_block *sb)
2374 {
2375         struct lustre_sb_info *lsi = s2lsi(sb);
2376
2377         if (kill_super_cb && lsi && !IS_SERVER(lsi))
2378                 (*kill_super_cb)(sb);
2379
2380         kill_anon_super(sb);
2381 }
2382
2383 /** Register the "lustre" fs type
2384  */
2385 struct file_system_type lustre_fs_type = {
2386         .owner        = THIS_MODULE,
2387         .name         = "lustre",
2388 #ifdef HAVE_FSTYPE_MOUNT
2389         .mount        = lustre_mount,
2390 #else
2391         .get_sb       = lustre_get_sb,
2392 #endif
2393         .kill_sb      = lustre_kill_super,
2394         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
2395 #ifdef FS_HAS_FIEMAP
2396                         FS_HAS_FIEMAP |
2397 #endif
2398                         LL_RENAME_DOES_D_MOVE,
2399 };
2400
2401 int lustre_register_fs(void)
2402 {
2403         return register_filesystem(&lustre_fs_type);
2404 }
2405
2406 int lustre_unregister_fs(void)
2407 {
2408         return unregister_filesystem(&lustre_fs_type);
2409 }
2410
2411 EXPORT_SYMBOL(server_mti_print);