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