lustre/obdclass/obd_mount.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  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
  59 static int (*client_fill_super)(struct super_block *sb) = NULL;
  60 static void (*kill_super_cb)(struct super_block *sb) = NULL;
  61
  62 /*********** mount lookup *********/
  63
  64 DECLARE_MUTEX(lustre_mount_info_lock);
  65 static CFS_LIST_HEAD(server_mount_info_list);
  66
  67 static struct lustre_mount_info *server_find_mount(const char *name)
  68 {
  69         struct list_head *tmp;
  70         struct lustre_mount_info *lmi;
  71         ENTRY;
  72
  73         list_for_each(tmp, &server_mount_info_list) {
  74                 lmi = list_entry(tmp, struct lustre_mount_info, lmi_list_chain);
  75                 if (strcmp(name, lmi->lmi_name) == 0)
  76                         RETURN(lmi);
  77         }
  78         RETURN(NULL);
  79 }
  80
  81 /* we must register an obd for a mount before we call the setup routine.
  82    *_setup will call lustre_get_mount to get the mnt struct
  83    by obd_name, since we can't pass the pointer to setup. */
  84 static int server_register_mount(const char *name, struct super_block *sb,
  85                           struct vfsmount *mnt)
  86 {
  87         struct lustre_mount_info *lmi;
  88         char *name_cp;
  89         ENTRY;
  90
  91         LASSERT(mnt);
  92         LASSERT(sb);
  93
  94         OBD_ALLOC(lmi, sizeof(*lmi));
  95         if (!lmi)
  96                 RETURN(-ENOMEM);
  97         OBD_ALLOC(name_cp, strlen(name) + 1);
  98         if (!name_cp) {
  99                 OBD_FREE(lmi, sizeof(*lmi));
 100                 RETURN(-ENOMEM);
 101         }
 102         strcpy(name_cp, name);
 103
 104         down(&lustre_mount_info_lock);
 105
 106         if (server_find_mount(name)) {
 107                 up(&lustre_mount_info_lock);
 108                 OBD_FREE(lmi, sizeof(*lmi));
 109                 OBD_FREE(name_cp, strlen(name) + 1);
 110                 CERROR("Already registered %s\n", name);
 111                 RETURN(-EEXIST);
 112         }
 113         lmi->lmi_name = name_cp;
 114         lmi->lmi_sb = sb;
 115         lmi->lmi_mnt = mnt;
 116         list_add(&lmi->lmi_list_chain, &server_mount_info_list);
 117
 118         up(&lustre_mount_info_lock);
 119
 120         CDEBUG(D_MOUNT, "reg_mnt %p from %s, vfscount=%d\n",
 121                lmi->lmi_mnt, name, atomic_read(&lmi->lmi_mnt->mnt_count));
 122
 123         RETURN(0);
 124 }
 125
 126 /* when an obd no longer needs a mount */
 127 static int server_deregister_mount(const char *name)
 128 {
 129         struct lustre_mount_info *lmi;
 130         ENTRY;
 131
 132         down(&lustre_mount_info_lock);
 133         lmi = server_find_mount(name);
 134         if (!lmi) {
 135                 up(&lustre_mount_info_lock);
 136                 CERROR("%s not registered\n", name);
 137                 RETURN(-ENOENT);
 138         }
 139
 140         CDEBUG(D_MOUNT, "dereg_mnt %p from %s, vfscount=%d\n",
 141                lmi->lmi_mnt, name, atomic_read(&lmi->lmi_mnt->mnt_count));
 142
 143         OBD_FREE(lmi->lmi_name, strlen(lmi->lmi_name) + 1);
 144         list_del(&lmi->lmi_list_chain);
 145         OBD_FREE(lmi, sizeof(*lmi));
 146         up(&lustre_mount_info_lock);
 147
 148         RETURN(0);
 149 }
 150
 151 /* obd's look up a registered mount using their obdname. This is just
 152    for initial obd setup to find the mount struct.  It should not be
 153    called every time you want to mntget. */
 154 struct lustre_mount_info *server_get_mount(const char *name)
 155 {
 156         struct lustre_mount_info *lmi;
 157         struct lustre_sb_info *lsi;
 158         ENTRY;
 159
 160         down(&lustre_mount_info_lock);
 161         lmi = server_find_mount(name);
 162         up(&lustre_mount_info_lock);
 163         if (!lmi) {
 164                 CERROR("Can't find mount for %s\n", name);
 165                 RETURN(NULL);
 166         }
 167         lsi = s2lsi(lmi->lmi_sb);
 168         mntget(lmi->lmi_mnt);
 169         atomic_inc(&lsi->lsi_mounts);
 170
 171         CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d, vfscount=%d\n",
 172                lmi->lmi_mnt, name, atomic_read(&lsi->lsi_mounts),
 173                atomic_read(&lmi->lmi_mnt->mnt_count));
 174
 175         RETURN(lmi);
 176 }
 177
 178 /*
 179  * Used by mdt to get mount_info from obdname.
 180  * There are no blocking when using the mount_info.
 181  * Do not use server_get_mount for this purpose.
 182  */
 183 struct lustre_mount_info *server_get_mount_2(const char *name)
 184 {
 185         struct lustre_mount_info *lmi;
 186         ENTRY;
 187
 188         down(&lustre_mount_info_lock);
 189         lmi = server_find_mount(name);
 190         up(&lustre_mount_info_lock);
 191         if (!lmi)
 192                 CERROR("Can't find mount for %s\n", name);
 193
 194         RETURN(lmi);
 195 }
 196
 197 static void unlock_mntput(struct vfsmount *mnt)
 198 {
 199         if (kernel_locked()) {
 200                 unlock_kernel();
 201                 mntput(mnt);
 202                 lock_kernel();
 203         } else {
 204                 mntput(mnt);
 205         }
 206 }
 207
 208 static int lustre_put_lsi(struct super_block *sb);
 209
 210 /* to be called from obd_cleanup methods */
 211 int server_put_mount(const char *name, struct vfsmount *mnt)
 212 {
 213         struct lustre_mount_info *lmi;
 214         struct lustre_sb_info *lsi;
 215         int count = atomic_read(&mnt->mnt_count) - 1;
 216         ENTRY;
 217
 218         /* This might be the last one, can't deref after this */
 219         unlock_mntput(mnt);
 220
 221         down(&lustre_mount_info_lock);
 222         lmi = server_find_mount(name);
 223         up(&lustre_mount_info_lock);
 224         if (!lmi) {
 225                 CERROR("Can't find mount for %s\n", name);
 226                 RETURN(-ENOENT);
 227         }
 228         lsi = s2lsi(lmi->lmi_sb);
 229         LASSERT(lmi->lmi_mnt == mnt);
 230
 231         CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d, vfscount=%d\n",
 232                lmi->lmi_mnt, name, atomic_read(&lsi->lsi_mounts), count);
 233
 234         if (lustre_put_lsi(lmi->lmi_sb)) {
 235                 CDEBUG(D_MOUNT, "Last put of mnt %p from %s, vfscount=%d\n",
 236                        lmi->lmi_mnt, name, count);
 237                 /* last mount is the One True Mount */
 238                 if (count > 1)
 239                         CERROR("%s: mount busy, vfscount=%d!\n", name, count);
 240         }
 241
 242         /* this obd should never need the mount again */
 243         server_deregister_mount(name);
 244
 245         RETURN(0);
 246 }
 247
 248 /* Corresponding to server_get_mount_2 */
 249 int server_put_mount_2(const char *name, struct vfsmount *mnt)
 250 {
 251         ENTRY;
 252         RETURN(0);
 253 }
 254
 255 /******* mount helper utilities *********/
 256
 257 #if 0
 258 static void ldd_print(struct lustre_disk_data *ldd)
 259 {
 260         PRINT_CMD(PRINT_MASK, "  disk data:\n");
 261         PRINT_CMD(PRINT_MASK, "server:  %s\n", ldd->ldd_svname);
 262         PRINT_CMD(PRINT_MASK, "uuid:    %s\n", (char *)ldd->ldd_uuid);
 263         PRINT_CMD(PRINT_MASK, "fs:      %s\n", ldd->ldd_fsname);
 264         PRINT_CMD(PRINT_MASK, "index:   %04x\n", ldd->ldd_svindex);
 265         PRINT_CMD(PRINT_MASK, "config:  %d\n", ldd->ldd_config_ver);
 266         PRINT_CMD(PRINT_MASK, "flags:   %#x\n", ldd->ldd_flags);
 267         PRINT_CMD(PRINT_MASK, "diskfs:  %s\n", MT_STR(ldd));
 268         PRINT_CMD(PRINT_MASK, "options: %s\n", ldd->ldd_mount_opts);
 269         PRINT_CMD(PRINT_MASK, "params:  %s\n", ldd->ldd_params);
 270         PRINT_CMD(PRINT_MASK, "comment: %s\n", ldd->ldd_userdata);
 271 }
 272 #endif
 273
 274 static int ldd_parse(struct lvfs_run_ctxt *mount_ctxt,
 275                            struct lustre_disk_data *ldd)
 276 {
 277         struct lvfs_run_ctxt saved;
 278         struct file *file;
 279         loff_t off = 0;
 280         unsigned long len;
 281         int rc;
 282         ENTRY;
 283
 284         push_ctxt(&saved, mount_ctxt, NULL);
 285
 286         file = filp_open(MOUNT_DATA_FILE, O_RDONLY, 0644);
 287         if (IS_ERR(file)) {
 288                 rc = PTR_ERR(file);
 289                 CERROR("cannot open %s: rc = %d\n", MOUNT_DATA_FILE, rc);
 290                 GOTO(out, rc);
 291         }
 292
 293         len = i_size_read(file->f_dentry->d_inode);
 294         CDEBUG(D_MOUNT, "Have %s, size %lu\n", MOUNT_DATA_FILE, len);
 295         if (len != sizeof(*ldd)) {
 296                 CERROR("disk data size does not match: see %lu expect "LPSZ"\n",
 297                        len, sizeof(*ldd));
 298                 GOTO(out_close, rc = -EINVAL);
 299         }
 300
 301         rc = lustre_fread(file, ldd, len, &off);
 302         if (rc != len) {
 303                 CERROR("error reading %s: read %d of %lu\n",
 304                        MOUNT_DATA_FILE, rc, len);
 305                 GOTO(out_close, rc = -EINVAL);
 306         }
 307         rc = 0;
 308
 309         if (ldd->ldd_magic != LDD_MAGIC) {
 310                 /* FIXME add swabbing support */
 311                 CERROR("Bad magic in %s: %x!=%x\n", MOUNT_DATA_FILE,
 312                        ldd->ldd_magic, LDD_MAGIC);
 313                 GOTO(out_close, rc = -EINVAL);
 314         }
 315
 316         if (ldd->ldd_feature_incompat & ~LDD_INCOMPAT_SUPP) {
 317                 CERROR("%s: unsupported incompat filesystem feature(s) %x\n",
 318                        ldd->ldd_svname,
 319                        ldd->ldd_feature_incompat & ~LDD_INCOMPAT_SUPP);
 320                 GOTO(out_close, rc = -EINVAL);
 321         }
 322         if (ldd->ldd_feature_rocompat & ~LDD_ROCOMPAT_SUPP) {
 323                 CERROR("%s: unsupported read-only filesystem feature(s) %x\n",
 324                        ldd->ldd_svname,
 325                        ldd->ldd_feature_rocompat & ~LDD_ROCOMPAT_SUPP);
 326                 /* Do something like remount filesystem read-only */
 327                 GOTO(out_close, rc = -EINVAL);
 328         }
 329
 330 out_close:
 331         filp_close(file, 0);
 332 out:
 333         pop_ctxt(&saved, mount_ctxt, NULL);
 334         RETURN(rc);
 335 }
 336
 337 static int ldd_write(struct lvfs_run_ctxt *mount_ctxt,
 338                      struct lustre_disk_data *ldd)
 339 {
 340         struct lvfs_run_ctxt saved;
 341         struct file *file;
 342         loff_t off = 0;
 343         unsigned long len = sizeof(struct lustre_disk_data);
 344         int rc = 0;
 345         ENTRY;
 346
 347         LASSERT(ldd->ldd_magic == LDD_MAGIC);
 348
 349         ldd->ldd_config_ver++;
 350
 351         push_ctxt(&saved, mount_ctxt, NULL);
 352
 353         file = filp_open(MOUNT_DATA_FILE, O_RDWR, 0644);
 354         if (IS_ERR(file)) {
 355                 rc = PTR_ERR(file);
 356                 CERROR("cannot open %s: rc = %d\n", MOUNT_DATA_FILE, rc);
 357                 GOTO(out, rc);
 358         }
 359
 360         rc = lustre_fwrite(file, ldd, len, &off);
 361         if (rc != len) {
 362                 CERROR("error writing %s: read %d of %lu\n",
 363                        MOUNT_DATA_FILE, rc, len);
 364                 GOTO(out_close, rc = -EINVAL);
 365         }
 366
 367         rc = 0;
 368
 369 out_close:
 370         filp_close(file, 0);
 371 out:
 372         pop_ctxt(&saved, mount_ctxt, NULL);
 373         RETURN(rc);
 374 }
 375
 376
 377 /**************** config llog ********************/
 378
 379 /* Get a config log from the MGS and process it.
 380    This func is called for both clients and servers.
 381    Continue to process new statements appended to the logs
 382    (whenever the config lock is revoked) until lustre_end_log
 383    is called. */
 384 int lustre_process_log(struct super_block *sb, char *logname,
 385                      struct config_llog_instance *cfg)
 386 {
 387         struct lustre_cfg *lcfg;
 388         struct lustre_cfg_bufs bufs;
 389         struct lustre_sb_info *lsi = s2lsi(sb);
 390         struct obd_device *mgc = lsi->lsi_mgc;
 391         int rc;
 392         ENTRY;
 393
 394         LASSERT(mgc);
 395         LASSERT(cfg);
 396
 397         /* mgc_process_config */
 398         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
 399         lustre_cfg_bufs_set_string(&bufs, 1, logname);
 400         lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
 401         lustre_cfg_bufs_set(&bufs, 3, &sb, sizeof(sb));
 402         lcfg = lustre_cfg_new(LCFG_LOG_START, &bufs);
 403         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 404         lustre_cfg_free(lcfg);
 405
 406         if (rc == -EINVAL)
 407                 LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
 408                                    "failed from the MGS (%d).  Make sure this "
 409                                    "client and the MGS are running compatible "
 410                                    "versions of Lustre.\n",
 411                                    mgc->obd_name, logname, rc);
 412
 413         if (rc)
 414                 LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
 415                                    "failed (%d). This may be the result of "
 416                                    "communication errors between this node and "
 417                                    "the MGS, a bad configuration, or other "
 418                                    "errors. See the syslog for more "
 419                                    "information.\n", mgc->obd_name, logname,
 420                                    rc);
 421
 422         /* class_obd_list(); */
 423         RETURN(rc);
 424 }
 425
 426 /* Stop watching this config log for updates */
 427 int lustre_end_log(struct super_block *sb, char *logname,
 428                        struct config_llog_instance *cfg)
 429 {
 430         struct lustre_cfg *lcfg;
 431         struct lustre_cfg_bufs bufs;
 432         struct lustre_sb_info *lsi = s2lsi(sb);
 433         struct obd_device *mgc = lsi->lsi_mgc;
 434         int rc;
 435         ENTRY;
 436
 437         if (!mgc)
 438                 RETURN(-ENOENT);
 439
 440         /* mgc_process_config */
 441         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
 442         lustre_cfg_bufs_set_string(&bufs, 1, logname);
 443         if (cfg)
 444                 lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
 445         lcfg = lustre_cfg_new(LCFG_LOG_END, &bufs);
 446         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 447         lustre_cfg_free(lcfg);
 448         RETURN(rc);
 449 }
 450
 451 /**************** obd start *******************/
 452
 453 int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
 454             char *s1, char *s2, char *s3, char *s4)
 455 {
 456         struct lustre_cfg_bufs bufs;
 457         struct lustre_cfg    * lcfg = NULL;
 458         int rc;
 459
 460         CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
 461                cmd, s1, s2, s3, s4);
 462
 463         lustre_cfg_bufs_reset(&bufs, cfgname);
 464         if (s1)
 465                 lustre_cfg_bufs_set_string(&bufs, 1, s1);
 466         if (s2)
 467                 lustre_cfg_bufs_set_string(&bufs, 2, s2);
 468         if (s3)
 469                 lustre_cfg_bufs_set_string(&bufs, 3, s3);
 470         if (s4)
 471                 lustre_cfg_bufs_set_string(&bufs, 4, s4);
 472
 473         lcfg = lustre_cfg_new(cmd, &bufs);
 474         lcfg->lcfg_nid = nid;
 475         rc = class_process_config(lcfg);
 476         lustre_cfg_free(lcfg);
 477         return(rc);
 478 }
 479
 480 static int lustre_start_simple(char *obdname, char *type, char *uuid,
 481                                char *s1, char *s2)
 482 {
 483         int rc;
 484         CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
 485
 486         rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, 0, 0);
 487         if (rc) {
 488                 CERROR("%s attach error %d\n", obdname, rc);
 489                 return(rc);
 490         }
 491         rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, 0, 0);
 492         if (rc) {
 493                 CERROR("%s setup error %d\n", obdname, rc);
 494                 do_lcfg(obdname, 0, LCFG_DETACH, 0, 0, 0, 0);
 495         }
 496         return rc;
 497 }
 498
 499 /* Set up a MGS to serve startup logs */
 500 static int server_start_mgs(struct super_block *sb)
 501 {
 502         struct lustre_sb_info    *lsi = s2lsi(sb);
 503         struct vfsmount          *mnt = lsi->lsi_srv_mnt;
 504         struct lustre_mount_info *lmi;
 505         int    rc = 0;
 506         ENTRY;
 507         LASSERT(mnt);
 508
 509         /* It is impossible to have more than 1 MGS per node, since
 510            MGC wouldn't know which to connect to */
 511         lmi = server_find_mount(LUSTRE_MGS_OBDNAME);
 512         if (lmi) {
 513                 lsi = s2lsi(lmi->lmi_sb);
 514                 LCONSOLE_ERROR_MSG(0x15d, "The MGS service was already started"
 515                                    " from server %s\n",
 516                                    lsi->lsi_ldd->ldd_svname);
 517                 RETURN(-EALREADY);
 518         }
 519
 520         CDEBUG(D_CONFIG, "Start MGS service %s\n", LUSTRE_MGS_OBDNAME);
 521
 522         rc = server_register_mount(LUSTRE_MGS_OBDNAME, sb, mnt);
 523
 524         if (!rc &&
 525             ((rc = lustre_start_simple(LUSTRE_MGS_OBDNAME, LUSTRE_MGS_NAME,
 526                                        LUSTRE_MGS_OBDNAME, 0, 0))))
 527                 server_deregister_mount(LUSTRE_MGS_OBDNAME);
 528
 529         if (rc)
 530                 LCONSOLE_ERROR_MSG(0x15e, "Failed to start MGS '%s' (%d). "
 531                                    "Is the 'mgs' module loaded?\n",
 532                                    LUSTRE_MGS_OBDNAME, rc);
 533         RETURN(rc);
 534 }
 535
 536 static int server_stop_mgs(struct super_block *sb)
 537 {
 538         struct obd_device *obd;
 539         int rc;
 540         ENTRY;
 541
 542         CDEBUG(D_MOUNT, "Stop MGS service %s\n", LUSTRE_MGS_OBDNAME);
 543
 544         /* There better be only one MGS */
 545         obd = class_name2obd(LUSTRE_MGS_OBDNAME);
 546         if (!obd) {
 547                 CDEBUG(D_CONFIG, "mgs %s not running\n", LUSTRE_MGS_OBDNAME);
 548                 RETURN(-EALREADY);
 549         }
 550
 551         /* The MGS should always stop when we say so */
 552         obd->obd_force = 1;
 553         rc = class_manual_cleanup(obd);
 554         RETURN(rc);
 555 }
 556
 557 DECLARE_MUTEX(mgc_start_lock);
 558
 559 /** Set up a mgc obd to process startup logs
 560  *
 561  * \param sb [in] super block of the mgc obd
 562  *
 563  * \retval 0 success, otherwise error code
 564  */
 565 static int lustre_start_mgc(struct super_block *sb)
 566 {
 567         struct lustre_handle mgc_conn = {0, };
 568         struct obd_connect_data *data = NULL;
 569         struct lustre_sb_info *lsi = s2lsi(sb);
 570         struct obd_device *obd;
 571         struct obd_export *exp;
 572         struct obd_uuid *uuid;
 573         class_uuid_t uuidc;
 574         lnet_nid_t nid;
 575         char *mgcname, *niduuid;
 576         char *ptr;
 577         int recov_bk;
 578         int rc = 0, i = 0, j, len;
 579         ENTRY;
 580
 581         LASSERT(lsi->lsi_lmd);
 582
 583         /* Find the first non-lo MGS nid for our MGC name */
 584         if (lsi->lsi_flags & LSI_SERVER) {
 585                 ptr = lsi->lsi_ldd->ldd_params;
 586                 /* Use mgsnode= nids */
 587                 if ((class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0) &&
 588                     (class_parse_nid(ptr, &nid, &ptr) == 0)) {
 589                         i++;
 590                 } else if (IS_MGS(lsi->lsi_ldd)) {
 591                         lnet_process_id_t id;
 592                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 593                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 594                                         continue;
 595                                 nid = id.nid;
 596                                 i++;
 597                                 break;
 598                         }
 599                 }
 600         } else { /* client */
 601                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 602                 ptr = lsi->lsi_lmd->lmd_dev;
 603                 if (class_parse_nid(ptr, &nid, &ptr) == 0)
 604                         i++;
 605         }
 606         if (i == 0) {
 607                 CERROR("No valid MGS nids found.\n");
 608                 RETURN(-EINVAL);
 609         }
 610
 611         len = strlen(LUSTRE_MGC_OBDNAME) + strlen(libcfs_nid2str(nid)) + 1;
 612         OBD_ALLOC(mgcname, len);
 613         OBD_ALLOC(niduuid, len + 2);
 614         if (!mgcname || !niduuid)
 615                 GOTO(out_free, rc = -ENOMEM);
 616         sprintf(mgcname, "%s%s", LUSTRE_MGC_OBDNAME, libcfs_nid2str(nid));
 617
 618         mutex_down(&mgc_start_lock);
 619
 620         obd = class_name2obd(mgcname);
 621         if (obd && !obd->obd_stopping) {
 622                 /* Re-using an existing MGC */
 623                 atomic_inc(&obd->u.cli.cl_mgc_refcount);
 624
 625                 recov_bk = 0;
 626                 /* If we are restarting the MGS, don't try to keep the MGC's
 627                    old connection, or registration will fail. */
 628                 if ((lsi->lsi_flags & LSI_SERVER) && IS_MGS(lsi->lsi_ldd)) {
 629                         CDEBUG(D_MOUNT, "New MGS with live MGC\n");
 630                         recov_bk = 1;
 631                 }
 632
 633                 /* Try all connections, but only once (again).
 634                    We don't want to block another target from starting
 635                    (using its local copy of the log), but we do want to connect
 636                    if at all possible. */
 637                 recov_bk++;
 638                 CDEBUG(D_MOUNT, "%s: Set MGC reconnect %d\n", mgcname,recov_bk);
 639                 rc = obd_set_info_async(obd->obd_self_export,
 640                                         sizeof(KEY_INIT_RECOV_BACKUP),
 641                                         KEY_INIT_RECOV_BACKUP,
 642                                         sizeof(recov_bk), &recov_bk, NULL);
 643                 GOTO(out, rc = 0);
 644         }
 645
 646         CDEBUG(D_MOUNT, "Start MGC '%s'\n", mgcname);
 647
 648         /* Add the primary nids for the MGS */
 649         i = 0;
 650         sprintf(niduuid, "%s_%x", mgcname, i);
 651         if (lsi->lsi_flags & LSI_SERVER) {
 652                 ptr = lsi->lsi_ldd->ldd_params;
 653                 if (IS_MGS(lsi->lsi_ldd)) {
 654                         /* Use local nids (including LO) */
 655                         lnet_process_id_t id;
 656                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 657                                 rc = do_lcfg(mgcname, id.nid,
 658                                              LCFG_ADD_UUID, niduuid, 0,0,0);
 659                         }
 660                 } else {
 661                         /* Use mgsnode= nids */
 662                         if (class_find_param(ptr, PARAM_MGSNODE, &ptr) != 0) {
 663                                 CERROR("No MGS nids given.\n");
 664                                 GOTO(out_free, rc = -EINVAL);
 665                         }
 666                         while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 667                                 rc = do_lcfg(mgcname, nid,
 668                                              LCFG_ADD_UUID, niduuid, 0,0,0);
 669                                 i++;
 670                         }
 671                 }
 672         } else { /* client */
 673                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 674                 ptr = lsi->lsi_lmd->lmd_dev;
 675                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 676                         rc = do_lcfg(mgcname, nid,
 677                                      LCFG_ADD_UUID, niduuid, 0,0,0);
 678                         i++;
 679                         /* Stop at the first failover nid */
 680                         if (*ptr == ':')
 681                                 break;
 682                 }
 683         }
 684         if (i == 0) {
 685                 CERROR("No valid MGS nids found.\n");
 686                 GOTO(out_free, rc = -EINVAL);
 687         }
 688         lsi->lsi_lmd->lmd_mgs_failnodes = 1;
 689
 690         /* Random uuid for MGC allows easier reconnects */
 691         OBD_ALLOC_PTR(uuid);
 692         ll_generate_random_uuid(uuidc);
 693         class_uuid_unparse(uuidc, uuid);
 694
 695         /* Start the MGC */
 696         rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
 697                                  (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
 698                                  niduuid);
 699         OBD_FREE_PTR(uuid);
 700         if (rc)
 701                 GOTO(out_free, rc);
 702
 703         /* Add any failover MGS nids */
 704         i = 1;
 705         while ((*ptr == ':' ||
 706                 class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0)) {
 707                 /* New failover node */
 708                 sprintf(niduuid, "%s_%x", mgcname, i);
 709                 j = 0;
 710                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 711                         j++;
 712                         rc = do_lcfg(mgcname, nid,
 713                                      LCFG_ADD_UUID, niduuid, 0,0,0);
 714                         if (*ptr == ':')
 715                                 break;
 716                 }
 717                 if (j > 0) {
 718                         rc = do_lcfg(mgcname, 0, LCFG_ADD_CONN,
 719                                      niduuid, 0, 0, 0);
 720                         i++;
 721                 } else {
 722                         /* at ":/fsname" */
 723                         break;
 724                 }
 725         }
 726         lsi->lsi_lmd->lmd_mgs_failnodes = i;
 727
 728         obd = class_name2obd(mgcname);
 729         if (!obd) {
 730                 CERROR("Can't find mgcobd %s\n", mgcname);
 731                 GOTO(out_free, rc = -ENOTCONN);
 732         }
 733
 734         /* Keep a refcount of servers/clients who started with "mount",
 735            so we know when we can get rid of the mgc. */
 736         atomic_set(&obd->u.cli.cl_mgc_refcount, 1);
 737
 738         /* Try all connections, but only once. */
 739         recov_bk = 1;
 740         rc = obd_set_info_async(obd->obd_self_export,
 741                                 sizeof(KEY_INIT_RECOV_BACKUP),
 742                                 KEY_INIT_RECOV_BACKUP,
 743                                 sizeof(recov_bk), &recov_bk, NULL);
 744         if (rc)
 745                 /* nonfatal */
 746                 CWARN("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
 747         /* We connect to the MGS at setup, and don't disconnect until cleanup */
 748         OBD_ALLOC_PTR(data);
 749         if (data == NULL)
 750                 GOTO(out, rc = -ENOMEM);
 751         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_FID |
 752                                   OBD_CONNECT_AT;
 753         data->ocd_version = LUSTRE_VERSION_CODE;
 754         rc = obd_connect(NULL, &mgc_conn, obd, &(obd->obd_uuid), data, NULL);
 755         OBD_FREE_PTR(data);
 756         if (rc) {
 757                 CERROR("connect failed %d\n", rc);
 758                 GOTO(out, rc);
 759         }
 760
 761         exp = class_conn2export(&mgc_conn);
 762         obd->u.cli.cl_mgc_mgsexp = exp;
 763
 764 out:
 765         /* Keep the mgc info in the sb. Note that many lsi's can point
 766            to the same mgc.*/
 767         lsi->lsi_mgc = obd;
 768 out_free:
 769         mutex_up(&mgc_start_lock);
 770
 771         if (mgcname)
 772                 OBD_FREE(mgcname, len);
 773         if (niduuid)
 774                 OBD_FREE(niduuid, len + 2);
 775         RETURN(rc);
 776 }
 777
 778 static int lustre_stop_mgc(struct super_block *sb)
 779 {
 780         struct lustre_sb_info *lsi = s2lsi(sb);
 781         struct obd_device *obd;
 782         char *niduuid = 0, *ptr = 0;
 783         int i, rc = 0, len = 0;
 784         ENTRY;
 785
 786         if (!lsi)
 787                 RETURN(-ENOENT);
 788         obd = lsi->lsi_mgc;
 789         if (!obd)
 790                 RETURN(-ENOENT);
 791         lsi->lsi_mgc = NULL;
 792
 793         mutex_down(&mgc_start_lock);
 794         LASSERT(atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
 795         if (!atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 796                 /* This is not fatal, every client that stops
 797                    will call in here. */
 798                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 799                        atomic_read(&obd->u.cli.cl_mgc_refcount));
 800                 GOTO(out, rc = -EBUSY);
 801         }
 802
 803         /* The MGC has no recoverable data in any case.
 804          * force shotdown set in umount_begin */
 805         obd->obd_no_recov = 1;
 806
 807         if (obd->u.cli.cl_mgc_mgsexp) {
 808                 /* An error is not fatal, if we are unable to send the
 809                    disconnect mgs ping evictor cleans up the export */
 810                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 811                 if (rc)
 812                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 813         }
 814
 815         /* Save the obdname for cleaning the nid uuids, which are
 816            obdname_XX */
 817         len = strlen(obd->obd_name) + 6;
 818         OBD_ALLOC(niduuid, len);
 819         if (niduuid) {
 820                 strcpy(niduuid, obd->obd_name);
 821                 ptr = niduuid + strlen(niduuid);
 822         }
 823
 824         rc = class_manual_cleanup(obd);
 825         if (rc)
 826                 GOTO(out, rc);
 827
 828         /* Clean the nid uuids */
 829         if (!niduuid)
 830                 GOTO(out, rc = -ENOMEM);
 831
 832         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 833                 sprintf(ptr, "_%x", i);
 834                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 835                              niduuid, 0, 0, 0);
 836                 if (rc)
 837                         CERROR("del MDC UUID %s failed: rc = %d\n",
 838                                niduuid, rc);
 839         }
 840 out:
 841         if (niduuid)
 842                 OBD_FREE(niduuid, len);
 843
 844         /* class_import_put will get rid of the additional connections */
 845         mutex_up(&mgc_start_lock);
 846         RETURN(rc);
 847 }
 848
 849 /* Since there's only one mgc per node, we have to change it's fs to get
 850    access to the right disk. */
 851 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
 852 {
 853         struct lustre_sb_info *lsi = s2lsi(sb);
 854         int rc;
 855         ENTRY;
 856
 857         CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
 858
 859         /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
 860         rc = obd_set_info_async(mgc->obd_self_export,
 861                                 sizeof(KEY_SET_FS), KEY_SET_FS,
 862                                 sizeof(*sb), sb, NULL);
 863         if (rc) {
 864                 CERROR("can't set_fs %d\n", rc);
 865         }
 866
 867         RETURN(rc);
 868 }
 869
 870 static int server_mgc_clear_fs(struct obd_device *mgc)
 871 {
 872         int rc;
 873         ENTRY;
 874
 875         CDEBUG(D_MOUNT, "Unassign mgc disk\n");
 876
 877         rc = obd_set_info_async(mgc->obd_self_export,
 878                                 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
 879                                 0, NULL, NULL);
 880         RETURN(rc);
 881 }
 882
 883 DECLARE_MUTEX(server_start_lock);
 884
 885 /* Stop MDS/OSS if nobody is using them */
 886 static int server_stop_servers(int lddflags, int lsiflags)
 887 {
 888         struct obd_device *obd = NULL;
 889         struct obd_type *type = NULL;
 890         int rc = 0;
 891         ENTRY;
 892
 893         mutex_down(&server_start_lock);
 894
 895         /* Either an MDT or an OST or neither  */
 896         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
 897         if ((lddflags & LDD_F_SV_TYPE_MDT) &&
 898             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
 899                 /*FIXME pre-rename, should eventually be LUSTRE_MDT_NAME*/
 900                 type = class_search_type(LUSTRE_MDS_NAME);
 901         }
 902         /* if this was an OST, and there are no more OST's, clean up the OSS */
 903         if ((lddflags & LDD_F_SV_TYPE_OST) &&
 904             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
 905                 type = class_search_type(LUSTRE_OST_NAME);
 906         }
 907
 908         if (obd && (!type || !type->typ_refcnt)) {
 909                 int err;
 910                 obd->obd_force = 1;
 911                 /* obd_fail doesn't mean much on a server obd */
 912                 err = class_manual_cleanup(obd);
 913                 if (!rc)
 914                         rc = err;
 915         }
 916
 917         mutex_up(&server_start_lock);
 918
 919         RETURN(rc);
 920 }
 921
 922 int server_mti_print(char *title, struct mgs_target_info *mti)
 923 {
 924         PRINT_CMD(PRINT_MASK, "mti %s\n", title);
 925         PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
 926         PRINT_CMD(PRINT_MASK, "fs:     %s\n", mti->mti_fsname);
 927         PRINT_CMD(PRINT_MASK, "uuid:   %s\n", mti->mti_uuid);
 928         PRINT_CMD(PRINT_MASK, "ver: %d  flags: %#x\n",
 929                   mti->mti_config_ver, mti->mti_flags);
 930         return(0);
 931 }
 932
 933 static int server_sb2mti(struct super_block *sb, struct mgs_target_info *mti)
 934 {
 935         struct lustre_sb_info    *lsi = s2lsi(sb);
 936         struct lustre_disk_data  *ldd = lsi->lsi_ldd;
 937         lnet_process_id_t         id;
 938         int i = 0;
 939         ENTRY;
 940
 941         if (!(lsi->lsi_flags & LSI_SERVER))
 942                 RETURN(-EINVAL);
 943
 944         strncpy(mti->mti_fsname, ldd->ldd_fsname,
 945                 sizeof(mti->mti_fsname));
 946         strncpy(mti->mti_svname, ldd->ldd_svname,
 947                 sizeof(mti->mti_svname));
 948
 949         mti->mti_nid_count = 0;
 950         while (LNetGetId(i++, &id) != -ENOENT) {
 951                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 952                         continue;
 953                 mti->mti_nids[mti->mti_nid_count] = id.nid;
 954                 mti->mti_nid_count++;
 955                 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
 956                         CWARN("Only using first %d nids for %s\n",
 957                               mti->mti_nid_count, mti->mti_svname);
 958                         break;
 959                 }
 960         }
 961
 962         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
 963         mti->mti_config_ver = 0;
 964         mti->mti_flags = ldd->ldd_flags;
 965         mti->mti_stripe_index = ldd->ldd_svindex;
 966         memcpy(mti->mti_uuid, ldd->ldd_uuid, sizeof(mti->mti_uuid));
 967         if (strlen(ldd->ldd_params) > sizeof(mti->mti_params)) {
 968                 CERROR("params too big for mti\n");
 969                 RETURN(-ENOMEM);
 970         }
 971         memcpy(mti->mti_params, ldd->ldd_params, sizeof(mti->mti_params));
 972         RETURN(0);
 973 }
 974
 975 /* Register an old or new target with the MGS. If needed MGS will construct
 976    startup logs and assign index */
 977 int server_register_target(struct super_block *sb)
 978 {
 979         struct lustre_sb_info *lsi = s2lsi(sb);
 980         struct obd_device *mgc = lsi->lsi_mgc;
 981         struct lustre_disk_data *ldd = lsi->lsi_ldd;
 982         struct mgs_target_info *mti = NULL;
 983         int rc;
 984         ENTRY;
 985
 986         LASSERT(mgc);
 987
 988         if (!(lsi->lsi_flags & LSI_SERVER))
 989                 RETURN(-EINVAL);
 990
 991         OBD_ALLOC_PTR(mti);
 992         if (!mti)
 993                 RETURN(-ENOMEM);
 994         rc = server_sb2mti(sb, mti);
 995         if (rc)
 996                 GOTO(out, rc);
 997
 998         CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
 999                mti->mti_svname, mti->mti_fsname,
1000                libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
1001                mti->mti_flags);
1002
1003         /* Register the target */
1004         /* FIXME use mgc_process_config instead */
1005         rc = obd_set_info_async(mgc->u.cli.cl_mgc_mgsexp,
1006                                 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1007                                 sizeof(*mti), mti, NULL);
1008         if (rc)
1009                 GOTO(out, rc);
1010
1011         /* Always update our flags */
1012         ldd->ldd_flags = mti->mti_flags & ~LDD_F_REWRITE_LDD;
1013
1014         /* If this flag is set, it means the MGS wants us to change our
1015            on-disk data. (So far this means just the index.) */
1016         if (mti->mti_flags & LDD_F_REWRITE_LDD) {
1017                 char *label;
1018                 int err;
1019                 CDEBUG(D_MOUNT, "Changing on-disk index from %#x to %#x "
1020                        "for %s\n", ldd->ldd_svindex, mti->mti_stripe_index,
1021                        mti->mti_svname);
1022                 ldd->ldd_svindex = mti->mti_stripe_index;
1023                 strncpy(ldd->ldd_svname, mti->mti_svname,
1024                         sizeof(ldd->ldd_svname));
1025                 /* or ldd_make_sv_name(ldd); */
1026                 ldd_write(&mgc->obd_lvfs_ctxt, ldd);
1027                 err = fsfilt_set_label(mgc, lsi->lsi_srv_mnt->mnt_sb,
1028                                        mti->mti_svname);
1029                 if (err)
1030                         CERROR("Label set error %d\n", err);
1031                 label = fsfilt_get_label(mgc, lsi->lsi_srv_mnt->mnt_sb);
1032                 if (label)
1033                         CDEBUG(D_MOUNT, "Disk label changed to %s\n", label);
1034
1035                 /* Flush the new ldd to disk */
1036                 fsfilt_sync(mgc, lsi->lsi_srv_mnt->mnt_sb);
1037         }
1038
1039 out:
1040         if (mti)
1041                 OBD_FREE_PTR(mti);
1042         RETURN(rc);
1043 }
1044
1045 /* Start targets */
1046 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1047 {
1048         struct obd_device *obd;
1049         struct lustre_sb_info *lsi = s2lsi(sb);
1050         struct config_llog_instance cfg;
1051         int rc;
1052         ENTRY;
1053
1054         CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_ldd->ldd_svname);
1055
1056 #if 0
1057         /* If we're an MDT, make sure the global MDS is running */
1058         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_MDT) {
1059                 /* make sure the MDS is started */
1060                 mutex_down(&server_start_lock);
1061                 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1062                 if (!obd) {
1063                         rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1064                     /* FIXME pre-rename, should eventually be LUSTRE_MDS_NAME */
1065                                                  LUSTRE_MDT_NAME,
1066                                                  LUSTRE_MDS_OBDNAME"_uuid",
1067                                                  0, 0);
1068                         if (rc) {
1069                                 mutex_up(&server_start_lock);
1070                                 CERROR("failed to start MDS: %d\n", rc);
1071                                 RETURN(rc);
1072                         }
1073                 }
1074                 mutex_up(&server_start_lock);
1075         }
1076 #endif
1077
1078         /* If we're an OST, make sure the global OSS is running */
1079         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_OST) {
1080                 /* make sure OSS is started */
1081                 mutex_down(&server_start_lock);
1082                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1083                 if (!obd) {
1084                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1085                                                  LUSTRE_OSS_NAME,
1086                                                  LUSTRE_OSS_OBDNAME"_uuid",
1087                                                  0, 0);
1088                         if (rc) {
1089                                 mutex_up(&server_start_lock);
1090                                 CERROR("failed to start OSS: %d\n", rc);
1091                                 RETURN(rc);
1092                         }
1093                 }
1094                 mutex_up(&server_start_lock);
1095         }
1096
1097         /* Set the mgc fs to our server disk.  This allows the MGC
1098            to read and write configs locally. */
1099         rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1100         if (rc)
1101                 RETURN(rc);
1102
1103         /* Register with MGS */
1104         rc = server_register_target(sb);
1105         if (rc && (lsi->lsi_ldd->ldd_flags &
1106                    (LDD_F_NEED_INDEX | LDD_F_UPDATE | LDD_F_UPGRADE14))){
1107                 CERROR("Required registration failed for %s: %d\n",
1108                        lsi->lsi_ldd->ldd_svname, rc);
1109                 if (rc == -EIO) {
1110                         LCONSOLE_ERROR_MSG(0x15f, "Communication error with "
1111                                            "the MGS.  Is the MGS running?\n");
1112                 }
1113                 GOTO(out_mgc, rc);
1114         }
1115         if (rc == -EINVAL) {
1116                 LCONSOLE_ERROR_MSG(0x160, "The MGS is refusing to allow this "
1117                                    "server (%s) to start. Please see messages"
1118                                    " on the MGS node.\n",
1119                                    lsi->lsi_ldd->ldd_svname);
1120                 GOTO(out_mgc, rc);
1121         }
1122         /* non-fatal error of registeration with MGS */
1123         if (rc)
1124                 CDEBUG(D_MOUNT, "Cannot register with MGS: %d\n", rc);
1125
1126         /* Let the target look up the mount using the target's name
1127            (we can't pass the sb or mnt through class_process_config.) */
1128         rc = server_register_mount(lsi->lsi_ldd->ldd_svname, sb, mnt);
1129         if (rc)
1130                 GOTO(out_mgc, rc);
1131
1132         /* Start targets using the llog named for the target */
1133         memset(&cfg, 0, sizeof(cfg));
1134         rc = lustre_process_log(sb, lsi->lsi_ldd->ldd_svname, &cfg);
1135         if (rc) {
1136                 CERROR("failed to start server %s: %d\n",
1137                        lsi->lsi_ldd->ldd_svname, rc);
1138                 server_deregister_mount(lsi->lsi_ldd->ldd_svname);
1139                 GOTO(out_mgc, rc);
1140         }
1141
1142 out_mgc:
1143         /* Release the mgc fs for others to use */
1144         server_mgc_clear_fs(lsi->lsi_mgc);
1145
1146         if (!rc) {
1147                 obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
1148                 if (!obd) {
1149                         CERROR("no server named %s was started\n",
1150                                lsi->lsi_ldd->ldd_svname);
1151                         RETURN(-ENXIO);
1152                 }
1153
1154                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1155                     (OBP(obd, iocontrol))) {
1156                         obd_iocontrol(OBD_IOC_ABORT_RECOVERY,
1157                                       obd->obd_self_export, 0, NULL, NULL);
1158                 }
1159
1160                 /* log has been fully processed */
1161                 obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1162         }
1163
1164         RETURN(rc);
1165 }
1166
1167 /***************** lustre superblock **************/
1168
1169 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1170 {
1171         struct lustre_sb_info *lsi;
1172         ENTRY;
1173
1174         OBD_ALLOC_PTR(lsi);
1175         if (!lsi)
1176                 RETURN(NULL);
1177         OBD_ALLOC_PTR(lsi->lsi_lmd);
1178         if (!lsi->lsi_lmd) {
1179                 OBD_FREE_PTR(lsi);
1180                 RETURN(NULL);
1181         }
1182
1183         lsi->lsi_lmd->lmd_exclude_count = 0;
1184         s2lsi_nocast(sb) = lsi;
1185         /* we take 1 extra ref for our setup */
1186         atomic_set(&lsi->lsi_mounts, 1);
1187
1188         /* Default umount style */
1189         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1190
1191         RETURN(lsi);
1192 }
1193
1194 static int lustre_free_lsi(struct super_block *sb)
1195 {
1196         struct lustre_sb_info *lsi = s2lsi(sb);
1197         ENTRY;
1198
1199         LASSERT(lsi != NULL);
1200         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
1201
1202         /* someone didn't call server_put_mount. */
1203         LASSERT(atomic_read(&lsi->lsi_mounts) == 0);
1204
1205         if (lsi->lsi_ldd != NULL)
1206                 OBD_FREE(lsi->lsi_ldd, sizeof(*lsi->lsi_ldd));
1207
1208         if (lsi->lsi_lmd != NULL) {
1209                 if (lsi->lsi_lmd->lmd_dev != NULL)
1210                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
1211                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
1212                 if (lsi->lsi_lmd->lmd_profile != NULL)
1213                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
1214                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
1215                 if (lsi->lsi_lmd->lmd_opts != NULL)
1216                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
1217                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
1218                 if (lsi->lsi_lmd->lmd_exclude_count)
1219                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1220                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1221                                  lsi->lsi_lmd->lmd_exclude_count);
1222                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1223         }
1224
1225         LASSERT(lsi->lsi_llsbi == NULL);
1226         OBD_FREE(lsi, sizeof(*lsi));
1227         s2lsi_nocast(sb) = NULL;
1228
1229         RETURN(0);
1230 }
1231
1232 /* The lsi has one reference for every server that is using the disk -
1233    e.g. MDT, MGS, and potentially MGC */
1234 static int lustre_put_lsi(struct super_block *sb)
1235 {
1236         struct lustre_sb_info *lsi = s2lsi(sb);
1237         ENTRY;
1238
1239         LASSERT(lsi != NULL);
1240
1241         CDEBUG(D_MOUNT, "put %p %d\n", sb, atomic_read(&lsi->lsi_mounts));
1242         if (atomic_dec_and_test(&lsi->lsi_mounts)) {
1243                 lustre_free_lsi(sb);
1244                 RETURN(1);
1245         }
1246         RETURN(0);
1247 }
1248
1249 /*************** server mount ******************/
1250
1251 /* Kernel mount using mount options in MOUNT_DATA_FILE */
1252 static struct vfsmount *server_kernel_mount(struct super_block *sb)
1253 {
1254         struct lvfs_run_ctxt mount_ctxt;
1255         struct lustre_sb_info *lsi = s2lsi(sb);
1256         struct lustre_disk_data *ldd;
1257         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1258         struct vfsmount *mnt;
1259         char *options = NULL;
1260         unsigned long page, s_flags;
1261         struct page *__page;
1262         int rc;
1263         ENTRY;
1264
1265         OBD_ALLOC(ldd, sizeof(*ldd));
1266         if (!ldd)
1267                 RETURN(ERR_PTR(-ENOMEM));
1268
1269         /* In the past, we have always used flags = 0.
1270            Note ext3/ldiskfs can't be mounted ro. */
1271         s_flags = sb->s_flags;
1272
1273         /* allocate memory for options */
1274         OBD_PAGE_ALLOC(__page, CFS_ALLOC_STD);
1275         if (!__page)
1276                 GOTO(out_free, rc = -ENOMEM);
1277         page = (unsigned long)cfs_page_address(__page);
1278         options = (char *)page;
1279         memset(options, 0, CFS_PAGE_SIZE);
1280
1281         /* mount-line options must be added for pre-mount because it may
1282          * contain mount options such as journal_dev which are required
1283          * to mount successfuly the underlying filesystem */
1284         if (lmd->lmd_opts && (*(lmd->lmd_opts) != 0))
1285                 strncat(options, lmd->lmd_opts, CFS_PAGE_SIZE - 1);
1286
1287         /* Pre-mount ldiskfs to read the MOUNT_DATA_FILE */
1288         CDEBUG(D_MOUNT, "Pre-mount ldiskfs %s\n", lmd->lmd_dev);
1289         mnt = ll_kern_mount("ldiskfs", s_flags, lmd->lmd_dev, (void *)options);
1290         if (IS_ERR(mnt)) {
1291                 rc = PTR_ERR(mnt);
1292                 CERROR("premount %s:%#lx ldiskfs failed: %d "
1293                         "Is the ldiskfs module available?\n",
1294                         lmd->lmd_dev, s_flags, rc );
1295                 GOTO(out_free, rc);
1296         }
1297
1298         OBD_SET_CTXT_MAGIC(&mount_ctxt);
1299         mount_ctxt.pwdmnt = mnt;
1300         mount_ctxt.pwd = mnt->mnt_root;
1301         mount_ctxt.fs = get_ds();
1302
1303         rc = ldd_parse(&mount_ctxt, ldd);
1304         unlock_mntput(mnt);
1305
1306         if (rc) {
1307                 CERROR("premount parse options failed: rc = %d\n", rc);
1308                 GOTO(out_free, rc);
1309         }
1310
1311         /* Done with our pre-mount, now do the real mount. */
1312
1313         /* Glom up mount options */
1314         memset(options, 0, CFS_PAGE_SIZE);
1315         strncpy(options, ldd->ldd_mount_opts, CFS_PAGE_SIZE - 2);
1316
1317         /* Add in any mount-line options */
1318         if (lmd->lmd_opts && (*(lmd->lmd_opts) != 0)) {
1319                 int len = CFS_PAGE_SIZE - strlen(options) - 2;
1320                 if (*options != 0)
1321                         strcat(options, ",");
1322                 strncat(options, lmd->lmd_opts, len);
1323         }
1324
1325         /* Special permanent mount flags */
1326         if (IS_OST(ldd))
1327             s_flags |= MS_NOATIME | MS_NODIRATIME;
1328
1329         CDEBUG(D_MOUNT, "kern_mount: %s %s %s\n",
1330                MT_STR(ldd), lmd->lmd_dev, options);
1331         mnt = ll_kern_mount(MT_STR(ldd), s_flags, lmd->lmd_dev,
1332                             (void *)options);
1333         if (IS_ERR(mnt)) {
1334                 rc = PTR_ERR(mnt);
1335                 CERROR("ll_kern_mount failed: rc = %d\n", rc);
1336                 GOTO(out_free, rc);
1337         }
1338
1339         OBD_PAGE_FREE(__page);
1340         lsi->lsi_ldd = ldd;   /* freed at lsi cleanup */
1341         CDEBUG(D_SUPER, "%s: mnt = %p\n", lmd->lmd_dev, mnt);
1342         RETURN(mnt);
1343
1344 out_free:
1345         if (__page)
1346                 OBD_PAGE_FREE(__page);
1347         OBD_FREE(ldd, sizeof(*ldd));
1348         lsi->lsi_ldd = NULL;
1349         RETURN(ERR_PTR(rc));
1350 }
1351
1352 static void server_wait_finished(struct vfsmount *mnt)
1353 {
1354         wait_queue_head_t   waitq;
1355         struct l_wait_info  lwi;
1356         int                 retries = 330;
1357
1358         init_waitqueue_head(&waitq);
1359
1360         while ((atomic_read(&mnt->mnt_count) > 1) && (retries > 0)) {
1361                 LCONSOLE_WARN("Mount still busy with %d refs, waiting for "
1362                               "%d secs...\n",
1363                               atomic_read(&mnt->mnt_count), retries);
1364
1365                 /* Wait for a bit */
1366                 retries -= 5;
1367                 lwi = LWI_TIMEOUT(5 * HZ, NULL, NULL);
1368                 l_wait_event(waitq, 0, &lwi);
1369         }
1370         if (atomic_read(&mnt->mnt_count) > 1) {
1371                 CERROR("Mount %p is still busy (%d refs), giving up.\n",
1372                        mnt, atomic_read(&mnt->mnt_count));
1373         }
1374 }
1375
1376 static void server_put_super(struct super_block *sb)
1377 {
1378         struct lustre_sb_info *lsi = s2lsi(sb);
1379         struct obd_device     *obd;
1380         struct vfsmount       *mnt = lsi->lsi_srv_mnt;
1381         char *tmpname, *extraname = NULL;
1382         int tmpname_sz;
1383         int lddflags = lsi->lsi_ldd->ldd_flags;
1384         int lsiflags = lsi->lsi_flags;
1385         ENTRY;
1386
1387         LASSERT(lsiflags & LSI_SERVER);
1388
1389         tmpname_sz = strlen(lsi->lsi_ldd->ldd_svname) + 1;
1390         OBD_ALLOC(tmpname, tmpname_sz);
1391         memcpy(tmpname, lsi->lsi_ldd->ldd_svname, tmpname_sz);
1392         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
1393
1394         /* Stop the target */
1395         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1396             (IS_MDT(lsi->lsi_ldd) || IS_OST(lsi->lsi_ldd))) {
1397                 struct lustre_profile *lprof = NULL;
1398
1399                 /* tell the mgc to drop the config log */
1400                 lustre_end_log(sb, lsi->lsi_ldd->ldd_svname, NULL);
1401
1402                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
1403                    If there are any setup/cleanup errors, save the lov
1404                    name for safety cleanup later. */
1405                 lprof = class_get_profile(lsi->lsi_ldd->ldd_svname);
1406                 if (lprof && lprof->lp_dt) {
1407                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
1408                         strcpy(extraname, lprof->lp_dt);
1409                 }
1410
1411                 obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
1412                 if (obd) {
1413                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
1414                         if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
1415                                 obd->obd_fail = 1;
1416                         /* We can't seem to give an error return code
1417                          * to .put_super, so we better make sure we clean up! */
1418                         obd->obd_force = 1;
1419                         class_manual_cleanup(obd);
1420                 } else {
1421                         CERROR("no obd %s\n", lsi->lsi_ldd->ldd_svname);
1422                         server_deregister_mount(lsi->lsi_ldd->ldd_svname);
1423                 }
1424         }
1425
1426         /* If they wanted the mgs to stop separately from the mdt, they
1427            should have put it on a different device. */
1428         if (IS_MGS(lsi->lsi_ldd)) {
1429                 /* if MDS start with --nomgs, don't stop MGS then */
1430                 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
1431                         server_stop_mgs(sb);
1432         }
1433
1434         /* Clean the mgc and sb */
1435         lustre_common_put_super(sb);
1436
1437         /* Wait for the targets to really clean up - can't exit (and let the
1438            sb get destroyed) while the mount is still in use */
1439         server_wait_finished(mnt);
1440
1441         /* drop the One True Mount */
1442         unlock_mntput(mnt);
1443
1444         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
1445            until the target is really gone so that our type refcount check
1446            is right. */
1447         server_stop_servers(lddflags, lsiflags);
1448
1449         /* In case of startup or cleanup err, stop related obds */
1450         if (extraname) {
1451                 obd = class_name2obd(extraname);
1452                 if (obd) {
1453                         CWARN("Cleaning orphaned obd %s\n", extraname);
1454                         obd->obd_force = 1;
1455                         class_manual_cleanup(obd);
1456                 }
1457                 OBD_FREE(extraname, strlen(extraname) + 1);
1458         }
1459
1460         LCONSOLE_WARN("server umount %s complete\n", tmpname);
1461         OBD_FREE(tmpname, tmpname_sz);
1462         EXIT;
1463 }
1464
1465 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1466 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
1467 {
1468         struct super_block *sb = vfsmnt->mnt_sb;
1469 #else
1470 static void server_umount_begin(struct super_block *sb)
1471 {
1472 #endif
1473         struct lustre_sb_info *lsi = s2lsi(sb);
1474         ENTRY;
1475
1476 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1477         if (!(flags & MNT_FORCE)) {
1478                 EXIT;
1479                 return;
1480         }
1481 #endif
1482
1483         CDEBUG(D_MOUNT, "umount -f\n");
1484         /* umount = failover
1485            umount -f = force
1486            no third way to do non-force, non-failover */
1487         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
1488         lsi->lsi_flags |= LSI_UMOUNT_FORCE;
1489         EXIT;
1490 }
1491
1492 #ifndef HAVE_STATFS_DENTRY_PARAM
1493 static int server_statfs (struct super_block *sb, struct kstatfs *buf)
1494 {
1495 #else
1496 static int server_statfs (struct dentry *dentry, struct kstatfs *buf)
1497 {
1498         struct super_block *sb = dentry->d_sb;
1499 #endif
1500         struct vfsmount *mnt = s2lsi(sb)->lsi_srv_mnt;
1501         ENTRY;
1502
1503         if (mnt && mnt->mnt_sb && mnt->mnt_sb->s_op->statfs) {
1504 #ifdef HAVE_STATFS_DENTRY_PARAM
1505                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_root, buf);
1506 #else
1507                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_sb, buf);
1508 #endif
1509                 if (!rc) {
1510                         buf->f_type = sb->s_magic;
1511                         RETURN(0);
1512                 }
1513         }
1514
1515         /* just return 0 */
1516         buf->f_type = sb->s_magic;
1517         buf->f_bsize = sb->s_blocksize;
1518         buf->f_blocks = 1;
1519         buf->f_bfree = 0;
1520         buf->f_bavail = 0;
1521         buf->f_files = 1;
1522         buf->f_ffree = 0;
1523         buf->f_namelen = NAME_MAX;
1524         RETURN(0);
1525 }
1526
1527 static struct super_operations server_ops =
1528 {
1529         .put_super      = server_put_super,
1530         .umount_begin   = server_umount_begin, /* umount -f */
1531         .statfs         = server_statfs,
1532 };
1533
1534 #define log2(n) ffz(~(n))
1535 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
1536
1537 static int server_fill_super_common(struct super_block *sb)
1538 {
1539         struct inode *root = 0;
1540         ENTRY;
1541
1542         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
1543
1544         sb->s_blocksize = 4096;
1545         sb->s_blocksize_bits = log2(sb->s_blocksize);
1546         sb->s_magic = LUSTRE_SUPER_MAGIC;
1547         sb->s_maxbytes = 0; //PAGE_CACHE_MAXBYTES;
1548         sb->s_flags |= MS_RDONLY;
1549         sb->s_op = &server_ops;
1550
1551         root = new_inode(sb);
1552         if (!root) {
1553                 CERROR("Can't make root inode\n");
1554                 RETURN(-EIO);
1555         }
1556
1557         /* returns -EIO for every operation */
1558         /* make_bad_inode(root); -- badness - can't umount */
1559         /* apparently we need to be a directory for the mount to finish */
1560         root->i_mode = S_IFDIR;
1561
1562         sb->s_root = d_alloc_root(root);
1563         if (!sb->s_root) {
1564                 CERROR("Can't make root dentry\n");
1565                 iput(root);
1566                 RETURN(-EIO);
1567         }
1568
1569         RETURN(0);
1570 }
1571
1572 static int server_fill_super(struct super_block *sb)
1573 {
1574         struct lustre_sb_info *lsi = s2lsi(sb);
1575         struct vfsmount *mnt;
1576         int rc;
1577         ENTRY;
1578
1579         /* the One True Mount */
1580         mnt = server_kernel_mount(sb);
1581         if (IS_ERR(mnt)) {
1582                 rc = PTR_ERR(mnt);
1583                 CERROR("Unable to mount device %s: %d\n",
1584                        lsi->lsi_lmd->lmd_dev, rc);
1585                 lustre_put_lsi(sb);
1586                 RETURN(rc);
1587         }
1588         lsi->lsi_srv_mnt = mnt;
1589
1590         LASSERT(lsi->lsi_ldd);
1591         CDEBUG(D_MOUNT, "Found service %s for fs '%s' on device %s\n",
1592                lsi->lsi_ldd->ldd_svname, lsi->lsi_ldd->ldd_fsname,
1593                lsi->lsi_lmd->lmd_dev);
1594
1595         if (class_name2obd(lsi->lsi_ldd->ldd_svname)) {
1596                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
1597                                    "running. Double-mount may have compromised"
1598                                    " the disk journal.\n",
1599                                    lsi->lsi_ldd->ldd_svname);
1600                 lustre_put_lsi(sb);
1601                 unlock_mntput(mnt);
1602                 RETURN(-EALREADY);
1603         }
1604
1605         /* Start MGS before MGC */
1606         if (IS_MGS(lsi->lsi_ldd) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)) {
1607                 rc = server_start_mgs(sb);
1608                 if (rc)
1609                         GOTO(out_mnt, rc);
1610         }
1611
1612         rc = lustre_start_mgc(sb);
1613         if (rc)
1614                 GOTO(out_mnt, rc);
1615
1616         /* Set up all obd devices for service */
1617         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1618                 (IS_OST(lsi->lsi_ldd) || IS_MDT(lsi->lsi_ldd))) {
1619                 rc = server_start_targets(sb, mnt);
1620                 if (rc < 0) {
1621                         CERROR("Unable to start targets: %d\n", rc);
1622                         GOTO(out_mnt, rc);
1623                 }
1624         /* FIXME overmount client here,
1625            or can we just start a client log and client_fill_super on this sb?
1626            We need to make sure server_put_super gets called too - ll_put_super
1627            calls lustre_common_put_super; check there for LSI_SERVER flag,
1628            call s_p_s if so.
1629            Probably should start client from new thread so we can return.
1630            Client will not finish until all servers are connected.
1631            Note - MGS-only server does NOT get a client, since there is no
1632            lustre fs associated - the MGS is for all lustre fs's */
1633         }
1634
1635         rc = server_fill_super_common(sb);
1636         if (rc)
1637                 GOTO(out_mnt, rc);
1638
1639         LCONSOLE_WARN("Server %s on device %s has started\n",
1640                       lsi->lsi_ldd->ldd_svname, lsi->lsi_lmd->lmd_dev);
1641
1642         RETURN(0);
1643 out_mnt:
1644         /* We jump here in case of failure while starting targets or MGS.
1645          * In this case we can't just put @mnt and have to do real cleanup
1646          * with stoping targets, etc. */
1647         server_put_super(sb);
1648         return rc;
1649 }
1650
1651 /* Get the index from the obd name.
1652    rc = server type, or
1653    rc < 0  on error
1654    if endptr isn't NULL it is set to end of name */
1655 int server_name2index(char *svname, __u32 *idx, char **endptr)
1656 {
1657         unsigned long index;
1658         int rc;
1659         char *dash = strchr(svname, '-');
1660         if (!dash)
1661                 return(-EINVAL);
1662
1663         if (strncmp(dash + 1, "MDT", 3) == 0)
1664                 rc = LDD_F_SV_TYPE_MDT;
1665         else if (strncmp(dash + 1, "OST", 3) == 0)
1666                 rc = LDD_F_SV_TYPE_OST;
1667         else
1668                 return(-EINVAL);
1669
1670         index = simple_strtoul(dash + 4, endptr, 16);
1671         *idx = index;
1672         return rc;
1673 }
1674
1675 /*************** mount common betweeen server and client ***************/
1676
1677 /* Common umount */
1678 int lustre_common_put_super(struct super_block *sb)
1679 {
1680         int rc;
1681         ENTRY;
1682
1683         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
1684
1685         /* Drop a ref to the MGC */
1686         rc = lustre_stop_mgc(sb);
1687         if (rc && (rc != -ENOENT)) {
1688                 if (rc != -EBUSY) {
1689                         CERROR("Can't stop MGC: %d\n", rc);
1690                         RETURN(rc);
1691                 }
1692                 /* BUSY just means that there's some other obd that
1693                    needs the mgc.  Let him clean it up. */
1694                 CDEBUG(D_MOUNT, "MGC still in use\n");
1695         }
1696         /* Drop a ref to the mounted disk */
1697         lustre_put_lsi(sb);
1698         lu_types_stop();
1699         RETURN(rc);
1700 }
1701
1702 #if 0
1703 static void lmd_print(struct lustre_mount_data *lmd)
1704 {
1705         int i;
1706
1707         PRINT_CMD(PRINT_MASK, "  mount data:\n");
1708         if (lmd_is_client(lmd))
1709                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
1710         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
1711         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
1712         if (lmd->lmd_opts)
1713                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
1714         for (i = 0; i < lmd->lmd_exclude_count; i++) {
1715                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
1716                           lmd->lmd_exclude[i]);
1717         }
1718 }
1719 #endif
1720
1721 /* Is this server on the exclusion list */
1722 int lustre_check_exclusion(struct super_block *sb, char *svname)
1723 {
1724         struct lustre_sb_info *lsi = s2lsi(sb);
1725         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1726         __u32 index;
1727         int i, rc;
1728         ENTRY;
1729
1730         rc = server_name2index(svname, &index, NULL);
1731         if (rc != LDD_F_SV_TYPE_OST)
1732                 /* Only exclude OSTs */
1733                 RETURN(0);
1734
1735         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
1736                index, lmd->lmd_exclude_count, lmd->lmd_dev);
1737
1738         for(i = 0; i < lmd->lmd_exclude_count; i++) {
1739                 if (index == lmd->lmd_exclude[i]) {
1740                         CWARN("Excluding %s (on exclusion list)\n", svname);
1741                         RETURN(1);
1742                 }
1743         }
1744         RETURN(0);
1745 }
1746
1747 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
1748 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
1749 {
1750         char *s1 = ptr, *s2;
1751         __u32 index, *exclude_list;
1752         int rc = 0, devmax;
1753         ENTRY;
1754
1755         /* The shortest an ost name can be is 8 chars: -OST0000.
1756            We don't actually know the fsname at this time, so in fact
1757            a user could specify any fsname. */
1758         devmax = strlen(ptr) / 8 + 1;
1759
1760         /* temp storage until we figure out how many we have */
1761         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
1762         if (!exclude_list)
1763                 RETURN(-ENOMEM);
1764
1765         /* we enter this fn pointing at the '=' */
1766         while (*s1 && *s1 != ' ' && *s1 != ',') {
1767                 s1++;
1768                 rc = server_name2index(s1, &index, &s2);
1769                 if (rc < 0) {
1770                         CERROR("Can't parse server name '%s'\n", s1);
1771                         break;
1772                 }
1773                 if (rc == LDD_F_SV_TYPE_OST)
1774                         exclude_list[lmd->lmd_exclude_count++] = index;
1775                 else
1776                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
1777                 s1 = s2;
1778                 /* now we are pointing at ':' (next exclude)
1779                    or ',' (end of excludes) */
1780                 if (lmd->lmd_exclude_count >= devmax)
1781                         break;
1782         }
1783         if (rc >= 0) /* non-err */
1784                 rc = 0;
1785
1786         if (lmd->lmd_exclude_count) {
1787                 /* permanent, freed in lustre_free_lsi */
1788                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
1789                           lmd->lmd_exclude_count);
1790                 if (lmd->lmd_exclude) {
1791                         memcpy(lmd->lmd_exclude, exclude_list,
1792                                sizeof(index) * lmd->lmd_exclude_count);
1793                 } else {
1794                         rc = -ENOMEM;
1795                         lmd->lmd_exclude_count = 0;
1796                 }
1797         }
1798         OBD_FREE(exclude_list, sizeof(index) * devmax);
1799         RETURN(rc);
1800 }
1801
1802 /* mount -v -t lustre uml1:uml2:/lustre-client /mnt/lustre */
1803 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
1804 {
1805         char *s1, *s2, *devname = NULL;
1806         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
1807         int rc = 0;
1808         ENTRY;
1809
1810         LASSERT(lmd);
1811         if (!options) {
1812                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
1813                                    "/sbin/mount.lustre is installed.\n");
1814                 RETURN(-EINVAL);
1815         }
1816
1817         /* Options should be a string - try to detect old lmd data */
1818         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
1819                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
1820                                    "/sbin/mount.lustre.  Please install "
1821                                    "version %s\n", LUSTRE_VERSION_STRING);
1822                 RETURN(-EINVAL);
1823         }
1824         lmd->lmd_magic = LMD_MAGIC;
1825
1826         /* Set default flags here */
1827
1828         s1 = options;
1829         while (*s1) {
1830                 int clear = 0;
1831                 /* Skip whitespace and extra commas */
1832                 while (*s1 == ' ' || *s1 == ',')
1833                         s1++;
1834
1835                 /* Client options are parsed in ll_options: eg. flock,
1836                    user_xattr, acl */
1837
1838                 /* Parse non-ldiskfs options here. Rather than modifying
1839                    ldiskfs, we just zero these out here */
1840                 if (strncmp(s1, "abort_recov", 11) == 0) {
1841                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
1842                         clear++;
1843                 } else if (strncmp(s1, "nosvc", 5) == 0) {
1844                         lmd->lmd_flags |= LMD_FLG_NOSVC;
1845                         clear++;
1846                 } else if (strncmp(s1, "nomgs", 5) == 0) {
1847                         lmd->lmd_flags |= LMD_FLG_NOMGS;
1848                         clear++;
1849                 /* ost exclusion list */
1850                 } else if (strncmp(s1, "exclude=", 8) == 0) {
1851                         rc = lmd_make_exclusion(lmd, s1 + 7);
1852                         if (rc)
1853                                 goto invalid;
1854                         clear++;
1855                 }
1856                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
1857                    end of the options. */
1858                 else if (strncmp(s1, "device=", 7) == 0) {
1859                         devname = s1 + 7;
1860                         /* terminate options right before device.  device
1861                            must be the last one. */
1862                         *s1 = '\0';
1863                         break;
1864                 }
1865
1866                 /* Find next opt */
1867                 s2 = strchr(s1, ',');
1868                 if (s2 == NULL) {
1869                         if (clear)
1870                                 *s1 = '\0';
1871                         break;
1872                 }
1873                 s2++;
1874                 if (clear)
1875                         memmove(s1, s2, strlen(s2) + 1);
1876                 else
1877                         s1 = s2;
1878         }
1879
1880         if (!devname) {
1881                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
1882                                    "(need mount option 'device=...')\n");
1883                 goto invalid;
1884         }
1885
1886         s1 = strstr(devname, ":/");
1887         if (s1) {
1888                 ++s1;
1889                 lmd->lmd_flags = LMD_FLG_CLIENT;
1890                 /* Remove leading /s from fsname */
1891                 while (*++s1 == '/') ;
1892                 /* Freed in lustre_free_lsi */
1893                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
1894                 if (!lmd->lmd_profile)
1895                         RETURN(-ENOMEM);
1896                 sprintf(lmd->lmd_profile, "%s-client", s1);
1897         }
1898
1899         /* Freed in lustre_free_lsi */
1900         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
1901         if (!lmd->lmd_dev)
1902                 RETURN(-ENOMEM);
1903         strcpy(lmd->lmd_dev, devname);
1904
1905         /* Save mount options */
1906         s1 = options + strlen(options) - 1;
1907         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
1908                 *s1-- = 0;
1909         if (*options != 0) {
1910                 /* Freed in lustre_free_lsi */
1911                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
1912                 if (!lmd->lmd_opts)
1913                         RETURN(-ENOMEM);
1914                 strcpy(lmd->lmd_opts, options);
1915         }
1916
1917         lmd->lmd_magic = LMD_MAGIC;
1918
1919         RETURN(rc);
1920
1921 invalid:
1922         CERROR("Bad mount options %s\n", options);
1923         RETURN(-EINVAL);
1924 }
1925
1926
1927 /* Common mount */
1928 int lustre_fill_super(struct super_block *sb, void *data, int silent)
1929 {
1930         struct lustre_mount_data *lmd;
1931         struct lustre_sb_info *lsi;
1932         int rc;
1933         ENTRY;
1934
1935         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
1936
1937         lsi = lustre_init_lsi(sb);
1938         if (!lsi)
1939                 RETURN(-ENOMEM);
1940         lmd = lsi->lsi_lmd;
1941
1942         /*
1943          * Disable lockdep during mount, because mount locking patterns are
1944          * `special'.
1945          */
1946         lockdep_off();
1947
1948         /* Figure out the lmd from the mount options */
1949         if (lmd_parse((char *)data, lmd)) {
1950                 lustre_put_lsi(sb);
1951                 GOTO(out, rc = -EINVAL);
1952         }
1953
1954         if (lmd_is_client(lmd)) {
1955                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
1956                 if (!client_fill_super) {
1957                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
1958                                            "client mount! Is the 'lustre' "
1959                                            "module loaded?\n");
1960                         lustre_put_lsi(sb);
1961                         rc = -ENODEV;
1962                 } else {
1963                         rc = lustre_start_mgc(sb);
1964                         if (rc) {
1965                                 lustre_put_lsi(sb);
1966                                 GOTO(out, rc);
1967                         }
1968                         /* Connect and start */
1969                         /* (should always be ll_fill_super) */
1970                         rc = (*client_fill_super)(sb);
1971                         /* c_f_s will call lustre_common_put_super on failure */
1972                 }
1973         } else {
1974                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
1975                 lsi->lsi_flags |= LSI_SERVER;
1976                 rc = server_fill_super(sb);
1977                 /* s_f_s calls lustre_start_mgc after the mount because we need
1978                    the MGS nids which are stored on disk.  Plus, we may
1979                    need to start the MGS first. */
1980                 /* s_f_s will call server_put_super on failure */
1981         }
1982
1983         /* If error happens in fill_super() call, @lsi will be killed there.
1984          * This is why we do not put it here. */
1985         GOTO(out, rc);
1986 out:
1987         if (rc) {
1988                 CERROR("Unable to mount %s (%d)\n",
1989                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
1990         } else {
1991                 CDEBUG(D_SUPER, "Mount %s complete\n",
1992                        lmd->lmd_dev);
1993         }
1994         lockdep_on();
1995         return rc;
1996 }
1997
1998
1999 /* We can't call ll_fill_super by name because it lives in a module that
2000    must be loaded after this one. */
2001 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb))
2002 {
2003         client_fill_super = cfs;
2004 }
2005
2006 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
2007 {
2008         kill_super_cb = cfs;
2009 }
2010
2011 /***************** FS registration ******************/
2012
2013 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
2014 struct super_block * lustre_get_sb(struct file_system_type *fs_type,
2015                                int flags, const char *devname, void * data)
2016 {
2017         return get_sb_nodev(fs_type, flags, data, lustre_fill_super);
2018 }
2019 #else
2020 int lustre_get_sb(struct file_system_type *fs_type,
2021                                int flags, const char *devname, void * data,
2022                                struct vfsmount *mnt)
2023 {
2024         return get_sb_nodev(fs_type, flags, data, lustre_fill_super, mnt);
2025 }
2026 #endif
2027
2028 void lustre_kill_super(struct super_block *sb)
2029 {
2030         struct lustre_sb_info *lsi = s2lsi(sb);
2031
2032         if (kill_super_cb && lsi && !(lsi->lsi_flags & LSI_SERVER))
2033                 (*kill_super_cb)(sb);
2034
2035         kill_anon_super(sb);
2036 }
2037
2038 struct file_system_type lustre_fs_type = {
2039         .owner        = THIS_MODULE,
2040         .name         = "lustre",
2041         .get_sb       = lustre_get_sb,
2042         .kill_sb      = lustre_kill_super,
2043         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
2044                         LL_RENAME_DOES_D_MOVE,
2045 };
2046
2047 int lustre_register_fs(void)
2048 {
2049         return register_filesystem(&lustre_fs_type);
2050 }
2051
2052 int lustre_unregister_fs(void)
2053 {
2054         return unregister_filesystem(&lustre_fs_type);
2055 }
2056
2057 EXPORT_SYMBOL(lustre_register_client_fill_super);
2058 EXPORT_SYMBOL(lustre_register_kill_super_cb);
2059 EXPORT_SYMBOL(lustre_common_put_super);
2060 EXPORT_SYMBOL(lustre_process_log);
2061 EXPORT_SYMBOL(lustre_end_log);
2062 EXPORT_SYMBOL(server_get_mount);
2063 EXPORT_SYMBOL(server_get_mount_2);
2064 EXPORT_SYMBOL(server_put_mount);
2065 EXPORT_SYMBOL(server_put_mount_2);
2066 EXPORT_SYMBOL(server_register_target);
2067 EXPORT_SYMBOL(server_name2index);
2068 EXPORT_SYMBOL(server_mti_print);
2069 EXPORT_SYMBOL(do_lcfg);