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 [sun.com URL with a
  20  * copy of GPLv2].
  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         if (!atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 795                 /* This is not fatal, every client that stops
 796                    will call in here. */
 797                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 798                        atomic_read(&obd->u.cli.cl_mgc_refcount));
 799                 GOTO(out, rc = -EBUSY);
 800         }
 801
 802         /* The MGC has no recoverable data in any case.
 803          * force shotdown set in umount_begin */
 804         obd->obd_no_recov = 1;
 805
 806         if (obd->u.cli.cl_mgc_mgsexp) {
 807                 /* An error is not fatal, if we are unable to send the
 808                    disconnect mgs ping evictor cleans up the export */
 809                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 810                 if (rc)
 811                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 812         }
 813
 814         /* Save the obdname for cleaning the nid uuids, which are
 815            obdname_XX */
 816         len = strlen(obd->obd_name) + 6;
 817         OBD_ALLOC(niduuid, len);
 818         if (niduuid) {
 819                 strcpy(niduuid, obd->obd_name);
 820                 ptr = niduuid + strlen(niduuid);
 821         }
 822
 823         rc = class_manual_cleanup(obd);
 824         if (rc)
 825                 GOTO(out, rc);
 826
 827         /* Clean the nid uuids */
 828         if (!niduuid)
 829                 RETURN(-ENOMEM);
 830         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 831                 sprintf(ptr, "_%x", i);
 832                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 833                              niduuid, 0, 0, 0);
 834                 if (rc)
 835                         CERROR("del MDC UUID %s failed: rc = %d\n",
 836                                niduuid, rc);
 837         }
 838         OBD_FREE(niduuid, len);
 839         /* class_import_put will get rid of the additional connections */
 840
 841 out:
 842         mutex_up(&mgc_start_lock);
 843         RETURN(rc);
 844 }
 845
 846 /* Since there's only one mgc per node, we have to change it's fs to get
 847    access to the right disk. */
 848 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
 849 {
 850         struct lustre_sb_info *lsi = s2lsi(sb);
 851         int rc;
 852         ENTRY;
 853
 854         CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
 855
 856         /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
 857         rc = obd_set_info_async(mgc->obd_self_export,
 858                                 sizeof(KEY_SET_FS), KEY_SET_FS,
 859                                 sizeof(*sb), sb, NULL);
 860         if (rc) {
 861                 CERROR("can't set_fs %d\n", rc);
 862         }
 863
 864         RETURN(rc);
 865 }
 866
 867 static int server_mgc_clear_fs(struct obd_device *mgc)
 868 {
 869         int rc;
 870         ENTRY;
 871
 872         CDEBUG(D_MOUNT, "Unassign mgc disk\n");
 873
 874         rc = obd_set_info_async(mgc->obd_self_export,
 875                                 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
 876                                 0, NULL, NULL);
 877         RETURN(rc);
 878 }
 879
 880 DECLARE_MUTEX(server_start_lock);
 881
 882 /* Stop MDS/OSS if nobody is using them */
 883 static int server_stop_servers(int lddflags, int lsiflags)
 884 {
 885         struct obd_device *obd = NULL;
 886         struct obd_type *type = NULL;
 887         int rc = 0;
 888         ENTRY;
 889
 890         mutex_down(&server_start_lock);
 891
 892         /* Either an MDT or an OST or neither  */
 893         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
 894         if ((lddflags & LDD_F_SV_TYPE_MDT) &&
 895             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
 896                 /*FIXME pre-rename, should eventually be LUSTRE_MDT_NAME*/
 897                 type = class_search_type(LUSTRE_MDS_NAME);
 898         }
 899         /* if this was an OST, and there are no more OST's, clean up the OSS */
 900         if ((lddflags & LDD_F_SV_TYPE_OST) &&
 901             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
 902                 type = class_search_type(LUSTRE_OST_NAME);
 903         }
 904
 905         if (obd && (!type || !type->typ_refcnt)) {
 906                 int err;
 907                 obd->obd_force = 1;
 908                 /* obd_fail doesn't mean much on a server obd */
 909                 err = class_manual_cleanup(obd);
 910                 if (!rc)
 911                         rc = err;
 912         }
 913
 914         mutex_up(&server_start_lock);
 915
 916         RETURN(rc);
 917 }
 918
 919 int server_mti_print(char *title, struct mgs_target_info *mti)
 920 {
 921         PRINT_CMD(PRINT_MASK, "mti %s\n", title);
 922         PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
 923         PRINT_CMD(PRINT_MASK, "fs:     %s\n", mti->mti_fsname);
 924         PRINT_CMD(PRINT_MASK, "uuid:   %s\n", mti->mti_uuid);
 925         PRINT_CMD(PRINT_MASK, "ver: %d  flags: %#x\n",
 926                   mti->mti_config_ver, mti->mti_flags);
 927         return(0);
 928 }
 929
 930 static int server_sb2mti(struct super_block *sb, struct mgs_target_info *mti)
 931 {
 932         struct lustre_sb_info    *lsi = s2lsi(sb);
 933         struct lustre_disk_data  *ldd = lsi->lsi_ldd;
 934         lnet_process_id_t         id;
 935         int i = 0;
 936         ENTRY;
 937
 938         if (!(lsi->lsi_flags & LSI_SERVER))
 939                 RETURN(-EINVAL);
 940
 941         strncpy(mti->mti_fsname, ldd->ldd_fsname,
 942                 sizeof(mti->mti_fsname));
 943         strncpy(mti->mti_svname, ldd->ldd_svname,
 944                 sizeof(mti->mti_svname));
 945
 946         mti->mti_nid_count = 0;
 947         while (LNetGetId(i++, &id) != -ENOENT) {
 948                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 949                         continue;
 950                 mti->mti_nids[mti->mti_nid_count] = id.nid;
 951                 mti->mti_nid_count++;
 952                 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
 953                         CWARN("Only using first %d nids for %s\n",
 954                               mti->mti_nid_count, mti->mti_svname);
 955                         break;
 956                 }
 957         }
 958
 959         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
 960         mti->mti_config_ver = 0;
 961         mti->mti_flags = ldd->ldd_flags;
 962         mti->mti_stripe_index = ldd->ldd_svindex;
 963         memcpy(mti->mti_uuid, ldd->ldd_uuid, sizeof(mti->mti_uuid));
 964         if (strlen(ldd->ldd_params) > sizeof(mti->mti_params)) {
 965                 CERROR("params too big for mti\n");
 966                 RETURN(-ENOMEM);
 967         }
 968         memcpy(mti->mti_params, ldd->ldd_params, sizeof(mti->mti_params));
 969         RETURN(0);
 970 }
 971
 972 /* Register an old or new target with the MGS. If needed MGS will construct
 973    startup logs and assign index */
 974 int server_register_target(struct super_block *sb)
 975 {
 976         struct lustre_sb_info *lsi = s2lsi(sb);
 977         struct obd_device *mgc = lsi->lsi_mgc;
 978         struct lustre_disk_data *ldd = lsi->lsi_ldd;
 979         struct mgs_target_info *mti = NULL;
 980         int rc;
 981         ENTRY;
 982
 983         LASSERT(mgc);
 984
 985         if (!(lsi->lsi_flags & LSI_SERVER))
 986                 RETURN(-EINVAL);
 987
 988         OBD_ALLOC_PTR(mti);
 989         if (!mti)
 990                 RETURN(-ENOMEM);
 991         rc = server_sb2mti(sb, mti);
 992         if (rc)
 993                 GOTO(out, rc);
 994
 995         CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
 996                mti->mti_svname, mti->mti_fsname,
 997                libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
 998                mti->mti_flags);
 999
1000         /* Register the target */
1001         /* FIXME use mgc_process_config instead */
1002         rc = obd_set_info_async(mgc->u.cli.cl_mgc_mgsexp,
1003                                 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1004                                 sizeof(*mti), mti, NULL);
1005         if (rc)
1006                 GOTO(out, rc);
1007
1008         /* Always update our flags */
1009         ldd->ldd_flags = mti->mti_flags & ~LDD_F_REWRITE_LDD;
1010
1011         /* If this flag is set, it means the MGS wants us to change our
1012            on-disk data. (So far this means just the index.) */
1013         if (mti->mti_flags & LDD_F_REWRITE_LDD) {
1014                 char *label;
1015                 int err;
1016                 CDEBUG(D_MOUNT, "Changing on-disk index from %#x to %#x "
1017                        "for %s\n", ldd->ldd_svindex, mti->mti_stripe_index,
1018                        mti->mti_svname);
1019                 ldd->ldd_svindex = mti->mti_stripe_index;
1020                 strncpy(ldd->ldd_svname, mti->mti_svname,
1021                         sizeof(ldd->ldd_svname));
1022                 /* or ldd_make_sv_name(ldd); */
1023                 ldd_write(&mgc->obd_lvfs_ctxt, ldd);
1024                 err = fsfilt_set_label(mgc, lsi->lsi_srv_mnt->mnt_sb,
1025                                        mti->mti_svname);
1026                 if (err)
1027                         CERROR("Label set error %d\n", err);
1028                 label = fsfilt_get_label(mgc, lsi->lsi_srv_mnt->mnt_sb);
1029                 if (label)
1030                         CDEBUG(D_MOUNT, "Disk label changed to %s\n", label);
1031
1032                 /* Flush the new ldd to disk */
1033                 fsfilt_sync(mgc, lsi->lsi_srv_mnt->mnt_sb);
1034         }
1035
1036 out:
1037         if (mti)
1038                 OBD_FREE_PTR(mti);
1039         RETURN(rc);
1040 }
1041
1042 /* Start targets */
1043 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1044 {
1045         struct obd_device *obd;
1046         struct lustre_sb_info *lsi = s2lsi(sb);
1047         struct config_llog_instance cfg;
1048         int rc;
1049         ENTRY;
1050
1051         CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_ldd->ldd_svname);
1052
1053 #if 0
1054         /* If we're an MDT, make sure the global MDS is running */
1055         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_MDT) {
1056                 /* make sure the MDS is started */
1057                 mutex_down(&server_start_lock);
1058                 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1059                 if (!obd) {
1060                         rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1061                     /* FIXME pre-rename, should eventually be LUSTRE_MDS_NAME */
1062                                                  LUSTRE_MDT_NAME,
1063                                                  LUSTRE_MDS_OBDNAME"_uuid",
1064                                                  0, 0);
1065                         if (rc) {
1066                                 mutex_up(&server_start_lock);
1067                                 CERROR("failed to start MDS: %d\n", rc);
1068                                 RETURN(rc);
1069                         }
1070                 }
1071                 mutex_up(&server_start_lock);
1072         }
1073 #endif
1074
1075         /* If we're an OST, make sure the global OSS is running */
1076         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_OST) {
1077                 /* make sure OSS is started */
1078                 mutex_down(&server_start_lock);
1079                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1080                 if (!obd) {
1081                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1082                                                  LUSTRE_OSS_NAME,
1083                                                  LUSTRE_OSS_OBDNAME"_uuid",
1084                                                  0, 0);
1085                         if (rc) {
1086                                 mutex_up(&server_start_lock);
1087                                 CERROR("failed to start OSS: %d\n", rc);
1088                                 RETURN(rc);
1089                         }
1090                 }
1091                 mutex_up(&server_start_lock);
1092         }
1093
1094         /* Set the mgc fs to our server disk.  This allows the MGC
1095            to read and write configs locally. */
1096         rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1097         if (rc)
1098                 RETURN(rc);
1099
1100         /* Register with MGS */
1101         rc = server_register_target(sb);
1102         if (rc && (lsi->lsi_ldd->ldd_flags &
1103                    (LDD_F_NEED_INDEX | LDD_F_UPDATE | LDD_F_UPGRADE14))){
1104                 CERROR("Required registration failed for %s: %d\n",
1105                        lsi->lsi_ldd->ldd_svname, rc);
1106                 if (rc == -EIO) {
1107                         LCONSOLE_ERROR_MSG(0x15f, "Communication error with "
1108                                            "the MGS.  Is the MGS running?\n");
1109                 }
1110                 GOTO(out_mgc, rc);
1111         }
1112         if (rc == -EINVAL) {
1113                 LCONSOLE_ERROR_MSG(0x160, "The MGS is refusing to allow this "
1114                                    "server (%s) to start. Please see messages"
1115                                    " on the MGS node.\n",
1116                                    lsi->lsi_ldd->ldd_svname);
1117                 GOTO(out_mgc, rc);
1118         }
1119         /* non-fatal error of registeration with MGS */
1120         if (rc)
1121                 CDEBUG(D_MOUNT, "Cannot register with MGS: %d\n", rc);
1122
1123         /* Let the target look up the mount using the target's name
1124            (we can't pass the sb or mnt through class_process_config.) */
1125         rc = server_register_mount(lsi->lsi_ldd->ldd_svname, sb, mnt);
1126         if (rc)
1127                 GOTO(out_mgc, rc);
1128
1129         /* Start targets using the llog named for the target */
1130         memset(&cfg, 0, sizeof(cfg));
1131         rc = lustre_process_log(sb, lsi->lsi_ldd->ldd_svname, &cfg);
1132         if (rc) {
1133                 CERROR("failed to start server %s: %d\n",
1134                        lsi->lsi_ldd->ldd_svname, rc);
1135                 GOTO(out_mgc, rc);
1136         }
1137
1138 out_mgc:
1139         /* Release the mgc fs for others to use */
1140         server_mgc_clear_fs(lsi->lsi_mgc);
1141
1142         if (!rc) {
1143                 obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
1144                 if (!obd) {
1145                         CERROR("no server named %s was started\n",
1146                                lsi->lsi_ldd->ldd_svname);
1147                         RETURN(-ENXIO);
1148                 }
1149
1150                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1151                     (OBP(obd, iocontrol))) {
1152                         obd_iocontrol(OBD_IOC_ABORT_RECOVERY,
1153                                       obd->obd_self_export, 0, NULL, NULL);
1154                 }
1155
1156                 /* log has been fully processed */
1157                 obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1158         }
1159
1160         RETURN(rc);
1161 }
1162
1163 /***************** lustre superblock **************/
1164
1165 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1166 {
1167         struct lustre_sb_info *lsi = NULL;
1168         ENTRY;
1169
1170         OBD_ALLOC(lsi, sizeof(*lsi));
1171         if (!lsi)
1172                 RETURN(NULL);
1173         OBD_ALLOC(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1174         if (!lsi->lsi_lmd) {
1175                 OBD_FREE(lsi, sizeof(*lsi));
1176                 RETURN(NULL);
1177         }
1178
1179         lsi->lsi_lmd->lmd_exclude_count = 0;
1180         s2lsi_nocast(sb) = lsi;
1181         /* we take 1 extra ref for our setup */
1182         atomic_set(&lsi->lsi_mounts, 1);
1183
1184         /* Default umount style */
1185         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1186
1187         RETURN(lsi);
1188 }
1189
1190 static int lustre_free_lsi(struct super_block *sb)
1191 {
1192         struct lustre_sb_info *lsi = s2lsi(sb);
1193         ENTRY;
1194
1195         if (!lsi)
1196                 RETURN(0);
1197
1198         CDEBUG(D_MOUNT, "Freeing lsi\n");
1199
1200         /* someone didn't call server_put_mount. */
1201         LASSERT(atomic_read(&lsi->lsi_mounts) == 0);
1202
1203         if (lsi->lsi_ldd != NULL)
1204                 OBD_FREE(lsi->lsi_ldd, sizeof(*lsi->lsi_ldd));
1205
1206         if (lsi->lsi_lmd != NULL) {
1207                 if (lsi->lsi_lmd->lmd_dev != NULL)
1208                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
1209                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
1210                 if (lsi->lsi_lmd->lmd_profile != NULL)
1211                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
1212                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
1213                 if (lsi->lsi_lmd->lmd_opts != NULL)
1214                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
1215                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
1216                 if (lsi->lsi_lmd->lmd_exclude_count)
1217                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1218                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1219                                  lsi->lsi_lmd->lmd_exclude_count);
1220                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1221         }
1222
1223         LASSERT(lsi->lsi_llsbi == NULL);
1224         OBD_FREE(lsi, sizeof(*lsi));
1225         s2lsi_nocast(sb) = NULL;
1226
1227         RETURN(0);
1228 }
1229
1230 /* The lsi has one reference for every server that is using the disk -
1231    e.g. MDT, MGS, and potentially MGC */
1232 static int lustre_put_lsi(struct super_block *sb)
1233 {
1234         struct lustre_sb_info *lsi = s2lsi(sb);
1235         ENTRY;
1236
1237         LASSERT(lsi);
1238
1239         CDEBUG(D_MOUNT, "put %p %d\n", sb, atomic_read(&lsi->lsi_mounts));
1240
1241         if (atomic_dec_and_test(&lsi->lsi_mounts)) {
1242                 lustre_free_lsi(sb);
1243                 RETURN(1);
1244         }
1245         RETURN(0);
1246 }
1247
1248 /*************** server mount ******************/
1249
1250 /* Kernel mount using mount options in MOUNT_DATA_FILE */
1251 static struct vfsmount *server_kernel_mount(struct super_block *sb)
1252 {
1253         struct lvfs_run_ctxt mount_ctxt;
1254         struct lustre_sb_info *lsi = s2lsi(sb);
1255         struct lustre_disk_data *ldd;
1256         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1257         struct vfsmount *mnt;
1258         char *options = NULL;
1259         unsigned long page, s_flags;
1260         struct page *__page;
1261         int rc;
1262         ENTRY;
1263
1264         OBD_ALLOC(ldd, sizeof(*ldd));
1265         if (!ldd)
1266                 RETURN(ERR_PTR(-ENOMEM));
1267
1268         /* In the past, we have always used flags = 0.
1269            Note ext3/ldiskfs can't be mounted ro. */
1270         s_flags = sb->s_flags;
1271
1272         /* Pre-mount ldiskfs to read the MOUNT_DATA_FILE */
1273         CDEBUG(D_MOUNT, "Pre-mount ldiskfs %s\n", lmd->lmd_dev);
1274         mnt = ll_kern_mount("ldiskfs", s_flags, lmd->lmd_dev, 0);
1275         if (IS_ERR(mnt)) {
1276                 rc = PTR_ERR(mnt);
1277                 CERROR("premount %s:%#lx ldiskfs failed: %d "
1278                         "Is the ldiskfs module available?\n",
1279                         lmd->lmd_dev, s_flags, rc );
1280                 GOTO(out_free, rc);
1281         }
1282
1283         OBD_SET_CTXT_MAGIC(&mount_ctxt);
1284         mount_ctxt.pwdmnt = mnt;
1285         mount_ctxt.pwd = mnt->mnt_root;
1286         mount_ctxt.fs = get_ds();
1287
1288         rc = ldd_parse(&mount_ctxt, ldd);
1289         unlock_mntput(mnt);
1290
1291         if (rc) {
1292                 CERROR("premount parse options failed: rc = %d\n", rc);
1293                 GOTO(out_free, rc);
1294         }
1295
1296         /* Done with our pre-mount, now do the real mount. */
1297
1298         /* Glom up mount options */
1299         OBD_PAGE_ALLOC(__page, CFS_ALLOC_STD);
1300         if (!__page)
1301                 GOTO(out_free, rc = -ENOMEM);
1302         page = (unsigned long)cfs_page_address(__page);
1303
1304         options = (char *)page;
1305         memset(options, 0, CFS_PAGE_SIZE);
1306         strncpy(options, ldd->ldd_mount_opts, CFS_PAGE_SIZE - 2);
1307
1308         /* Add in any mount-line options */
1309         if (lmd->lmd_opts && (*(lmd->lmd_opts) != 0)) {
1310                 int len = CFS_PAGE_SIZE - strlen(options) - 2;
1311                 if (*options != 0)
1312                         strcat(options, ",");
1313                 strncat(options, lmd->lmd_opts, len);
1314         }
1315
1316         /* Special permanent mount flags */
1317         if (IS_OST(ldd))
1318             s_flags |= MS_NOATIME | MS_NODIRATIME;
1319
1320         CDEBUG(D_MOUNT, "kern_mount: %s %s %s\n",
1321                MT_STR(ldd), lmd->lmd_dev, options);
1322         mnt = ll_kern_mount(MT_STR(ldd), s_flags, lmd->lmd_dev,
1323                             (void *)options);
1324         OBD_PAGE_FREE(__page);
1325         if (IS_ERR(mnt)) {
1326                 rc = PTR_ERR(mnt);
1327                 CERROR("ll_kern_mount failed: rc = %d\n", rc);
1328                 GOTO(out_free, rc);
1329         }
1330
1331         lsi->lsi_ldd = ldd;   /* freed at lsi cleanup */
1332         CDEBUG(D_SUPER, "%s: mnt = %p\n", lmd->lmd_dev, mnt);
1333         RETURN(mnt);
1334
1335 out_free:
1336         OBD_FREE(ldd, sizeof(*ldd));
1337         lsi->lsi_ldd = NULL;
1338         RETURN(ERR_PTR(rc));
1339 }
1340
1341 static void server_wait_finished(struct vfsmount *mnt)
1342 {
1343         wait_queue_head_t   waitq;
1344         struct l_wait_info  lwi;
1345         int                 retries = 330;
1346
1347         init_waitqueue_head(&waitq);
1348
1349         while ((atomic_read(&mnt->mnt_count) > 1) && (retries > 0)) {
1350                 LCONSOLE_WARN("Mount still busy with %d refs, waiting for "
1351                               "%d secs...\n",
1352                               atomic_read(&mnt->mnt_count), retries);
1353
1354                 /* Wait for a bit */
1355                 retries -= 5;
1356                 lwi = LWI_TIMEOUT(5 * HZ, NULL, NULL);
1357                 l_wait_event(waitq, 0, &lwi);
1358         }
1359         if (atomic_read(&mnt->mnt_count) > 1) {
1360                 CERROR("Mount %p is still busy (%d refs), giving up.\n",
1361                        mnt, atomic_read(&mnt->mnt_count));
1362         }
1363 }
1364
1365 static void server_put_super(struct super_block *sb)
1366 {
1367         struct lustre_sb_info *lsi = s2lsi(sb);
1368         struct obd_device     *obd;
1369         struct vfsmount       *mnt = lsi->lsi_srv_mnt;
1370         char *tmpname, *extraname = NULL;
1371         int tmpname_sz;
1372         int lddflags = lsi->lsi_ldd->ldd_flags;
1373         int lsiflags = lsi->lsi_flags;
1374         int rc;
1375         ENTRY;
1376
1377         LASSERT(lsiflags & LSI_SERVER);
1378
1379         tmpname_sz = strlen(lsi->lsi_ldd->ldd_svname) + 1;
1380         OBD_ALLOC(tmpname, tmpname_sz);
1381         memcpy(tmpname, lsi->lsi_ldd->ldd_svname, tmpname_sz);
1382         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
1383
1384         /* Stop the target */
1385         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1386             (IS_MDT(lsi->lsi_ldd) || IS_OST(lsi->lsi_ldd))) {
1387                 struct lustre_profile *lprof = NULL;
1388
1389                 /* tell the mgc to drop the config log */
1390                 lustre_end_log(sb, lsi->lsi_ldd->ldd_svname, NULL);
1391
1392                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
1393                    If there are any setup/cleanup errors, save the lov
1394                    name for safety cleanup later. */
1395                 lprof = class_get_profile(lsi->lsi_ldd->ldd_svname);
1396                 if (lprof && lprof->lp_dt) {
1397                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
1398                         strcpy(extraname, lprof->lp_dt);
1399                 }
1400
1401                 obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
1402                 if (obd) {
1403                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
1404                         if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
1405                                 obd->obd_fail = 1;
1406                         /* We can't seem to give an error return code
1407                          * to .put_super, so we better make sure we clean up! */
1408                         obd->obd_force = 1;
1409                         class_manual_cleanup(obd);
1410                 } else {
1411                         CERROR("no obd %s\n", lsi->lsi_ldd->ldd_svname);
1412                         server_deregister_mount(lsi->lsi_ldd->ldd_svname);
1413                 }
1414         }
1415
1416         /* If they wanted the mgs to stop separately from the mdt, they
1417            should have put it on a different device. */
1418         if (IS_MGS(lsi->lsi_ldd)) {
1419                 /* stop the mgc before the mgs so the connection gets cleaned
1420                    up */
1421                 lustre_stop_mgc(sb);
1422                 /* if MDS start with --nomgs, don't stop MGS then */
1423                 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
1424                         server_stop_mgs(sb);
1425         }
1426
1427         /* Clean the mgc and sb */
1428         rc = lustre_common_put_super(sb);
1429         /* FIXME how can I report a failure to umount? */
1430
1431         /* Wait for the targets to really clean up - can't exit (and let the
1432            sb get destroyed) while the mount is still in use */
1433         server_wait_finished(mnt);
1434
1435         /* drop the One True Mount */
1436         unlock_mntput(mnt);
1437
1438         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
1439            until the target is really gone so that our type refcount check
1440            is right. */
1441         server_stop_servers(lddflags, lsiflags);
1442
1443         /* In case of startup or cleanup err, stop related obds */
1444         if (extraname) {
1445                 obd = class_name2obd(extraname);
1446                 if (obd) {
1447                         CWARN("Cleaning orphaned obd %s\n", extraname);
1448                         obd->obd_force = 1;
1449                         class_manual_cleanup(obd);
1450                 }
1451                 OBD_FREE(extraname, strlen(extraname) + 1);
1452         }
1453
1454         LCONSOLE_WARN("server umount %s complete\n", tmpname);
1455         OBD_FREE(tmpname, tmpname_sz);
1456         EXIT;
1457 }
1458
1459 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1460 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
1461 {
1462         struct super_block *sb = vfsmnt->mnt_sb;
1463 #else
1464 static void server_umount_begin(struct super_block *sb)
1465 {
1466 #endif
1467         struct lustre_sb_info *lsi = s2lsi(sb);
1468         ENTRY;
1469
1470 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1471         if (!(flags & MNT_FORCE)) {
1472                 EXIT;
1473                 return;
1474         }
1475 #endif
1476
1477         CDEBUG(D_MOUNT, "umount -f\n");
1478         /* umount = failover
1479            umount -f = force
1480            no third way to do non-force, non-failover */
1481         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
1482         lsi->lsi_flags |= LSI_UMOUNT_FORCE;
1483         EXIT;
1484 }
1485
1486 #ifndef HAVE_STATFS_DENTRY_PARAM
1487 static int server_statfs (struct super_block *sb, struct kstatfs *buf)
1488 {
1489 #else
1490 static int server_statfs (struct dentry *dentry, struct kstatfs *buf)
1491 {
1492         struct super_block *sb = dentry->d_sb;
1493 #endif
1494         struct vfsmount *mnt = s2lsi(sb)->lsi_srv_mnt;
1495         ENTRY;
1496
1497         if (mnt && mnt->mnt_sb && mnt->mnt_sb->s_op->statfs) {
1498 #ifdef HAVE_STATFS_DENTRY_PARAM
1499                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_root, buf);
1500 #else
1501                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_sb, buf);
1502 #endif
1503                 if (!rc) {
1504                         buf->f_type = sb->s_magic;
1505                         RETURN(0);
1506                 }
1507         }
1508
1509         /* just return 0 */
1510         buf->f_type = sb->s_magic;
1511         buf->f_bsize = sb->s_blocksize;
1512         buf->f_blocks = 1;
1513         buf->f_bfree = 0;
1514         buf->f_bavail = 0;
1515         buf->f_files = 1;
1516         buf->f_ffree = 0;
1517         buf->f_namelen = NAME_MAX;
1518         RETURN(0);
1519 }
1520
1521 static struct super_operations server_ops =
1522 {
1523         .put_super      = server_put_super,
1524         .umount_begin   = server_umount_begin, /* umount -f */
1525         .statfs         = server_statfs,
1526 };
1527
1528 #define log2(n) ffz(~(n))
1529 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
1530
1531 static int server_fill_super_common(struct super_block *sb)
1532 {
1533         struct inode *root = 0;
1534         ENTRY;
1535
1536         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
1537
1538         sb->s_blocksize = 4096;
1539         sb->s_blocksize_bits = log2(sb->s_blocksize);
1540         sb->s_magic = LUSTRE_SUPER_MAGIC;
1541         sb->s_maxbytes = 0; //PAGE_CACHE_MAXBYTES;
1542         sb->s_flags |= MS_RDONLY;
1543         sb->s_op = &server_ops;
1544
1545         root = new_inode(sb);
1546         if (!root) {
1547                 CERROR("Can't make root inode\n");
1548                 RETURN(-EIO);
1549         }
1550
1551         /* returns -EIO for every operation */
1552         /* make_bad_inode(root); -- badness - can't umount */
1553         /* apparently we need to be a directory for the mount to finish */
1554         root->i_mode = S_IFDIR;
1555
1556         sb->s_root = d_alloc_root(root);
1557         if (!sb->s_root) {
1558                 CERROR("Can't make root dentry\n");
1559                 iput(root);
1560                 RETURN(-EIO);
1561         }
1562
1563         RETURN(0);
1564 }
1565
1566 static int server_fill_super(struct super_block *sb)
1567 {
1568         struct lustre_sb_info *lsi = s2lsi(sb);
1569         struct vfsmount *mnt;
1570         int rc;
1571         ENTRY;
1572
1573         /* the One True Mount */
1574         mnt = server_kernel_mount(sb);
1575         if (IS_ERR(mnt)) {
1576                 rc = PTR_ERR(mnt);
1577                 CERROR("Unable to mount device %s: %d\n",
1578                       lsi->lsi_lmd->lmd_dev, rc);
1579                 lustre_put_lsi(sb);
1580                 GOTO(out, rc);
1581         }
1582         lsi->lsi_srv_mnt = mnt;
1583
1584         LASSERT(lsi->lsi_ldd);
1585         CDEBUG(D_MOUNT, "Found service %s for fs '%s' on device %s\n",
1586                lsi->lsi_ldd->ldd_svname, lsi->lsi_ldd->ldd_fsname,
1587                lsi->lsi_lmd->lmd_dev);
1588
1589         if (class_name2obd(lsi->lsi_ldd->ldd_svname)) {
1590                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
1591                                    "running. Double-mount may have compromised"
1592                                    " the disk journal.\n",
1593                                    lsi->lsi_ldd->ldd_svname);
1594                 unlock_mntput(mnt);
1595                 lustre_put_lsi(sb);
1596                 GOTO(out, rc = -EALREADY);
1597         }
1598
1599         /* start MGS before MGC */
1600         if (IS_MGS(lsi->lsi_ldd) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)) {
1601                 rc = server_start_mgs(sb);
1602                 if (rc)
1603                         GOTO(out_mnt, rc);
1604         }
1605
1606         rc = lustre_start_mgc(sb);
1607         if (rc)
1608                 GOTO(out_mnt, rc);
1609
1610         /* Set up all obd devices for service */
1611         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1612                 (IS_OST(lsi->lsi_ldd) || IS_MDT(lsi->lsi_ldd))) {
1613                 rc = server_start_targets(sb, mnt);
1614                 if (rc < 0) {
1615                         CERROR("Unable to start targets: %d\n", rc);
1616                         GOTO(out_mnt, rc);
1617                 }
1618         /* FIXME overmount client here,
1619            or can we just start a client log and client_fill_super on this sb?
1620            We need to make sure server_put_super gets called too - ll_put_super
1621            calls lustre_common_put_super; check there for LSI_SERVER flag,
1622            call s_p_s if so.
1623            Probably should start client from new thread so we can return.
1624            Client will not finish until all servers are connected.
1625            Note - MGS-only server does NOT get a client, since there is no
1626            lustre fs associated - the MGS is for all lustre fs's */
1627         }
1628
1629         rc = server_fill_super_common(sb);
1630         if (rc)
1631                 GOTO(out_mnt, rc);
1632
1633         LCONSOLE_WARN("Server %s on device %s has started\n",
1634                       lsi->lsi_ldd->ldd_svname, lsi->lsi_lmd->lmd_dev);
1635
1636         RETURN(0);
1637
1638 out_mnt:
1639         server_put_super(sb);
1640 out:
1641         RETURN(rc);
1642 }
1643
1644 /* Get the index from the obd name.
1645    rc = server type, or
1646    rc < 0  on error
1647    if endptr isn't NULL it is set to end of name */
1648 int server_name2index(char *svname, __u32 *idx, char **endptr)
1649 {
1650         unsigned long index;
1651         int rc;
1652         char *dash = strchr(svname, '-');
1653         if (!dash)
1654                 return(-EINVAL);
1655
1656         if (strncmp(dash + 1, "MDT", 3) == 0)
1657                 rc = LDD_F_SV_TYPE_MDT;
1658         else if (strncmp(dash + 1, "OST", 3) == 0)
1659                 rc = LDD_F_SV_TYPE_OST;
1660         else
1661                 return(-EINVAL);
1662
1663         index = simple_strtoul(dash + 4, endptr, 16);
1664         *idx = index;
1665         return rc;
1666 }
1667
1668 /*************** mount common betweeen server and client ***************/
1669
1670 /* Common umount */
1671 int lustre_common_put_super(struct super_block *sb)
1672 {
1673         int rc;
1674         ENTRY;
1675
1676         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
1677
1678         /* Drop a ref to the MGC */
1679         rc = lustre_stop_mgc(sb);
1680         if (rc && (rc != -ENOENT)) {
1681                 if (rc != -EBUSY) {
1682                         CERROR("Can't stop MGC: %d\n", rc);
1683                         RETURN(rc);
1684                 }
1685                 /* BUSY just means that there's some other obd that
1686                    needs the mgc.  Let him clean it up. */
1687                 CDEBUG(D_MOUNT, "MGC still in use\n");
1688         }
1689         /* Drop a ref to the mounted disk */
1690         lustre_put_lsi(sb);
1691         RETURN(rc);
1692 }
1693
1694 #if 0
1695 static void lmd_print(struct lustre_mount_data *lmd)
1696 {
1697         int i;
1698
1699         PRINT_CMD(PRINT_MASK, "  mount data:\n");
1700         if (lmd_is_client(lmd))
1701                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
1702         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
1703         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
1704         if (lmd->lmd_opts)
1705                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
1706         for (i = 0; i < lmd->lmd_exclude_count; i++) {
1707                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
1708                           lmd->lmd_exclude[i]);
1709         }
1710 }
1711 #endif
1712
1713 /* Is this server on the exclusion list */
1714 int lustre_check_exclusion(struct super_block *sb, char *svname)
1715 {
1716         struct lustre_sb_info *lsi = s2lsi(sb);
1717         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1718         __u32 index;
1719         int i, rc;
1720         ENTRY;
1721
1722         rc = server_name2index(svname, &index, NULL);
1723         if (rc != LDD_F_SV_TYPE_OST)
1724                 /* Only exclude OSTs */
1725                 RETURN(0);
1726
1727         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
1728                index, lmd->lmd_exclude_count, lmd->lmd_dev);
1729
1730         for(i = 0; i < lmd->lmd_exclude_count; i++) {
1731                 if (index == lmd->lmd_exclude[i]) {
1732                         CWARN("Excluding %s (on exclusion list)\n", svname);
1733                         RETURN(1);
1734                 }
1735         }
1736         RETURN(0);
1737 }
1738
1739 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
1740 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
1741 {
1742         char *s1 = ptr, *s2;
1743         __u32 index, *exclude_list;
1744         int rc = 0, devmax;
1745         ENTRY;
1746
1747         /* The shortest an ost name can be is 8 chars: -OST0000.
1748            We don't actually know the fsname at this time, so in fact
1749            a user could specify any fsname. */
1750         devmax = strlen(ptr) / 8 + 1;
1751
1752         /* temp storage until we figure out how many we have */
1753         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
1754         if (!exclude_list)
1755                 RETURN(-ENOMEM);
1756
1757         /* we enter this fn pointing at the '=' */
1758         while (*s1 && *s1 != ' ' && *s1 != ',') {
1759                 s1++;
1760                 rc = server_name2index(s1, &index, &s2);
1761                 if (rc < 0) {
1762                         CERROR("Can't parse server name '%s'\n", s1);
1763                         break;
1764                 }
1765                 if (rc == LDD_F_SV_TYPE_OST)
1766                         exclude_list[lmd->lmd_exclude_count++] = index;
1767                 else
1768                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
1769                 s1 = s2;
1770                 /* now we are pointing at ':' (next exclude)
1771                    or ',' (end of excludes) */
1772                 if (lmd->lmd_exclude_count >= devmax)
1773                         break;
1774         }
1775         if (rc >= 0) /* non-err */
1776                 rc = 0;
1777
1778         if (lmd->lmd_exclude_count) {
1779                 /* permanent, freed in lustre_free_lsi */
1780                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
1781                           lmd->lmd_exclude_count);
1782                 if (lmd->lmd_exclude) {
1783                         memcpy(lmd->lmd_exclude, exclude_list,
1784                                sizeof(index) * lmd->lmd_exclude_count);
1785                 } else {
1786                         rc = -ENOMEM;
1787                         lmd->lmd_exclude_count = 0;
1788                 }
1789         }
1790         OBD_FREE(exclude_list, sizeof(index) * devmax);
1791         RETURN(rc);
1792 }
1793
1794 /* mount -v -t lustre uml1:uml2:/lustre-client /mnt/lustre */
1795 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
1796 {
1797         char *s1, *s2, *devname = NULL;
1798         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
1799         int rc = 0;
1800         ENTRY;
1801
1802         LASSERT(lmd);
1803         if (!options) {
1804                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
1805                                    "/sbin/mount.lustre is installed.\n");
1806                 RETURN(-EINVAL);
1807         }
1808
1809         /* Options should be a string - try to detect old lmd data */
1810         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
1811                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
1812                                    "/sbin/mount.lustre.  Please install "
1813                                    "version %s\n", LUSTRE_VERSION_STRING);
1814                 RETURN(-EINVAL);
1815         }
1816         lmd->lmd_magic = LMD_MAGIC;
1817
1818         /* Set default flags here */
1819
1820         s1 = options;
1821         while (*s1) {
1822                 int clear = 0;
1823                 /* Skip whitespace and extra commas */
1824                 while (*s1 == ' ' || *s1 == ',')
1825                         s1++;
1826
1827                 /* Client options are parsed in ll_options: eg. flock,
1828                    user_xattr, acl */
1829
1830                 /* Parse non-ldiskfs options here. Rather than modifying
1831                    ldiskfs, we just zero these out here */
1832                 if (strncmp(s1, "abort_recov", 11) == 0) {
1833                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
1834                         clear++;
1835                 } else if (strncmp(s1, "nosvc", 5) == 0) {
1836                         lmd->lmd_flags |= LMD_FLG_NOSVC;
1837                         clear++;
1838                 } else if (strncmp(s1, "nomgs", 5) == 0) {
1839                         lmd->lmd_flags |= LMD_FLG_NOMGS;
1840                         clear++;
1841                 /* ost exclusion list */
1842                 } else if (strncmp(s1, "exclude=", 8) == 0) {
1843                         rc = lmd_make_exclusion(lmd, s1 + 7);
1844                         if (rc)
1845                                 goto invalid;
1846                         clear++;
1847                 }
1848                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
1849                    end of the options. */
1850                 else if (strncmp(s1, "device=", 7) == 0) {
1851                         devname = s1 + 7;
1852                         /* terminate options right before device.  device
1853                            must be the last one. */
1854                         *s1 = '\0';
1855                         break;
1856                 }
1857
1858                 /* Find next opt */
1859                 s2 = strchr(s1, ',');
1860                 if (s2 == NULL) {
1861                         if (clear)
1862                                 *s1 = '\0';
1863                         break;
1864                 }
1865                 s2++;
1866                 if (clear)
1867                         memmove(s1, s2, strlen(s2) + 1);
1868                 else
1869                         s1 = s2;
1870         }
1871
1872         if (!devname) {
1873                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
1874                                    "(need mount option 'device=...')\n");
1875                 goto invalid;
1876         }
1877
1878         s1 = strrchr(devname, ':');
1879         if (s1) {
1880                 lmd->lmd_flags = LMD_FLG_CLIENT;
1881                 /* Remove leading /s from fsname */
1882                 while (*++s1 == '/') ;
1883                 /* Freed in lustre_free_lsi */
1884                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
1885                 if (!lmd->lmd_profile)
1886                         RETURN(-ENOMEM);
1887                 sprintf(lmd->lmd_profile, "%s-client", s1);
1888         }
1889
1890         /* Freed in lustre_free_lsi */
1891         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
1892         if (!lmd->lmd_dev)
1893                 RETURN(-ENOMEM);
1894         strcpy(lmd->lmd_dev, devname);
1895
1896         /* Save mount options */
1897         s1 = options + strlen(options) - 1;
1898         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
1899                 *s1-- = 0;
1900         if (*options != 0) {
1901                 /* Freed in lustre_free_lsi */
1902                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
1903                 if (!lmd->lmd_opts)
1904                         RETURN(-ENOMEM);
1905                 strcpy(lmd->lmd_opts, options);
1906         }
1907
1908         lmd->lmd_magic = LMD_MAGIC;
1909
1910         RETURN(rc);
1911
1912 invalid:
1913         CERROR("Bad mount options %s\n", options);
1914         RETURN(-EINVAL);
1915 }
1916
1917
1918 /* Common mount */
1919 int lustre_fill_super(struct super_block *sb, void *data, int silent)
1920 {
1921         struct lustre_mount_data *lmd;
1922         struct lustre_sb_info *lsi;
1923         int rc;
1924         ENTRY;
1925
1926         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
1927
1928         lsi = lustre_init_lsi(sb);
1929         if (!lsi)
1930                 RETURN(-ENOMEM);
1931         lmd = lsi->lsi_lmd;
1932
1933         /* Figure out the lmd from the mount options */
1934         if (lmd_parse((char *)data, lmd)) {
1935                 lustre_put_lsi(sb);
1936                 RETURN(-EINVAL);
1937         }
1938
1939         if (lmd_is_client(lmd)) {
1940                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
1941                 if (!client_fill_super) {
1942                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
1943                                            "client mount! Is the 'lustre' "
1944                                            "module loaded?\n");
1945                         rc = -ENODEV;
1946                 } else {
1947                         rc = lustre_start_mgc(sb);
1948                         if (rc) {
1949                                 lustre_stop_mgc(sb);
1950                                 goto out;
1951                         }
1952                         /* Connect and start */
1953                         /* (should always be ll_fill_super) */
1954                         rc = (*client_fill_super)(sb);
1955                         /* c_f_s will call lustre_common_put_super on failure */
1956                 }
1957         } else {
1958                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
1959                 lsi->lsi_flags |= LSI_SERVER;
1960                 rc = server_fill_super(sb);
1961                 /* s_f_s calls lustre_start_mgc after the mount because we need
1962                    the MGS nids which are stored on disk.  Plus, we may
1963                    need to start the MGS first. */
1964                 /* s_f_s will call server_put_super on failure */
1965         }
1966
1967 out:
1968         if (rc){
1969                 CERROR("Unable to mount %s (%d)\n",
1970                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
1971         } else {
1972                 CDEBUG(D_SUPER, "mount %s complete\n", lmd->lmd_dev);
1973         }
1974         RETURN(rc);
1975 }
1976
1977
1978 /* We can't call ll_fill_super by name because it lives in a module that
1979    must be loaded after this one. */
1980 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb))
1981 {
1982         client_fill_super = cfs;
1983 }
1984
1985 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
1986 {
1987         kill_super_cb = cfs;
1988 }
1989
1990 /***************** FS registration ******************/
1991
1992 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
1993 struct super_block * lustre_get_sb(struct file_system_type *fs_type,
1994                                int flags, const char *devname, void * data)
1995 {
1996         /* calls back in fill super */
1997         /* we could append devname= onto options (*data) here,
1998            but 2.4 doesn't get devname.  So we do it in mount_lustre.c */
1999         return get_sb_nodev(fs_type, flags, data, lustre_fill_super);
2000 }
2001 #else
2002 int lustre_get_sb(struct file_system_type *fs_type,
2003                                int flags, const char *devname, void * data,
2004                                struct vfsmount *mnt)
2005 {
2006         /* calls back in fill super */
2007         /* we could append devname= onto options (*data) here,
2008            but 2.4 doesn't get devname.  So we do it in mount_lustre.c */
2009         return get_sb_nodev(fs_type, flags, data, lustre_fill_super, mnt);
2010 }
2011 #endif
2012
2013 void lustre_kill_super(struct super_block *sb)
2014 {
2015         struct lustre_sb_info *lsi = s2lsi(sb);
2016
2017         if (kill_super_cb && lsi &&(lsi->lsi_flags & LSI_SERVER))
2018                 (*kill_super_cb)(sb);
2019
2020         kill_anon_super(sb);
2021 }
2022
2023 struct file_system_type lustre_fs_type = {
2024         .owner        = THIS_MODULE,
2025         .name         = "lustre",
2026         .get_sb       = lustre_get_sb,
2027         .kill_sb      = lustre_kill_super,
2028         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
2029                         LL_RENAME_DOES_D_MOVE,
2030 };
2031
2032 int lustre_register_fs(void)
2033 {
2034         return register_filesystem(&lustre_fs_type);
2035 }
2036
2037 int lustre_unregister_fs(void)
2038 {
2039         return unregister_filesystem(&lustre_fs_type);
2040 }
2041
2042 EXPORT_SYMBOL(lustre_register_client_fill_super);
2043 EXPORT_SYMBOL(lustre_register_kill_super_cb);
2044 EXPORT_SYMBOL(lustre_common_put_super);
2045 EXPORT_SYMBOL(lustre_process_log);
2046 EXPORT_SYMBOL(lustre_end_log);
2047 EXPORT_SYMBOL(server_get_mount);
2048 EXPORT_SYMBOL(server_get_mount_2);
2049 EXPORT_SYMBOL(server_put_mount);
2050 EXPORT_SYMBOL(server_put_mount_2);
2051 EXPORT_SYMBOL(server_register_target);
2052 EXPORT_SYMBOL(server_name2index);
2053 EXPORT_SYMBOL(server_mti_print);
2054 EXPORT_SYMBOL(do_lcfg);