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