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