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