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, vfscount=%d\n",
 125                lmi->lmi_mnt, name,
 126                lmi->lmi_mnt ? mnt_get_count(lmi->lmi_mnt) : -1);
 127
 128         RETURN(0);
 129 }
 130
 131 /* when an obd no longer needs a mount */
 132 static int server_deregister_mount(const char *name)
 133 {
 134         struct lustre_mount_info *lmi;
 135         ENTRY;
 136
 137         cfs_mutex_lock(&lustre_mount_info_lock);
 138         lmi = server_find_mount(name);
 139         if (!lmi) {
 140                 cfs_mutex_unlock(&lustre_mount_info_lock);
 141                 CERROR("%s not registered\n", name);
 142                 RETURN(-ENOENT);
 143         }
 144
 145         CDEBUG(D_MOUNT, "dereg_mnt %p from %s, vfscount=%d\n",
 146                lmi->lmi_mnt, name,
 147                lmi->lmi_mnt ? mnt_get_count(lmi->lmi_mnt) : -1);
 148
 149         OBD_FREE(lmi->lmi_name, strlen(lmi->lmi_name) + 1);
 150         cfs_list_del(&lmi->lmi_list_chain);
 151         OBD_FREE(lmi, sizeof(*lmi));
 152         cfs_mutex_unlock(&lustre_mount_info_lock);
 153
 154         RETURN(0);
 155 }
 156
 157 /* obd's look up a registered mount using their obdname. This is just
 158    for initial obd setup to find the mount struct.  It should not be
 159    called every time you want to mntget. */
 160 struct lustre_mount_info *server_get_mount(const char *name)
 161 {
 162         struct lustre_mount_info *lmi;
 163         struct lustre_sb_info *lsi;
 164         ENTRY;
 165
 166         cfs_mutex_lock(&lustre_mount_info_lock);
 167         lmi = server_find_mount(name);
 168         cfs_mutex_unlock(&lustre_mount_info_lock);
 169         if (!lmi) {
 170                 CERROR("Can't find mount for %s\n", name);
 171                 RETURN(NULL);
 172         }
 173         lsi = s2lsi(lmi->lmi_sb);
 174
 175         cfs_atomic_inc(&lsi->lsi_mounts);
 176
 177         CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d, vfscount=%d\n",
 178                lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts),
 179                lmi->lmi_mnt ? mnt_get_count(lmi->lmi_mnt) - 1 : -1);
 180
 181         RETURN(lmi);
 182 }
 183 EXPORT_SYMBOL(server_get_mount);
 184
 185 /*
 186  * Used by mdt to get mount_info from obdname.
 187  * There are no blocking when using the mount_info.
 188  * Do not use server_get_mount for this purpose.
 189  */
 190 struct lustre_mount_info *server_get_mount_2(const char *name)
 191 {
 192         struct lustre_mount_info *lmi;
 193         ENTRY;
 194
 195         cfs_mutex_lock(&lustre_mount_info_lock);
 196         lmi = server_find_mount(name);
 197         cfs_mutex_unlock(&lustre_mount_info_lock);
 198         if (!lmi)
 199                 CERROR("Can't find mount for %s\n", name);
 200
 201         RETURN(lmi);
 202 }
 203 EXPORT_SYMBOL(server_get_mount_2);
 204
 205 static int lustre_put_lsi(struct super_block *sb);
 206
 207 /* to be called from obd_cleanup methods */
 208 int server_put_mount(const char *name, struct vfsmount *mnt)
 209 {
 210         struct lustre_mount_info *lmi;
 211         struct lustre_sb_info *lsi;
 212         int count = 0;
 213         ENTRY;
 214
 215         cfs_mutex_lock(&lustre_mount_info_lock);
 216         lmi = server_find_mount(name);
 217         cfs_mutex_unlock(&lustre_mount_info_lock);
 218         if (!lmi) {
 219                 CERROR("Can't find mount for %s\n", name);
 220                 RETURN(-ENOENT);
 221         }
 222         lsi = s2lsi(lmi->lmi_sb);
 223
 224         CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d, vfscount=%d\n",
 225                lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts), count);
 226
 227         if (lustre_put_lsi(lmi->lmi_sb)) {
 228                 CDEBUG(D_MOUNT, "Last put of mnt %p from %s, vfscount=%d\n",
 229                        lmi->lmi_mnt, name, count);
 230                 /* last mount is the One True Mount */
 231                 if (count > 1)
 232                         CERROR("%s: mount busy, vfscount=%d!\n", name, count);
 233         }
 234
 235         /* this obd should never need the mount again */
 236         server_deregister_mount(name);
 237
 238         RETURN(0);
 239 }
 240 EXPORT_SYMBOL(server_put_mount);
 241
 242 /* Corresponding to server_get_mount_2 */
 243 int server_put_mount_2(const char *name, struct vfsmount *mnt)
 244 {
 245         ENTRY;
 246         RETURN(0);
 247 }
 248 EXPORT_SYMBOL(server_put_mount_2);
 249
 250 /**************** config llog ********************/
 251
 252 /** Get a config log from the MGS and process it.
 253  * This func is called for both clients and servers.
 254  * Continue to process new statements appended to the logs
 255  * (whenever the config lock is revoked) until lustre_end_log
 256  * is called.
 257  * @param sb The superblock is used by the MGC to write to the local copy of
 258  *   the config log
 259  * @param logname The name of the llog to replicate from the MGS
 260  * @param cfg Since the same mgc may be used to follow multiple config logs
 261  *   (e.g. ost1, ost2, client), the config_llog_instance keeps the state for
 262  *   this log, and is added to the mgc's list of logs to follow.
 263  */
 264 int lustre_process_log(struct super_block *sb, char *logname,
 265                      struct config_llog_instance *cfg)
 266 {
 267         struct lustre_cfg *lcfg;
 268         struct lustre_cfg_bufs *bufs;
 269         struct lustre_sb_info *lsi = s2lsi(sb);
 270         struct obd_device *mgc = lsi->lsi_mgc;
 271         int rc;
 272         ENTRY;
 273
 274         LASSERT(mgc);
 275         LASSERT(cfg);
 276
 277         OBD_ALLOC_PTR(bufs);
 278         if (bufs == NULL)
 279                 RETURN(-ENOMEM);
 280
 281         /* mgc_process_config */
 282         lustre_cfg_bufs_reset(bufs, mgc->obd_name);
 283         lustre_cfg_bufs_set_string(bufs, 1, logname);
 284         lustre_cfg_bufs_set(bufs, 2, cfg, sizeof(*cfg));
 285         lustre_cfg_bufs_set(bufs, 3, &sb, sizeof(sb));
 286         lcfg = lustre_cfg_new(LCFG_LOG_START, bufs);
 287         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 288         lustre_cfg_free(lcfg);
 289
 290         OBD_FREE_PTR(bufs);
 291
 292         if (rc == -EINVAL)
 293                 LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
 294                                    "failed from the MGS (%d).  Make sure this "
 295                                    "client and the MGS are running compatible "
 296                                    "versions of Lustre.\n",
 297                                    mgc->obd_name, logname, rc);
 298
 299         if (rc)
 300                 LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
 301                                    "failed (%d). This may be the result of "
 302                                    "communication errors between this node and "
 303                                    "the MGS, a bad configuration, or other "
 304                                    "errors. See the syslog for more "
 305                                    "information.\n", mgc->obd_name, logname,
 306                                    rc);
 307
 308         /* class_obd_list(); */
 309         RETURN(rc);
 310 }
 311 EXPORT_SYMBOL(lustre_process_log);
 312
 313 /* Stop watching this config log for updates */
 314 int lustre_end_log(struct super_block *sb, char *logname,
 315                        struct config_llog_instance *cfg)
 316 {
 317         struct lustre_cfg *lcfg;
 318         struct lustre_cfg_bufs bufs;
 319         struct lustre_sb_info *lsi = s2lsi(sb);
 320         struct obd_device *mgc = lsi->lsi_mgc;
 321         int rc;
 322         ENTRY;
 323
 324         if (!mgc)
 325                 RETURN(-ENOENT);
 326
 327         /* mgc_process_config */
 328         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
 329         lustre_cfg_bufs_set_string(&bufs, 1, logname);
 330         if (cfg)
 331                 lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
 332         lcfg = lustre_cfg_new(LCFG_LOG_END, &bufs);
 333         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 334         lustre_cfg_free(lcfg);
 335         RETURN(rc);
 336 }
 337 EXPORT_SYMBOL(lustre_end_log);
 338
 339 /**************** obd start *******************/
 340
 341 /** lustre_cfg_bufs are a holdover from 1.4; we can still set these up from
 342  * lctl (and do for echo cli/srv.
 343  */
 344 int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
 345             char *s1, char *s2, char *s3, char *s4)
 346 {
 347         struct lustre_cfg_bufs bufs;
 348         struct lustre_cfg    * lcfg = NULL;
 349         int rc;
 350
 351         CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
 352                cmd, s1, s2, s3, s4);
 353
 354         lustre_cfg_bufs_reset(&bufs, cfgname);
 355         if (s1)
 356                 lustre_cfg_bufs_set_string(&bufs, 1, s1);
 357         if (s2)
 358                 lustre_cfg_bufs_set_string(&bufs, 2, s2);
 359         if (s3)
 360                 lustre_cfg_bufs_set_string(&bufs, 3, s3);
 361         if (s4)
 362                 lustre_cfg_bufs_set_string(&bufs, 4, s4);
 363
 364         lcfg = lustre_cfg_new(cmd, &bufs);
 365         lcfg->lcfg_nid = nid;
 366         rc = class_process_config(lcfg);
 367         lustre_cfg_free(lcfg);
 368         return(rc);
 369 }
 370 EXPORT_SYMBOL(do_lcfg);
 371
 372 /** Call class_attach and class_setup.  These methods in turn call
 373  * obd type-specific methods.
 374  */
 375 static int lustre_start_simple(char *obdname, char *type, char *uuid,
 376                                char *s1, char *s2, char *s3, char *s4)
 377 {
 378         int rc;
 379         CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
 380
 381         rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, 0, 0);
 382         if (rc) {
 383                 CERROR("%s attach error %d\n", obdname, rc);
 384                 return(rc);
 385         }
 386         rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, s3, s4);
 387         if (rc) {
 388                 CERROR("%s setup error %d\n", obdname, rc);
 389                 do_lcfg(obdname, 0, LCFG_DETACH, 0, 0, 0, 0);
 390         }
 391         return rc;
 392 }
 393
 394 /* Set up a MGS to serve startup logs */
 395 static int server_start_mgs(struct super_block *sb)
 396 {
 397         struct lustre_sb_info    *lsi = s2lsi(sb);
 398         struct vfsmount          *mnt = lsi->lsi_srv_mnt;
 399         struct lustre_mount_info *lmi;
 400         int    rc = 0;
 401         ENTRY;
 402         LASSERT(mnt);
 403
 404         /* It is impossible to have more than 1 MGS per node, since
 405            MGC wouldn't know which to connect to */
 406         lmi = server_find_mount(LUSTRE_MGS_OBDNAME);
 407         if (lmi) {
 408                 lsi = s2lsi(lmi->lmi_sb);
 409                 LCONSOLE_ERROR_MSG(0x15d, "The MGS service was already started"
 410                                    " from server\n");
 411                 RETURN(-EALREADY);
 412         }
 413
 414         CDEBUG(D_CONFIG, "Start MGS service %s\n", LUSTRE_MGS_OBDNAME);
 415
 416         rc = server_register_mount(LUSTRE_MGS_OBDNAME, sb, mnt);
 417
 418         if (!rc) {
 419                 rc = lustre_start_simple(LUSTRE_MGS_OBDNAME, LUSTRE_MGS_NAME,
 420                                          LUSTRE_MGS_OBDNAME, 0, 0, 0, 0);
 421                 /* Do NOT call server_deregister_mount() here. This leads to
 422                  * inability cleanup cleanly and free lsi and other stuff when
 423                  * mgs calls server_put_mount() in error handling case. -umka */
 424         }
 425
 426         if (rc)
 427                 LCONSOLE_ERROR_MSG(0x15e, "Failed to start MGS '%s' (%d). "
 428                                    "Is the 'mgs' module loaded?\n",
 429                                    LUSTRE_MGS_OBDNAME, rc);
 430         RETURN(rc);
 431 }
 432
 433 static int server_stop_mgs(struct super_block *sb)
 434 {
 435         struct obd_device *obd;
 436         int rc;
 437         ENTRY;
 438
 439         CDEBUG(D_MOUNT, "Stop MGS service %s\n", LUSTRE_MGS_OBDNAME);
 440
 441         /* There better be only one MGS */
 442         obd = class_name2obd(LUSTRE_MGS_OBDNAME);
 443         if (!obd) {
 444                 CDEBUG(D_CONFIG, "mgs %s not running\n", LUSTRE_MGS_OBDNAME);
 445                 RETURN(-EALREADY);
 446         }
 447
 448         /* The MGS should always stop when we say so */
 449         obd->obd_force = 1;
 450         rc = class_manual_cleanup(obd);
 451         RETURN(rc);
 452 }
 453
 454 CFS_DEFINE_MUTEX(mgc_start_lock);
 455
 456 /** Set up a mgc obd to process startup logs
 457  *
 458  * \param sb [in] super block of the mgc obd
 459  *
 460  * \retval 0 success, otherwise error code
 461  */
 462 static int lustre_start_mgc(struct super_block *sb)
 463 {
 464         struct obd_connect_data *data = NULL;
 465         struct lustre_sb_info *lsi = s2lsi(sb);
 466         struct obd_device *obd;
 467         struct obd_export *exp;
 468         struct obd_uuid *uuid;
 469         class_uuid_t uuidc;
 470         lnet_nid_t nid;
 471         char *mgcname = NULL, *niduuid = NULL, *mgssec = NULL;
 472         char *ptr;
 473         int recov_bk;
 474         int rc = 0, i = 0, j, len;
 475         ENTRY;
 476
 477         LASSERT(lsi->lsi_lmd);
 478
 479         /* Find the first non-lo MGS nid for our MGC name */
 480         if (IS_SERVER(lsi)) {
 481                 /* mount -o mgsnode=nid */
 482                 ptr = lsi->lsi_lmd->lmd_mgs;
 483                 if (lsi->lsi_lmd->lmd_mgs &&
 484                     (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
 485                         i++;
 486                 } else if (IS_MGS(lsi)) {
 487                         lnet_process_id_t id;
 488                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 489                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 490                                         continue;
 491                                 nid = id.nid;
 492                                 i++;
 493                                 break;
 494                         }
 495                 }
 496         } else { /* client */
 497                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 498                 ptr = lsi->lsi_lmd->lmd_dev;
 499                 if (class_parse_nid(ptr, &nid, &ptr) == 0)
 500                         i++;
 501         }
 502         if (i == 0) {
 503                 CERROR("No valid MGS nids found.\n");
 504                 RETURN(-EINVAL);
 505         }
 506
 507         cfs_mutex_lock(&mgc_start_lock);
 508
 509         len = strlen(LUSTRE_MGC_OBDNAME) + strlen(libcfs_nid2str(nid)) + 1;
 510         OBD_ALLOC(mgcname, len);
 511         OBD_ALLOC(niduuid, len + 2);
 512         if (!mgcname || !niduuid)
 513                 GOTO(out_free, rc = -ENOMEM);
 514         sprintf(mgcname, "%s%s", LUSTRE_MGC_OBDNAME, libcfs_nid2str(nid));
 515
 516         mgssec = lsi->lsi_lmd->lmd_mgssec ? lsi->lsi_lmd->lmd_mgssec : "";
 517
 518         OBD_ALLOC_PTR(data);
 519         if (data == NULL)
 520                 GOTO(out_free, rc = -ENOMEM);
 521
 522         obd = class_name2obd(mgcname);
 523         if (obd && !obd->obd_stopping) {
 524                 rc = obd_set_info_async(NULL, obd->obd_self_export,
 525                                         strlen(KEY_MGSSEC), KEY_MGSSEC,
 526                                         strlen(mgssec), mgssec, NULL);
 527                 if (rc)
 528                         GOTO(out_free, rc);
 529
 530                 /* Re-using an existing MGC */
 531                 cfs_atomic_inc(&obd->u.cli.cl_mgc_refcount);
 532
 533                 /* IR compatibility check, only for clients */
 534                 if (lmd_is_client(lsi->lsi_lmd)) {
 535                         int has_ir;
 536                         int vallen = sizeof(*data);
 537                         __u32 *flags = &lsi->lsi_lmd->lmd_flags;
 538
 539                         rc = obd_get_info(NULL, obd->obd_self_export,
 540                                           strlen(KEY_CONN_DATA), KEY_CONN_DATA,
 541                                           &vallen, data, NULL);
 542                         LASSERT(rc == 0);
 543                         has_ir = OCD_HAS_FLAG(data, IMP_RECOV);
 544                         if (has_ir ^ !(*flags & LMD_FLG_NOIR)) {
 545                                 /* LMD_FLG_NOIR is for test purpose only */
 546                                 LCONSOLE_WARN(
 547                                     "Trying to mount a client with IR setting "
 548                                     "not compatible with current mgc. "
 549                                     "Force to use current mgc setting that is "
 550                                     "IR %s.\n",
 551                                     has_ir ? "enabled" : "disabled");
 552                                 if (has_ir)
 553                                         *flags &= ~LMD_FLG_NOIR;
 554                                 else
 555                                         *flags |= LMD_FLG_NOIR;
 556                         }
 557                 }
 558
 559                 recov_bk = 0;
 560                 /* If we are restarting the MGS, don't try to keep the MGC's
 561                    old connection, or registration will fail. */
 562                 if (IS_MGS(lsi)) {
 563                         CDEBUG(D_MOUNT, "New MGS with live MGC\n");
 564                         recov_bk = 1;
 565                 }
 566
 567                 /* Try all connections, but only once (again).
 568                    We don't want to block another target from starting
 569                    (using its local copy of the log), but we do want to connect
 570                    if at all possible. */
 571                 recov_bk++;
 572                 CDEBUG(D_MOUNT, "%s: Set MGC reconnect %d\n", mgcname,recov_bk);
 573                 rc = obd_set_info_async(NULL, obd->obd_self_export,
 574                                         sizeof(KEY_INIT_RECOV_BACKUP),
 575                                         KEY_INIT_RECOV_BACKUP,
 576                                         sizeof(recov_bk), &recov_bk, NULL);
 577                 GOTO(out, rc = 0);
 578         }
 579
 580         CDEBUG(D_MOUNT, "Start MGC '%s'\n", mgcname);
 581
 582         /* Add the primary nids for the MGS */
 583         i = 0;
 584         sprintf(niduuid, "%s_%x", mgcname, i);
 585         if (IS_SERVER(lsi)) {
 586                 ptr = lsi->lsi_lmd->lmd_mgs;
 587                 if (IS_MGS(lsi)) {
 588                         /* Use local nids (including LO) */
 589                         lnet_process_id_t id;
 590                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 591                                 rc = do_lcfg(mgcname, id.nid,
 592                                              LCFG_ADD_UUID, niduuid, 0,0,0);
 593                         }
 594                 } else {
 595                         /* Use mgsnode= nids */
 596                         /* mount -o mgsnode=nid */
 597                         if (lsi->lsi_lmd->lmd_mgs) {
 598                                 ptr = lsi->lsi_lmd->lmd_mgs;
 599                         } else if (class_find_param(ptr, PARAM_MGSNODE,
 600                                                     &ptr) != 0) {
 601                                 CERROR("No MGS nids given.\n");
 602                                 GOTO(out_free, rc = -EINVAL);
 603                         }
 604                         while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 605                                 rc = do_lcfg(mgcname, nid,
 606                                              LCFG_ADD_UUID, niduuid, 0,0,0);
 607                                 i++;
 608                         }
 609                 }
 610         } else { /* client */
 611                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 612                 ptr = lsi->lsi_lmd->lmd_dev;
 613                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 614                         rc = do_lcfg(mgcname, nid,
 615                                      LCFG_ADD_UUID, niduuid, 0,0,0);
 616                         i++;
 617                         /* Stop at the first failover nid */
 618                         if (*ptr == ':')
 619                                 break;
 620                 }
 621         }
 622         if (i == 0) {
 623                 CERROR("No valid MGS nids found.\n");
 624                 GOTO(out_free, rc = -EINVAL);
 625         }
 626         lsi->lsi_lmd->lmd_mgs_failnodes = 1;
 627
 628         /* Random uuid for MGC allows easier reconnects */
 629         OBD_ALLOC_PTR(uuid);
 630         ll_generate_random_uuid(uuidc);
 631         class_uuid_unparse(uuidc, uuid);
 632
 633         /* Start the MGC */
 634         rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
 635                                  (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
 636                                  niduuid, 0, 0);
 637         OBD_FREE_PTR(uuid);
 638         if (rc)
 639                 GOTO(out_free, rc);
 640
 641         /* Add any failover MGS nids */
 642         i = 1;
 643         while (ptr && ((*ptr == ':' ||
 644                class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0))) {
 645                 /* New failover node */
 646                 sprintf(niduuid, "%s_%x", mgcname, i);
 647                 j = 0;
 648                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 649                         j++;
 650                         rc = do_lcfg(mgcname, nid,
 651                                      LCFG_ADD_UUID, niduuid, 0,0,0);
 652                         if (*ptr == ':')
 653                                 break;
 654                 }
 655                 if (j > 0) {
 656                         rc = do_lcfg(mgcname, 0, LCFG_ADD_CONN,
 657                                      niduuid, 0, 0, 0);
 658                         i++;
 659                 } else {
 660                         /* at ":/fsname" */
 661                         break;
 662                 }
 663         }
 664         lsi->lsi_lmd->lmd_mgs_failnodes = i;
 665
 666         obd = class_name2obd(mgcname);
 667         if (!obd) {
 668                 CERROR("Can't find mgcobd %s\n", mgcname);
 669                 GOTO(out_free, rc = -ENOTCONN);
 670         }
 671
 672         rc = obd_set_info_async(NULL, obd->obd_self_export,
 673                                 strlen(KEY_MGSSEC), KEY_MGSSEC,
 674                                 strlen(mgssec), mgssec, NULL);
 675         if (rc)
 676                 GOTO(out_free, rc);
 677
 678         /* Keep a refcount of servers/clients who started with "mount",
 679            so we know when we can get rid of the mgc. */
 680         cfs_atomic_set(&obd->u.cli.cl_mgc_refcount, 1);
 681
 682         /* Try all connections, but only once. */
 683         recov_bk = 1;
 684         rc = obd_set_info_async(NULL, obd->obd_self_export,
 685                                 sizeof(KEY_INIT_RECOV_BACKUP),
 686                                 KEY_INIT_RECOV_BACKUP,
 687                                 sizeof(recov_bk), &recov_bk, NULL);
 688         if (rc)
 689                 /* nonfatal */
 690                 CWARN("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
 691
 692         /* We connect to the MGS at setup, and don't disconnect until cleanup */
 693         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
 694                                   OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV |
 695                                   OBD_CONNECT_MNE_SWAB;
 696         if (lmd_is_client(lsi->lsi_lmd) &&
 697             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
 698                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
 699         data->ocd_version = LUSTRE_VERSION_CODE;
 700         rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
 701         if (rc) {
 702                 CERROR("connect failed %d\n", rc);
 703                 GOTO(out, rc);
 704         }
 705
 706         obd->u.cli.cl_mgc_mgsexp = exp;
 707
 708 out:
 709         /* Keep the mgc info in the sb. Note that many lsi's can point
 710            to the same mgc.*/
 711         lsi->lsi_mgc = obd;
 712 out_free:
 713         cfs_mutex_unlock(&mgc_start_lock);
 714
 715         if (data)
 716                 OBD_FREE_PTR(data);
 717         if (mgcname)
 718                 OBD_FREE(mgcname, len);
 719         if (niduuid)
 720                 OBD_FREE(niduuid, len + 2);
 721         RETURN(rc);
 722 }
 723
 724 static int lustre_stop_mgc(struct super_block *sb)
 725 {
 726         struct lustre_sb_info *lsi = s2lsi(sb);
 727         struct obd_device *obd;
 728         char *niduuid = 0, *ptr = 0;
 729         int i, rc = 0, len = 0;
 730         ENTRY;
 731
 732         if (!lsi)
 733                 RETURN(-ENOENT);
 734         obd = lsi->lsi_mgc;
 735         if (!obd)
 736                 RETURN(-ENOENT);
 737         lsi->lsi_mgc = NULL;
 738
 739         cfs_mutex_lock(&mgc_start_lock);
 740         LASSERT(cfs_atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
 741         if (!cfs_atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 742                 /* This is not fatal, every client that stops
 743                    will call in here. */
 744                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 745                        cfs_atomic_read(&obd->u.cli.cl_mgc_refcount));
 746                 GOTO(out, rc = -EBUSY);
 747         }
 748
 749         /* The MGC has no recoverable data in any case.
 750          * force shotdown set in umount_begin */
 751         obd->obd_no_recov = 1;
 752
 753         if (obd->u.cli.cl_mgc_mgsexp) {
 754                 /* An error is not fatal, if we are unable to send the
 755                    disconnect mgs ping evictor cleans up the export */
 756                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 757                 if (rc)
 758                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 759         }
 760
 761         /* Save the obdname for cleaning the nid uuids, which are
 762            obdname_XX */
 763         len = strlen(obd->obd_name) + 6;
 764         OBD_ALLOC(niduuid, len);
 765         if (niduuid) {
 766                 strcpy(niduuid, obd->obd_name);
 767                 ptr = niduuid + strlen(niduuid);
 768         }
 769
 770         rc = class_manual_cleanup(obd);
 771         if (rc)
 772                 GOTO(out, rc);
 773
 774         /* Clean the nid uuids */
 775         if (!niduuid)
 776                 GOTO(out, rc = -ENOMEM);
 777
 778         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 779                 sprintf(ptr, "_%x", i);
 780                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 781                              niduuid, 0, 0, 0);
 782                 if (rc)
 783                         CERROR("del MDC UUID %s failed: rc = %d\n",
 784                                niduuid, rc);
 785         }
 786 out:
 787         if (niduuid)
 788                 OBD_FREE(niduuid, len);
 789
 790         /* class_import_put will get rid of the additional connections */
 791         cfs_mutex_unlock(&mgc_start_lock);
 792         RETURN(rc);
 793 }
 794
 795 /* Since there's only one mgc per node, we have to change it's fs to get
 796    access to the right disk. */
 797 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
 798 {
 799         struct lustre_sb_info *lsi = s2lsi(sb);
 800         int rc;
 801         ENTRY;
 802
 803         CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
 804
 805         /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
 806         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 807                                 sizeof(KEY_SET_FS), KEY_SET_FS,
 808                                 sizeof(*sb), sb, NULL);
 809         if (rc) {
 810                 CERROR("can't set_fs %d\n", rc);
 811         }
 812
 813         RETURN(rc);
 814 }
 815
 816 static int server_mgc_clear_fs(struct obd_device *mgc)
 817 {
 818         int rc;
 819         ENTRY;
 820
 821         CDEBUG(D_MOUNT, "Unassign mgc disk\n");
 822
 823         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 824                                 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
 825                                 0, NULL, NULL);
 826         RETURN(rc);
 827 }
 828
 829 CFS_DEFINE_MUTEX(server_start_lock);
 830
 831 /* Stop MDS/OSS if nobody is using them */
 832 static int server_stop_servers(int lsiflags)
 833 {
 834         struct obd_device *obd = NULL;
 835         struct obd_type *type = NULL;
 836         int rc = 0;
 837         ENTRY;
 838
 839         cfs_mutex_lock(&server_start_lock);
 840
 841         /* Either an MDT or an OST or neither  */
 842         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
 843         if ((lsiflags & LDD_F_SV_TYPE_MDT) &&
 844             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
 845                 /*FIXME pre-rename, should eventually be LUSTRE_MDT_NAME*/
 846                 type = class_search_type(LUSTRE_MDS_NAME);
 847         }
 848         /* if this was an OST, and there are no more OST's, clean up the OSS */
 849         if ((lsiflags & LDD_F_SV_TYPE_OST) &&
 850             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
 851                 type = class_search_type(LUSTRE_OST_NAME);
 852         }
 853
 854         if (obd && (!type || !type->typ_refcnt)) {
 855                 int err;
 856                 obd->obd_force = 1;
 857                 /* obd_fail doesn't mean much on a server obd */
 858                 err = class_manual_cleanup(obd);
 859                 if (!rc)
 860                         rc = err;
 861         }
 862
 863         cfs_mutex_unlock(&server_start_lock);
 864
 865         RETURN(rc);
 866 }
 867
 868 int server_mti_print(char *title, struct mgs_target_info *mti)
 869 {
 870         PRINT_CMD(PRINT_MASK, "mti %s\n", title);
 871         PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
 872         PRINT_CMD(PRINT_MASK, "fs:     %s\n", mti->mti_fsname);
 873         PRINT_CMD(PRINT_MASK, "uuid:   %s\n", mti->mti_uuid);
 874         PRINT_CMD(PRINT_MASK, "ver: %d  flags: %#x\n",
 875                   mti->mti_config_ver, mti->mti_flags);
 876         return(0);
 877 }
 878
 879 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
 880  * @param [in] svname server name including type and index
 881  * @param [out] fsname Buffer to copy filesystem name prefix into.
 882  *  Must have at least 'strlen(fsname) + 1' chars.
 883  * @param [out] endptr if endptr isn't NULL it is set to end of fsname
 884  * rc < 0  on error
 885  */
 886 static int server_name2fsname(char *svname, char *fsname, char **endptr)
 887 {
 888         char *p;
 889
 890         p = strstr(svname, "-OST");
 891         if (p == NULL)
 892                 p = strstr(svname, "-MDT");
 893         if (p == NULL)
 894                 return -1;
 895
 896         if (fsname) {
 897                 strncpy(fsname, svname, p - svname);
 898                 fsname[p - svname] = '\0';
 899         }
 900
 901         if (endptr != NULL)
 902                 *endptr = p;
 903
 904         return 0;
 905 }
 906
 907 /**
 908  * Get service name (svname) from string
 909  * rc < 0 on error
 910  * if endptr isn't NULL it is set to end of fsname *
 911  */
 912 int server_name2svname(char *label, char *svname, char **endptr)
 913 {
 914         int rc;
 915         char *dash;
 916
 917         /* We use server_name2fsname() just for parsing */
 918         rc = server_name2fsname(label, NULL, &dash);
 919         if (rc != 0)
 920                 return rc;
 921
 922         if (*dash != '-')
 923                 return -1;
 924
 925         strncpy(svname, dash + 1, MTI_NAME_MAXLEN);
 926
 927         return 0;
 928 }
 929 EXPORT_SYMBOL(server_name2svname);
 930
 931
 932 /* Get the index from the obd name.
 933    rc = server type, or
 934    rc < 0  on error
 935    if endptr isn't NULL it is set to end of name */
 936 int server_name2index(char *svname, __u32 *idx, char **endptr)
 937 {
 938         unsigned long index;
 939         int rc;
 940         char *dash;
 941
 942         /* We use server_name2fsname() just for parsing */
 943         rc = server_name2fsname(svname, NULL, &dash);
 944         if (rc != 0)
 945                 return rc;
 946
 947         if (*dash != '-')
 948                 return -EINVAL;
 949
 950         dash++;
 951
 952         if (strncmp(dash, "MDT", 3) == 0)
 953                 rc = LDD_F_SV_TYPE_MDT;
 954         else if (strncmp(dash, "OST", 3) == 0)
 955                 rc = LDD_F_SV_TYPE_OST;
 956         else
 957                 return -EINVAL;
 958
 959         dash += 3;
 960
 961         if (strcmp(dash, "all") == 0)
 962                 return rc | LDD_F_SV_ALL;
 963
 964         index = simple_strtoul(dash, endptr, 16);
 965         *idx = index;
 966
 967         return rc;
 968 }
 969 EXPORT_SYMBOL(server_name2index);
 970
 971 /* Generate data for registration */
 972 static int server_lsi2mti(struct lustre_sb_info *lsi,
 973                           struct mgs_target_info *mti)
 974 {
 975         lnet_process_id_t id;
 976         int rc, i = 0;
 977         ENTRY;
 978
 979         if (!IS_SERVER(lsi))
 980                 RETURN(-EINVAL);
 981
 982         strncpy(mti->mti_svname, lsi->lsi_svname, sizeof(mti->mti_svname));
 983
 984         mti->mti_nid_count = 0;
 985         while (LNetGetId(i++, &id) != -ENOENT) {
 986                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 987                         continue;
 988
 989                 /* server use --servicenode param, only allow specified
 990                  * nids be registered */
 991                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) != 0 &&
 992                     class_match_nid(lsi->lsi_lmd->lmd_params,
 993                                     PARAM_FAILNODE, id.nid) < 1)
 994                         continue;
 995
 996                 /* match specified network */
 997                 if (!class_match_net(lsi->lsi_lmd->lmd_params,
 998                                      PARAM_NETWORK, LNET_NIDNET(id.nid)))
 999                         continue;
1000
1001                 mti->mti_nids[mti->mti_nid_count] = id.nid;
1002                 mti->mti_nid_count++;
1003                 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
1004                         CWARN("Only using first %d nids for %s\n",
1005                               mti->mti_nid_count, mti->mti_svname);
1006                         break;
1007                 }
1008         }
1009
1010         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
1011         mti->mti_config_ver = 0;
1012
1013         rc = server_name2fsname(lsi->lsi_svname, mti->mti_fsname, NULL);
1014         if (rc != 0)
1015                 return rc;
1016
1017         rc = server_name2index(lsi->lsi_svname, &mti->mti_stripe_index, NULL);
1018         if (rc < 0)
1019                 return rc;
1020         /* Orion requires index to be set */
1021         LASSERT(!(rc & LDD_F_NEED_INDEX));
1022         /* keep only LDD flags */
1023         mti->mti_flags = lsi->lsi_flags & LDD_F_MASK;
1024         mti->mti_flags |= LDD_F_UPDATE;
1025         strncpy(mti->mti_params, lsi->lsi_lmd->lmd_params,
1026                 sizeof(mti->mti_params));
1027         return 0;
1028 }
1029
1030 /* Register an old or new target with the MGS. If needed MGS will construct
1031    startup logs and assign index */
1032 static int server_register_target(struct lustre_sb_info *lsi)
1033 {
1034         struct obd_device *mgc = lsi->lsi_mgc;
1035         struct mgs_target_info *mti = NULL;
1036         bool writeconf;
1037         int rc;
1038         ENTRY;
1039
1040         LASSERT(mgc);
1041
1042         if (!IS_SERVER(lsi))
1043                 RETURN(-EINVAL);
1044
1045         OBD_ALLOC_PTR(mti);
1046         if (!mti)
1047                 RETURN(-ENOMEM);
1048
1049         rc = server_lsi2mti(lsi, mti);
1050         if (rc)
1051                 GOTO(out, rc);
1052
1053         CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
1054                mti->mti_svname, mti->mti_fsname,
1055                libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
1056                mti->mti_flags);
1057
1058         /* if write_conf is true, the registration must succeed */
1059         writeconf = !!(lsi->lsi_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE));
1060         mti->mti_flags |= LDD_F_OPC_REG;
1061
1062         /* Register the target */
1063         /* FIXME use mgc_process_config instead */
1064         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1065                                 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1066                                 sizeof(*mti), mti, NULL);
1067         if (rc) {
1068                 if (mti->mti_flags & LDD_F_ERROR) {
1069                         LCONSOLE_ERROR_MSG(0x160,
1070                                 "The MGS is refusing to allow this "
1071                                 "server (%s) to start. Please see messages"
1072                                 " on the MGS node.\n", lsi->lsi_svname);
1073                 } else if (writeconf) {
1074                         LCONSOLE_ERROR_MSG(0x15f,
1075                                 "Communication to the MGS return error %d. "
1076                                 "Is the MGS running?\n", rc);
1077                 } else {
1078                         CERROR("Cannot talk to the MGS: %d, not fatal\n", rc);
1079                         /* reset the error code for non-fatal error. */
1080                         rc = 0;
1081                 }
1082                 GOTO(out, rc);
1083         }
1084
1085 out:
1086         if (mti)
1087                 OBD_FREE_PTR(mti);
1088         RETURN(rc);
1089 }
1090
1091 /**
1092  * Notify the MGS that this target is ready.
1093  * Used by IR - if the MGS receives this message, it will notify clients.
1094  */
1095 static int server_notify_target(struct super_block *sb, struct obd_device *obd)
1096 {
1097         struct lustre_sb_info *lsi = s2lsi(sb);
1098         struct obd_device *mgc = lsi->lsi_mgc;
1099         struct mgs_target_info *mti = NULL;
1100         int rc;
1101         ENTRY;
1102
1103         LASSERT(mgc);
1104
1105         if (!(IS_SERVER(lsi)))
1106                 RETURN(-EINVAL);
1107
1108         OBD_ALLOC_PTR(mti);
1109         if (!mti)
1110                 RETURN(-ENOMEM);
1111         rc = server_lsi2mti(lsi, mti);
1112         if (rc)
1113                 GOTO(out, rc);
1114
1115         mti->mti_instance = obd->u.obt.obt_instance;
1116         mti->mti_flags |= LDD_F_OPC_READY;
1117
1118         /* FIXME use mgc_process_config instead */
1119         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1120                                 sizeof(KEY_REGISTER_TARGET),
1121                                 KEY_REGISTER_TARGET,
1122                                 sizeof(*mti), mti, NULL);
1123
1124         /* Imperative recovery: if the mgs informs us to use IR? */
1125         if (!rc && !(mti->mti_flags & LDD_F_ERROR) &&
1126             (mti->mti_flags & LDD_F_IR_CAPABLE))
1127                 lsi->lsi_flags |= LDD_F_IR_CAPABLE;
1128
1129 out:
1130         if (mti)
1131                 OBD_FREE_PTR(mti);
1132         RETURN(rc);
1133
1134 }
1135
1136 /** Start server targets: MDTs and OSTs
1137  */
1138 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1139 {
1140         struct obd_device *obd;
1141         struct lustre_sb_info *lsi = s2lsi(sb);
1142         struct config_llog_instance cfg;
1143         int rc;
1144         ENTRY;
1145
1146         CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_svname);
1147
1148 #if 0
1149         /* If we're an MDT, make sure the global MDS is running */
1150         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_MDT) {
1151                 /* make sure the MDS is started */
1152                 cfs_mutex_lock(&server_start_lock);
1153                 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1154                 if (!obd) {
1155                         rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1156                     /* FIXME pre-rename, should eventually be LUSTRE_MDS_NAME */
1157                                                  LUSTRE_MDT_NAME,
1158                                                  LUSTRE_MDS_OBDNAME"_uuid",
1159                                                  0, 0);
1160                         if (rc) {
1161                                 cfs_mutex_unlock(&server_start_lock);
1162                                 CERROR("failed to start MDS: %d\n", rc);
1163                                 RETURN(rc);
1164                         }
1165                 }
1166                 cfs_mutex_unlock(&server_start_lock);
1167         }
1168 #endif
1169
1170         /* If we're an OST, make sure the global OSS is running */
1171         if (IS_OST(lsi)) {
1172                 /* make sure OSS is started */
1173                 cfs_mutex_lock(&server_start_lock);
1174                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1175                 if (!obd) {
1176                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1177                                                  LUSTRE_OSS_NAME,
1178                                                  LUSTRE_OSS_OBDNAME"_uuid",
1179                                                  0, 0, 0, 0);
1180                         if (rc) {
1181                                 cfs_mutex_unlock(&server_start_lock);
1182                                 CERROR("failed to start OSS: %d\n", rc);
1183                                 RETURN(rc);
1184                         }
1185                 }
1186                 cfs_mutex_unlock(&server_start_lock);
1187         }
1188
1189         /* Set the mgc fs to our server disk.  This allows the MGC to
1190          * read and write configs locally, in case it can't talk to the MGS. */
1191         if (lsi->lsi_srv_mnt) {
1192                 rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1193                 if (rc)
1194                         RETURN(rc);
1195         }
1196
1197         /* Register with MGS */
1198         rc = server_register_target(lsi);
1199         if (rc)
1200                 GOTO(out_mgc, rc);
1201
1202         /* Let the target look up the mount using the target's name
1203            (we can't pass the sb or mnt through class_process_config.) */
1204         rc = server_register_mount(lsi->lsi_svname, sb, mnt);
1205         if (rc)
1206                 GOTO(out_mgc, rc);
1207
1208         /* Start targets using the llog named for the target */
1209         memset(&cfg, 0, sizeof(cfg));
1210         rc = lustre_process_log(sb, lsi->lsi_svname, &cfg);
1211         if (rc) {
1212                 CERROR("failed to start server %s: %d\n",
1213                        lsi->lsi_svname, rc);
1214                 /* Do NOT call server_deregister_mount() here. This makes it
1215                  * impossible to find mount later in cleanup time and leaves
1216                  * @lsi and othder stuff leaked. -umka */
1217                 GOTO(out_mgc, rc);
1218         }
1219
1220 out_mgc:
1221         /* Release the mgc fs for others to use */
1222         if (lsi->lsi_srv_mnt)
1223                 server_mgc_clear_fs(lsi->lsi_mgc);
1224
1225         if (!rc) {
1226                 obd = class_name2obd(lsi->lsi_svname);
1227                 if (!obd) {
1228                         CERROR("no server named %s was started\n",
1229                                lsi->lsi_svname);
1230                         RETURN(-ENXIO);
1231                 }
1232
1233                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1234                     (OBP(obd, iocontrol))) {
1235                         obd_iocontrol(OBD_IOC_ABORT_RECOVERY,
1236                                       obd->obd_self_export, 0, NULL, NULL);
1237                 }
1238
1239                 server_notify_target(sb, obd);
1240
1241                 /* calculate recovery timeout, do it after lustre_process_log */
1242                 server_calc_timeout(lsi, obd);
1243
1244                 /* log has been fully processed */
1245                 obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1246         }
1247
1248         RETURN(rc);
1249 }
1250
1251 /***************** lustre superblock **************/
1252
1253 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1254 {
1255         struct lustre_sb_info *lsi;
1256         ENTRY;
1257
1258         OBD_ALLOC_PTR(lsi);
1259         if (!lsi)
1260                 RETURN(NULL);
1261         OBD_ALLOC_PTR(lsi->lsi_lmd);
1262         if (!lsi->lsi_lmd) {
1263                 OBD_FREE_PTR(lsi);
1264                 RETURN(NULL);
1265         }
1266
1267         lsi->lsi_lmd->lmd_exclude_count = 0;
1268         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
1269         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
1270         s2lsi_nocast(sb) = lsi;
1271         /* we take 1 extra ref for our setup */
1272         cfs_atomic_set(&lsi->lsi_mounts, 1);
1273
1274         /* Default umount style */
1275         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1276
1277         RETURN(lsi);
1278 }
1279
1280 static int lustre_free_lsi(struct super_block *sb)
1281 {
1282         struct lustre_sb_info *lsi = s2lsi(sb);
1283         ENTRY;
1284
1285         LASSERT(lsi != NULL);
1286         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
1287
1288         /* someone didn't call server_put_mount. */
1289         LASSERT(cfs_atomic_read(&lsi->lsi_mounts) == 0);
1290
1291         if (lsi->lsi_lmd != NULL) {
1292                 if (lsi->lsi_lmd->lmd_dev != NULL)
1293                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
1294                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
1295                 if (lsi->lsi_lmd->lmd_profile != NULL)
1296                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
1297                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
1298                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
1299                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
1300                                  strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
1301                 if (lsi->lsi_lmd->lmd_opts != NULL)
1302                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
1303                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
1304                 if (lsi->lsi_lmd->lmd_exclude_count)
1305                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1306                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1307                                  lsi->lsi_lmd->lmd_exclude_count);
1308                 if (lsi->lsi_lmd->lmd_mgs != NULL)
1309                         OBD_FREE(lsi->lsi_lmd->lmd_mgs,
1310                                  strlen(lsi->lsi_lmd->lmd_mgs) + 1);
1311                 if (lsi->lsi_lmd->lmd_osd_type != NULL)
1312                         OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
1313                                  strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
1314                 if (lsi->lsi_lmd->lmd_params != NULL)
1315                         OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
1316
1317                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1318         }
1319
1320         LASSERT(lsi->lsi_llsbi == NULL);
1321         OBD_FREE(lsi, sizeof(*lsi));
1322         s2lsi_nocast(sb) = NULL;
1323
1324         RETURN(0);
1325 }
1326
1327 /* The lsi has one reference for every server that is using the disk -
1328    e.g. MDT, MGS, and potentially MGC */
1329 static int lustre_put_lsi(struct super_block *sb)
1330 {
1331         struct lustre_sb_info *lsi = s2lsi(sb);
1332         ENTRY;
1333
1334         LASSERT(lsi != NULL);
1335
1336         CDEBUG(D_MOUNT, "put %p %d\n", sb, cfs_atomic_read(&lsi->lsi_mounts));
1337         if (cfs_atomic_dec_and_test(&lsi->lsi_mounts)) {
1338                 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
1339                         obd_disconnect(lsi->lsi_osd_exp);
1340                         /* wait till OSD is gone */
1341                         obd_zombie_barrier();
1342                 }
1343                 lustre_free_lsi(sb);
1344                 RETURN(1);
1345         }
1346         RETURN(0);
1347 }
1348
1349 static int lsi_prepare(struct lustre_sb_info *lsi)
1350 {
1351         __u32 index;
1352         int rc;
1353         ENTRY;
1354
1355         LASSERT(lsi);
1356         LASSERT(lsi->lsi_lmd);
1357
1358         /* The server name is given as a mount line option */
1359         if (lsi->lsi_lmd->lmd_profile == NULL) {
1360                 LCONSOLE_ERROR("Can't determine server name\n");
1361                 RETURN(-EINVAL);
1362         }
1363
1364         if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname))
1365                 RETURN(-ENAMETOOLONG);
1366
1367         strcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile);
1368
1369         /* Determine osd type */
1370         if (lsi->lsi_lmd->lmd_osd_type != NULL) {
1371                 if (strlen(lsi->lsi_lmd->lmd_osd_type) >=
1372                            sizeof(lsi->lsi_osd_type))
1373                         RETURN(-ENAMETOOLONG);
1374
1375                 strcpy(lsi->lsi_osd_type, lsi->lsi_lmd->lmd_osd_type);
1376         } else {
1377                 strcpy(lsi->lsi_osd_type, LUSTRE_OSD_LDISKFS_NAME);
1378         }
1379
1380         /* XXX: a temp. solution for components using fsfilt
1381          *      to be removed in one of the subsequent patches */
1382         if (!strcmp(lsi->lsi_lmd->lmd_osd_type, "osd-ldiskfs")) {
1383                 strcpy(lsi->lsi_fstype, "ldiskfs");
1384         } else {
1385                 strcpy(lsi->lsi_fstype, lsi->lsi_lmd->lmd_osd_type);
1386         }
1387
1388         /* Determine server type */
1389         rc = server_name2index(lsi->lsi_svname, &index, NULL);
1390         if (rc < 0) {
1391                 if (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) {
1392                         /* Assume we're a bare MGS */
1393                         rc = 0;
1394                         lsi->lsi_lmd->lmd_flags |= LMD_FLG_NOSVC;
1395                 } else {
1396                         LCONSOLE_ERROR("Can't determine server type of '%s'\n",
1397                                        lsi->lsi_svname);
1398                         RETURN(rc);
1399                 }
1400         }
1401         lsi->lsi_flags |= rc;
1402
1403         /* Add mount line flags that used to be in ldd:
1404          * writeconf, mgs, iam, anything else?
1405          */
1406         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_WRITECONF) ?
1407                 LDD_F_WRITECONF : 0;
1408         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_VIRGIN) ?
1409                 LDD_F_VIRGIN : 0;
1410         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) ?
1411                 LDD_F_SV_TYPE_MGS : 0;
1412         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_IAM) ?
1413                 LDD_F_IAM_DIR : 0;
1414         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) ?
1415                 LDD_F_NO_PRIMNODE : 0;
1416
1417         RETURN(0);
1418 }
1419
1420 /*************** server mount ******************/
1421
1422 /** Start the shutdown of servers at umount.
1423  */
1424 static void server_put_super(struct super_block *sb)
1425 {
1426         struct lustre_sb_info *lsi = s2lsi(sb);
1427         struct obd_device     *obd;
1428         char *tmpname, *extraname = NULL;
1429         int tmpname_sz;
1430         int lsiflags = lsi->lsi_flags;
1431         ENTRY;
1432
1433         LASSERT(IS_SERVER(lsi));
1434
1435         tmpname_sz = strlen(lsi->lsi_svname) + 1;
1436         OBD_ALLOC(tmpname, tmpname_sz);
1437         memcpy(tmpname, lsi->lsi_svname, tmpname_sz);
1438         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
1439         if (IS_MDT(lsi) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
1440                 snprintf(tmpname, tmpname_sz, "MGS");
1441
1442         /* Stop the target */
1443         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1444             (IS_MDT(lsi) || IS_OST(lsi))) {
1445                 struct lustre_profile *lprof = NULL;
1446
1447                 /* tell the mgc to drop the config log */
1448                 lustre_end_log(sb, lsi->lsi_svname, NULL);
1449
1450                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
1451                    If there are any setup/cleanup errors, save the lov
1452                    name for safety cleanup later. */
1453                 lprof = class_get_profile(lsi->lsi_svname);
1454                 if (lprof && lprof->lp_dt) {
1455                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
1456                         strcpy(extraname, lprof->lp_dt);
1457                 }
1458
1459                 obd = class_name2obd(lsi->lsi_svname);
1460                 if (obd) {
1461                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
1462                         if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
1463                                 obd->obd_fail = 1;
1464                         /* We can't seem to give an error return code
1465                          * to .put_super, so we better make sure we clean up! */
1466                         obd->obd_force = 1;
1467                         class_manual_cleanup(obd);
1468                 } else {
1469                         CERROR("no obd %s\n", lsi->lsi_svname);
1470                         server_deregister_mount(lsi->lsi_svname);
1471                 }
1472         }
1473
1474         /* If they wanted the mgs to stop separately from the mdt, they
1475            should have put it on a different device. */
1476         if (IS_MGS(lsi)) {
1477                 /* if MDS start with --nomgs, don't stop MGS then */
1478                 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
1479                         server_stop_mgs(sb);
1480         }
1481
1482         /* Clean the mgc and sb */
1483         lustre_common_put_super(sb);
1484
1485         /* wait till all in-progress cleanups are done
1486          * specifically we're interested in ofd cleanup
1487          * as it pins OSS */
1488         obd_zombie_barrier();
1489
1490         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
1491            until the target is really gone so that our type refcount check
1492            is right. */
1493         server_stop_servers(lsiflags);
1494
1495         /* In case of startup or cleanup err, stop related obds */
1496         if (extraname) {
1497                 obd = class_name2obd(extraname);
1498                 if (obd) {
1499                         CWARN("Cleaning orphaned obd %s\n", extraname);
1500                         obd->obd_force = 1;
1501                         class_manual_cleanup(obd);
1502                 }
1503                 OBD_FREE(extraname, strlen(extraname) + 1);
1504         }
1505
1506         LCONSOLE_WARN("server umount %s complete\n", tmpname);
1507         OBD_FREE(tmpname, tmpname_sz);
1508         EXIT;
1509 }
1510
1511 /** Called only for 'umount -f'
1512  */
1513 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1514 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
1515 {
1516         struct super_block *sb = vfsmnt->mnt_sb;
1517 #else
1518 static void server_umount_begin(struct super_block *sb)
1519 {
1520 #endif
1521         struct lustre_sb_info *lsi = s2lsi(sb);
1522         ENTRY;
1523
1524 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1525         if (!(flags & MNT_FORCE)) {
1526                 EXIT;
1527                 return;
1528         }
1529 #endif
1530
1531         CDEBUG(D_MOUNT, "umount -f\n");
1532         /* umount = failover
1533            umount -f = force
1534            no third way to do non-force, non-failover */
1535         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
1536         EXIT;
1537 }
1538
1539 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
1540 {
1541         struct super_block *sb = dentry->d_sb;
1542         struct vfsmount *mnt = s2lsi(sb)->lsi_srv_mnt;
1543         ENTRY;
1544
1545         if (mnt && mnt->mnt_sb && mnt->mnt_sb->s_op->statfs) {
1546                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_root, buf);
1547                 if (!rc) {
1548                         buf->f_type = sb->s_magic;
1549                         RETURN(0);
1550                 }
1551         }
1552
1553         /* just return 0 */
1554         buf->f_type = sb->s_magic;
1555         buf->f_bsize = sb->s_blocksize;
1556         buf->f_blocks = 1;
1557         buf->f_bfree = 0;
1558         buf->f_bavail = 0;
1559         buf->f_files = 1;
1560         buf->f_ffree = 0;
1561         buf->f_namelen = NAME_MAX;
1562         RETURN(0);
1563 }
1564
1565 /** The operations we support directly on the superblock:
1566  * mount, umount, and df.
1567  */
1568 static struct super_operations server_ops =
1569 {
1570         .put_super      = server_put_super,
1571         .umount_begin   = server_umount_begin, /* umount -f */
1572         .statfs         = server_statfs,
1573 };
1574
1575 #define log2(n) cfs_ffz(~(n))
1576 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
1577
1578 static int server_fill_super_common(struct super_block *sb)
1579 {
1580         struct inode *root = 0;
1581         ENTRY;
1582
1583         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
1584
1585         sb->s_blocksize = 4096;
1586         sb->s_blocksize_bits = log2(sb->s_blocksize);
1587         sb->s_magic = LUSTRE_SUPER_MAGIC;
1588         sb->s_maxbytes = 0; /* we don't allow file IO on server mountpoints */
1589         sb->s_flags |= MS_RDONLY;
1590         sb->s_op = &server_ops;
1591
1592         root = new_inode(sb);
1593         if (!root) {
1594                 CERROR("Can't make root inode\n");
1595                 RETURN(-EIO);
1596         }
1597
1598         /* returns -EIO for every operation */
1599         /* make_bad_inode(root); -- badness - can't umount */
1600         /* apparently we need to be a directory for the mount to finish */
1601         root->i_mode = S_IFDIR;
1602
1603         sb->s_root = d_alloc_root(root);
1604         if (!sb->s_root) {
1605                 CERROR("Can't make root dentry\n");
1606                 iput(root);
1607                 RETURN(-EIO);
1608         }
1609
1610         RETURN(0);
1611 }
1612
1613 static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags)
1614 {
1615         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1616         struct obd_device        *obd;
1617         struct dt_device_param    p;
1618         char                      flagstr[16];
1619         int                       rc;
1620         ENTRY;
1621
1622         CDEBUG(D_MOUNT,
1623                "Attempting to start %s, type=%s, lsifl=%x, mountfl=%lx\n",
1624                lsi->lsi_svname, lsi->lsi_osd_type, lsi->lsi_flags, mflags);
1625
1626         sprintf(lsi->lsi_osd_obdname, "%s-osd", lsi->lsi_svname);
1627         strcpy(lsi->lsi_osd_uuid, lsi->lsi_osd_obdname);
1628         strcat(lsi->lsi_osd_uuid, "_UUID");
1629         sprintf(flagstr, "%lu:%lu", mflags, (unsigned long) lmd->lmd_flags);
1630
1631         obd = class_name2obd(lsi->lsi_osd_obdname);
1632         if (obd == NULL) {
1633                 rc = lustre_start_simple(lsi->lsi_osd_obdname,
1634                                 lsi->lsi_osd_type,
1635                                 lsi->lsi_osd_uuid, lmd->lmd_dev,
1636                                 flagstr, lsi->lsi_lmd->lmd_opts,
1637                                 lsi->lsi_svname);
1638                 if (rc)
1639                         GOTO(out, rc);
1640                 obd = class_name2obd(lsi->lsi_osd_obdname);
1641                 LASSERT(obd);
1642         }
1643
1644         rc = obd_connect(NULL, &lsi->lsi_osd_exp, obd, &obd->obd_uuid, NULL, NULL);
1645         if (rc) {
1646                 obd->obd_force = 1;
1647                 class_manual_cleanup(obd);
1648                 lsi->lsi_dt_dev = NULL;
1649         }
1650
1651         /* XXX: to keep support old components relying on lsi_srv_mnt
1652          *      we get this info from OSD just started */
1653         LASSERT(obd->obd_lu_dev);
1654         lsi->lsi_dt_dev = lu2dt_dev(obd->obd_lu_dev);
1655         LASSERT(lsi->lsi_dt_dev);
1656
1657         dt_conf_get(NULL, lsi->lsi_dt_dev, &p);
1658
1659         lsi->lsi_srv_mnt = p.ddp_mnt;
1660
1661 out:
1662         RETURN(rc);
1663 }
1664
1665 /** Fill in the superblock info for a Lustre server.
1666  * Mount the device with the correct options.
1667  * Read the on-disk config file.
1668  * Start the services.
1669  */
1670 static int server_fill_super(struct super_block *sb)
1671 {
1672         struct lustre_sb_info *lsi = s2lsi(sb);
1673         int rc;
1674         ENTRY;
1675
1676         rc = lsi_prepare(lsi);
1677         if (rc)
1678                 RETURN(rc);
1679
1680         /* Start low level OSD */
1681         rc = osd_start(lsi, sb->s_flags);
1682         if (rc) {
1683                 CERROR("Unable to start osd on %s: %d\n",
1684                        lsi->lsi_lmd->lmd_dev, rc);
1685                 lustre_put_lsi(sb);
1686                 RETURN(rc);
1687         }
1688
1689         CDEBUG(D_MOUNT, "Found service %s on device %s\n",
1690                lsi->lsi_svname, lsi->lsi_lmd->lmd_dev);
1691
1692         if (class_name2obd(lsi->lsi_svname)) {
1693                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
1694                                    "running. Double-mount may have compromised"
1695                                    " the disk journal.\n",
1696                                    lsi->lsi_svname);
1697                 lustre_put_lsi(sb);
1698                 RETURN(-EALREADY);
1699         }
1700
1701         /* Start MGS before MGC */
1702         if (IS_MGS(lsi) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
1703                 rc = server_start_mgs(sb);
1704                 if (rc)
1705                         GOTO(out_mnt, rc);
1706         }
1707
1708         /* Start MGC before servers */
1709         rc = lustre_start_mgc(sb);
1710         if (rc)
1711                 GOTO(out_mnt, rc);
1712
1713         /* Set up all obd devices for service */
1714         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1715                         (IS_OST(lsi) || IS_MDT(lsi))) {
1716                 rc = server_start_targets(sb, lsi->lsi_srv_mnt);
1717                 if (rc < 0) {
1718                         CERROR("Unable to start targets: %d\n", rc);
1719                         GOTO(out_mnt, rc);
1720                 }
1721         /* FIXME overmount client here,
1722            or can we just start a client log and client_fill_super on this sb?
1723            We need to make sure server_put_super gets called too - ll_put_super
1724            calls lustre_common_put_super; check there for LSI_SERVER flag,
1725            call s_p_s if so.
1726            Probably should start client from new thread so we can return.
1727            Client will not finish until all servers are connected.
1728            Note - MGS-only server does NOT get a client, since there is no
1729            lustre fs associated - the MGS is for all lustre fs's */
1730         }
1731
1732         rc = server_fill_super_common(sb);
1733         if (rc)
1734                 GOTO(out_mnt, rc);
1735
1736         RETURN(0);
1737 out_mnt:
1738         /* We jump here in case of failure while starting targets or MGS.
1739          * In this case we can't just put @mnt and have to do real cleanup
1740          * with stoping targets, etc. */
1741         server_put_super(sb);
1742         return rc;
1743 }
1744
1745 /*
1746  * Calculate timeout value for a target.
1747  */
1748 void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
1749 {
1750         struct lustre_mount_data *lmd;
1751         int soft = 0;
1752         int hard = 0;
1753         int factor = 0;
1754         bool has_ir = !!(lsi->lsi_flags & LDD_F_IR_CAPABLE);
1755         int min = OBD_RECOVERY_TIME_MIN;
1756
1757         LASSERT(IS_SERVER(lsi));
1758
1759         lmd = lsi->lsi_lmd;
1760         if (lmd) {
1761                 soft   = lmd->lmd_recovery_time_soft;
1762                 hard   = lmd->lmd_recovery_time_hard;
1763                 has_ir = has_ir && !(lmd->lmd_flags & LMD_FLG_NOIR);
1764                 obd->obd_no_ir = !has_ir;
1765         }
1766
1767         if (soft == 0)
1768                 soft = OBD_RECOVERY_TIME_SOFT;
1769         if (hard == 0)
1770                 hard = OBD_RECOVERY_TIME_HARD;
1771
1772         /* target may have ir_factor configured. */
1773         factor = OBD_IR_FACTOR_DEFAULT;
1774         if (obd->obd_recovery_ir_factor)
1775                 factor = obd->obd_recovery_ir_factor;
1776
1777         if (has_ir) {
1778                 int new_soft = soft;
1779                 int new_hard = hard;
1780
1781                 /* adjust timeout value by imperative recovery */
1782
1783                 new_soft = (soft * factor) / OBD_IR_FACTOR_MAX;
1784                 new_hard = (hard * factor) / OBD_IR_FACTOR_MAX;
1785
1786                 /* make sure the timeout is not too short */
1787                 new_soft = max(min, new_soft);
1788                 new_hard = max(new_soft, new_hard);
1789
1790                 LCONSOLE_INFO("%s: Imperative Recovery enabled, recovery "
1791                               "window shrunk from %d-%d down to %d-%d\n",
1792                               obd->obd_name, soft, hard, new_soft, new_hard);
1793
1794                 soft = new_soft;
1795                 hard = new_hard;
1796         }
1797
1798         /* we're done */
1799         obd->obd_recovery_timeout   = max(obd->obd_recovery_timeout, soft);
1800         obd->obd_recovery_time_hard = hard;
1801         obd->obd_recovery_ir_factor = factor;
1802 }
1803 EXPORT_SYMBOL(server_calc_timeout);
1804
1805 /*************** mount common betweeen server and client ***************/
1806
1807 /* Common umount */
1808 int lustre_common_put_super(struct super_block *sb)
1809 {
1810         int rc;
1811         ENTRY;
1812
1813         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
1814
1815         /* Drop a ref to the MGC */
1816         rc = lustre_stop_mgc(sb);
1817         if (rc && (rc != -ENOENT)) {
1818                 if (rc != -EBUSY) {
1819                         CERROR("Can't stop MGC: %d\n", rc);
1820                         RETURN(rc);
1821                 }
1822                 /* BUSY just means that there's some other obd that
1823                    needs the mgc.  Let him clean it up. */
1824                 CDEBUG(D_MOUNT, "MGC still in use\n");
1825         }
1826         /* Drop a ref to the mounted disk */
1827         lustre_put_lsi(sb);
1828         lu_types_stop();
1829         RETURN(rc);
1830 }
1831 EXPORT_SYMBOL(lustre_common_put_super);
1832
1833 static void lmd_print(struct lustre_mount_data *lmd)
1834 {
1835         int i;
1836
1837         PRINT_CMD(PRINT_MASK, "  mount data:\n");
1838         if (lmd_is_client(lmd))
1839                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
1840         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
1841         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
1842
1843         if (lmd->lmd_opts)
1844                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
1845
1846         if (lmd->lmd_recovery_time_soft)
1847                 PRINT_CMD(PRINT_MASK, "recovery time soft: %d\n",
1848                           lmd->lmd_recovery_time_soft);
1849
1850         if (lmd->lmd_recovery_time_hard)
1851                 PRINT_CMD(PRINT_MASK, "recovery time hard: %d\n",
1852                           lmd->lmd_recovery_time_hard);
1853
1854         for (i = 0; i < lmd->lmd_exclude_count; i++) {
1855                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
1856                           lmd->lmd_exclude[i]);
1857         }
1858 }
1859
1860 /* Is this server on the exclusion list */
1861 int lustre_check_exclusion(struct super_block *sb, char *svname)
1862 {
1863         struct lustre_sb_info *lsi = s2lsi(sb);
1864         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1865         __u32 index;
1866         int i, rc;
1867         ENTRY;
1868
1869         rc = server_name2index(svname, &index, NULL);
1870         if (rc != LDD_F_SV_TYPE_OST)
1871                 /* Only exclude OSTs */
1872                 RETURN(0);
1873
1874         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
1875                index, lmd->lmd_exclude_count, lmd->lmd_dev);
1876
1877         for(i = 0; i < lmd->lmd_exclude_count; i++) {
1878                 if (index == lmd->lmd_exclude[i]) {
1879                         CWARN("Excluding %s (on exclusion list)\n", svname);
1880                         RETURN(1);
1881                 }
1882         }
1883         RETURN(0);
1884 }
1885
1886 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
1887 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
1888 {
1889         char *s1 = ptr, *s2;
1890         __u32 index, *exclude_list;
1891         int rc = 0, devmax;
1892         ENTRY;
1893
1894         /* The shortest an ost name can be is 8 chars: -OST0000.
1895            We don't actually know the fsname at this time, so in fact
1896            a user could specify any fsname. */
1897         devmax = strlen(ptr) / 8 + 1;
1898
1899         /* temp storage until we figure out how many we have */
1900         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
1901         if (!exclude_list)
1902                 RETURN(-ENOMEM);
1903
1904         /* we enter this fn pointing at the '=' */
1905         while (*s1 && *s1 != ' ' && *s1 != ',') {
1906                 s1++;
1907                 rc = server_name2index(s1, &index, &s2);
1908                 if (rc < 0) {
1909                         CERROR("Can't parse server name '%s'\n", s1);
1910                         break;
1911                 }
1912                 if (rc == LDD_F_SV_TYPE_OST)
1913                         exclude_list[lmd->lmd_exclude_count++] = index;
1914                 else
1915                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
1916                 s1 = s2;
1917                 /* now we are pointing at ':' (next exclude)
1918                    or ',' (end of excludes) */
1919                 if (lmd->lmd_exclude_count >= devmax)
1920                         break;
1921         }
1922         if (rc >= 0) /* non-err */
1923                 rc = 0;
1924
1925         if (lmd->lmd_exclude_count) {
1926                 /* permanent, freed in lustre_free_lsi */
1927                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
1928                           lmd->lmd_exclude_count);
1929                 if (lmd->lmd_exclude) {
1930                         memcpy(lmd->lmd_exclude, exclude_list,
1931                                sizeof(index) * lmd->lmd_exclude_count);
1932                 } else {
1933                         rc = -ENOMEM;
1934                         lmd->lmd_exclude_count = 0;
1935                 }
1936         }
1937         OBD_FREE(exclude_list, sizeof(index) * devmax);
1938         RETURN(rc);
1939 }
1940
1941 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
1942 {
1943         char   *tail;
1944         int     length;
1945
1946         if (lmd->lmd_mgssec != NULL) {
1947                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
1948                 lmd->lmd_mgssec = NULL;
1949         }
1950
1951         tail = strchr(ptr, ',');
1952         if (tail == NULL)
1953                 length = strlen(ptr);
1954         else
1955                 length = tail - ptr;
1956
1957         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
1958         if (lmd->lmd_mgssec == NULL)
1959                 return -ENOMEM;
1960
1961         memcpy(lmd->lmd_mgssec, ptr, length);
1962         lmd->lmd_mgssec[length] = '\0';
1963         return 0;
1964 }
1965
1966 static int lmd_parse_string(char **handle, char *ptr)
1967 {
1968         char   *tail;
1969         int     length;
1970
1971         if ((handle == NULL) || (ptr == NULL))
1972                 return -EINVAL;
1973
1974         if (*handle != NULL) {
1975                 OBD_FREE(*handle, strlen(*handle) + 1);
1976                 *handle = NULL;
1977         }
1978
1979         tail = strchr(ptr, ',');
1980         if (tail == NULL)
1981                 length = strlen(ptr);
1982         else
1983                 length = tail - ptr;
1984
1985         OBD_ALLOC(*handle, length + 1);
1986         if (*handle == NULL)
1987                 return -ENOMEM;
1988
1989         memcpy(*handle, ptr, length);
1990         (*handle)[length] = '\0';
1991
1992         return 0;
1993 }
1994
1995 /* Collect multiple values for mgsnid specifiers */
1996 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
1997 {
1998         lnet_nid_t nid;
1999         char *tail = *ptr;
2000         char *mgsnid;
2001         int   length;
2002         int   oldlen = 0;
2003
2004         /* Find end of nidlist */
2005         while (class_parse_nid(tail, &nid, &tail) == 0) {}
2006         length = tail - *ptr;
2007         if (length == 0) {
2008                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
2009                 return -EINVAL;
2010         }
2011
2012         if (lmd->lmd_mgs != NULL)
2013                 oldlen = strlen(lmd->lmd_mgs) + 1;
2014
2015         OBD_ALLOC(mgsnid, oldlen + length + 1);
2016         if (mgsnid == NULL)
2017                 return -ENOMEM;
2018
2019         if (lmd->lmd_mgs != NULL) {
2020                 /* Multiple mgsnid= are taken to mean failover locations */
2021                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
2022                 mgsnid[oldlen - 1] = ':';
2023                 OBD_FREE(lmd->lmd_mgs, oldlen);
2024         }
2025         memcpy(mgsnid + oldlen, *ptr, length);
2026         mgsnid[oldlen + length] = '\0';
2027         lmd->lmd_mgs = mgsnid;
2028         *ptr = tail;
2029
2030         return 0;
2031 }
2032
2033 /** Parse mount line options
2034  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
2035  * dev is passed as device=uml1:/lustre by mount.lustre
2036  */
2037 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
2038 {
2039         char *s1, *s2, *devname = NULL;
2040         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
2041         int rc = 0;
2042         ENTRY;
2043
2044         LASSERT(lmd);
2045         if (!options) {
2046                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
2047                                    "/sbin/mount.lustre is installed.\n");
2048                 RETURN(-EINVAL);
2049         }
2050
2051         /* Options should be a string - try to detect old lmd data */
2052         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
2053                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
2054                                    "/sbin/mount.lustre.  Please install "
2055                                    "version %s\n", LUSTRE_VERSION_STRING);
2056                 RETURN(-EINVAL);
2057         }
2058         lmd->lmd_magic = LMD_MAGIC;
2059
2060         OBD_ALLOC(lmd->lmd_params, 4096);
2061         if (lmd->lmd_params == NULL)
2062                 RETURN(-ENOMEM);
2063         lmd->lmd_params[0] = '\0';
2064
2065         /* Set default flags here */
2066
2067         s1 = options;
2068         while (*s1) {
2069                 int clear = 0;
2070                 int time_min = OBD_RECOVERY_TIME_MIN;
2071
2072                 /* Skip whitespace and extra commas */
2073                 while (*s1 == ' ' || *s1 == ',')
2074                         s1++;
2075
2076                 /* Client options are parsed in ll_options: eg. flock,
2077                    user_xattr, acl */
2078
2079                 /* Parse non-ldiskfs options here. Rather than modifying
2080                    ldiskfs, we just zero these out here */
2081                 if (strncmp(s1, "abort_recov", 11) == 0) {
2082                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
2083                         clear++;
2084                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
2085                         lmd->lmd_recovery_time_soft = max_t(int,
2086                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2087                         clear++;
2088                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
2089                         lmd->lmd_recovery_time_hard = max_t(int,
2090                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2091                         clear++;
2092                 } else if (strncmp(s1, "noir", 4) == 0) {
2093                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
2094                         clear++;
2095                 } else if (strncmp(s1, "nosvc", 5) == 0) {
2096                         lmd->lmd_flags |= LMD_FLG_NOSVC;
2097                         clear++;
2098                 } else if (strncmp(s1, "nomgs", 5) == 0) {
2099                         lmd->lmd_flags |= LMD_FLG_NOMGS;
2100                         clear++;
2101                 } else if (strncmp(s1, "noscrub", 7) == 0) {
2102                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
2103                         clear++;
2104                 } else if (strncmp(s1, PARAM_MGSNODE,
2105                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
2106                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
2107                         /* Assume the next mount opt is the first
2108                            invalid nid we get to. */
2109                         rc = lmd_parse_mgs(lmd, &s2);
2110                         if (rc)
2111                                 goto invalid;
2112                         clear++;
2113                 } else if (strncmp(s1, "writeconf", 9) == 0) {
2114                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
2115                         clear++;
2116                 } else if (strncmp(s1, "virgin", 6) == 0) {
2117                         lmd->lmd_flags |= LMD_FLG_VIRGIN;
2118                         clear++;
2119                 } else if (strncmp(s1, "noprimnode", 10) == 0) {
2120                         lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
2121                         clear++;
2122                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
2123                         rc = lmd_parse_mgssec(lmd, s1 + 7);
2124                         if (rc)
2125                                 goto invalid;
2126                         clear++;
2127                 /* ost exclusion list */
2128                 } else if (strncmp(s1, "exclude=", 8) == 0) {
2129                         rc = lmd_make_exclusion(lmd, s1 + 7);
2130                         if (rc)
2131                                 goto invalid;
2132                         clear++;
2133                 } else if (strncmp(s1, "mgs", 3) == 0) {
2134                         /* We are an MGS */
2135                         lmd->lmd_flags |= LMD_FLG_MGS;
2136                         clear++;
2137                 } else if (strncmp(s1, "svname=", 7) == 0) {
2138                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
2139                         if (rc)
2140                                 goto invalid;
2141                         clear++;
2142                 } else if (strncmp(s1, "param=", 6) == 0) {
2143                         int length;
2144                         char *tail = strchr(s1 + 6, ',');
2145                         if (tail == NULL)
2146                                 length = strlen(s1);
2147                         else
2148                                 length = tail - s1;
2149                         length -= 6;
2150                         strncat(lmd->lmd_params, s1 + 6, length);
2151                         strcat(lmd->lmd_params, " ");
2152                         clear++;
2153                 } else if (strncmp(s1, "osd=", 4) == 0) {
2154                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
2155                         if (rc)
2156                                 goto invalid;
2157                         clear++;
2158                 }
2159                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
2160                    end of the options. */
2161                 else if (strncmp(s1, "device=", 7) == 0) {
2162                         devname = s1 + 7;
2163                         /* terminate options right before device.  device
2164                            must be the last one. */
2165                         *s1 = '\0';
2166                         break;
2167                 }
2168
2169                 /* Find next opt */
2170                 s2 = strchr(s1, ',');
2171                 if (s2 == NULL) {
2172                         if (clear)
2173                                 *s1 = '\0';
2174                         break;
2175                 }
2176                 s2++;
2177                 if (clear)
2178                         memmove(s1, s2, strlen(s2) + 1);
2179                 else
2180                         s1 = s2;
2181         }
2182
2183         if (!devname) {
2184                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
2185                                    "(need mount option 'device=...')\n");
2186                 goto invalid;
2187         }
2188
2189         s1 = strstr(devname, ":/");
2190         if (s1) {
2191                 ++s1;
2192                 lmd->lmd_flags |= LMD_FLG_CLIENT;
2193                 /* Remove leading /s from fsname */
2194                 while (*++s1 == '/') ;
2195                 /* Freed in lustre_free_lsi */
2196                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
2197                 if (!lmd->lmd_profile)
2198                         RETURN(-ENOMEM);
2199                 sprintf(lmd->lmd_profile, "%s-client", s1);
2200         }
2201
2202         /* Freed in lustre_free_lsi */
2203         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
2204         if (!lmd->lmd_dev)
2205                 RETURN(-ENOMEM);
2206         strcpy(lmd->lmd_dev, devname);
2207
2208         /* Save mount options */
2209         s1 = options + strlen(options) - 1;
2210         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
2211                 *s1-- = 0;
2212         if (*options != 0) {
2213                 /* Freed in lustre_free_lsi */
2214                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
2215                 if (!lmd->lmd_opts)
2216                         RETURN(-ENOMEM);
2217                 strcpy(lmd->lmd_opts, options);
2218         }
2219
2220         lmd_print(lmd);
2221         lmd->lmd_magic = LMD_MAGIC;
2222
2223         RETURN(rc);
2224
2225 invalid:
2226         CERROR("Bad mount options %s\n", options);
2227         RETURN(-EINVAL);
2228 }
2229
2230 struct lustre_mount_data2 {
2231         void *lmd2_data;
2232         struct vfsmount *lmd2_mnt;
2233 };
2234
2235 /** This is the entry point for the mount call into Lustre.
2236  * This is called when a server or client is mounted,
2237  * and this is where we start setting things up.
2238  * @param data Mount options (e.g. -o flock,abort_recov)
2239  */
2240 int lustre_fill_super(struct super_block *sb, void *data, int silent)
2241 {
2242         struct lustre_mount_data *lmd;
2243         struct lustre_mount_data2 *lmd2 = data;
2244         struct lustre_sb_info *lsi;
2245         int rc;
2246         ENTRY;
2247
2248         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
2249
2250         lsi = lustre_init_lsi(sb);
2251         if (!lsi)
2252                 RETURN(-ENOMEM);
2253         lmd = lsi->lsi_lmd;
2254
2255         /*
2256          * Disable lockdep during mount, because mount locking patterns are
2257          * `special'.
2258          */
2259         cfs_lockdep_off();
2260
2261         /*
2262          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
2263          */
2264         obd_zombie_barrier();
2265
2266         /* Figure out the lmd from the mount options */
2267         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
2268                 lustre_put_lsi(sb);
2269                 GOTO(out, rc = -EINVAL);
2270         }
2271
2272         if (lmd_is_client(lmd)) {
2273                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
2274                 if (!client_fill_super) {
2275                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
2276                                            "client mount! Is the 'lustre' "
2277                                            "module loaded?\n");
2278                         lustre_put_lsi(sb);
2279                         rc = -ENODEV;
2280                 } else {
2281                         rc = lustre_start_mgc(sb);
2282                         if (rc) {
2283                                 lustre_put_lsi(sb);
2284                                 GOTO(out, rc);
2285                         }
2286                         /* Connect and start */
2287                         /* (should always be ll_fill_super) */
2288                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
2289                         /* c_f_s will call lustre_common_put_super on failure */
2290                 }
2291         } else {
2292                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
2293                 rc = server_fill_super(sb);
2294                 /* s_f_s calls lustre_start_mgc after the mount because we need
2295                    the MGS nids which are stored on disk.  Plus, we may
2296                    need to start the MGS first. */
2297                 /* s_f_s will call server_put_super on failure */
2298         }
2299
2300         /* If error happens in fill_super() call, @lsi will be killed there.
2301          * This is why we do not put it here. */
2302         GOTO(out, rc);
2303 out:
2304         if (rc) {
2305                 CERROR("Unable to mount %s (%d)\n",
2306                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
2307         } else {
2308                 CDEBUG(D_SUPER, "Mount %s complete\n",
2309                        lmd->lmd_dev);
2310         }
2311         cfs_lockdep_on();
2312         return rc;
2313 }
2314
2315
2316 /* We can't call ll_fill_super by name because it lives in a module that
2317    must be loaded after this one. */
2318 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
2319                                                   struct vfsmount *mnt))
2320 {
2321         client_fill_super = cfs;
2322 }
2323 EXPORT_SYMBOL(lustre_register_client_fill_super);
2324
2325 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
2326 {
2327         kill_super_cb = cfs;
2328 }
2329 EXPORT_SYMBOL(lustre_register_kill_super_cb);
2330
2331 /***************** FS registration ******************/
2332 #ifdef HAVE_FSTYPE_MOUNT
2333 struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
2334                                 const char *devname, void *data)
2335 {
2336         struct lustre_mount_data2 lmd2 = { data, NULL };
2337
2338         return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
2339 }
2340 #else
2341 int lustre_get_sb(struct file_system_type *fs_type, int flags,
2342                   const char *devname, void * data, struct vfsmount *mnt)
2343 {
2344         struct lustre_mount_data2 lmd2 = { data, mnt };
2345
2346         return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
2347 }
2348 #endif
2349
2350 void lustre_kill_super(struct super_block *sb)
2351 {
2352         struct lustre_sb_info *lsi = s2lsi(sb);
2353
2354         if (kill_super_cb && lsi && !IS_SERVER(lsi))
2355                 (*kill_super_cb)(sb);
2356
2357         kill_anon_super(sb);
2358 }
2359
2360 /** Register the "lustre" fs type
2361  */
2362 struct file_system_type lustre_fs_type = {
2363         .owner        = THIS_MODULE,
2364         .name         = "lustre",
2365 #ifdef HAVE_FSTYPE_MOUNT
2366         .mount        = lustre_mount,
2367 #else
2368         .get_sb       = lustre_get_sb,
2369 #endif
2370         .kill_sb      = lustre_kill_super,
2371         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
2372 #ifdef FS_HAS_FIEMAP
2373                         FS_HAS_FIEMAP |
2374 #endif
2375                         LL_RENAME_DOES_D_MOVE,
2376 };
2377
2378 int lustre_register_fs(void)
2379 {
2380         return register_filesystem(&lustre_fs_type);
2381 }
2382
2383 int lustre_unregister_fs(void)
2384 {
2385         return unregister_filesystem(&lustre_fs_type);
2386 }
2387
2388 EXPORT_SYMBOL(server_mti_print);