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);
 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                 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 (IS_MDT(lsi->lsi_ldd) || IS_OST(lsi->lsi_ldd)) {
1361                 struct lustre_profile *lprof = NULL;
1362
1363                 /* tell the mgc to drop the config log */
1364                 lustre_end_log(sb, lsi->lsi_ldd->ldd_svname, NULL);
1365
1366                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
1367                    If there are any setup/cleanup errors, save the lov
1368                    name for safety cleanup later. */
1369                 lprof = class_get_profile(lsi->lsi_ldd->ldd_svname);
1370                 if (lprof && lprof->lp_dt) {
1371                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
1372                         strcpy(extraname, lprof->lp_dt);
1373                 }
1374
1375                 obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
1376                 if (obd) {
1377                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
1378                         if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
1379                                 obd->obd_fail = 1;
1380                         /* We can't seem to give an error return code
1381                          * to .put_super, so we better make sure we clean up! */
1382                         obd->obd_force = 1;
1383                         class_manual_cleanup(obd);
1384                 } else {
1385                         CERROR("no obd %s\n", lsi->lsi_ldd->ldd_svname);
1386                         server_deregister_mount(lsi->lsi_ldd->ldd_svname);
1387                 }
1388         }
1389
1390         /* If they wanted the mgs to stop separately from the mdt, they
1391            should have put it on a different device. */
1392         if (IS_MGS(lsi->lsi_ldd)) {
1393                 /* stop the mgc before the mgs so the connection gets cleaned
1394                    up */
1395                 lustre_stop_mgc(sb);
1396                 server_stop_mgs(sb);
1397         }
1398
1399         /* Clean the mgc and sb */
1400         rc = lustre_common_put_super(sb);
1401         /* FIXME how can I report a failure to umount? */
1402
1403         /* Wait for the targets to really clean up - can't exit (and let the
1404            sb get destroyed) while the mount is still in use */
1405         server_wait_finished(mnt);
1406
1407         /* drop the One True Mount */
1408         unlock_mntput(mnt);
1409
1410         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
1411            until the target is really gone so that our type refcount check
1412            is right. */
1413         server_stop_servers(lddflags, lsiflags);
1414
1415         /* In case of startup or cleanup err, stop related obds */
1416         if (extraname) {
1417                 obd = class_name2obd(extraname);
1418                 if (obd) {
1419                         CWARN("Cleaning orphaned obd %s\n", extraname);
1420                         obd->obd_force = 1;
1421                         class_manual_cleanup(obd);
1422                 }
1423                 OBD_FREE(extraname, strlen(extraname) + 1);
1424         }
1425
1426         LCONSOLE_WARN("server umount %s complete\n", tmpname);
1427         OBD_FREE(tmpname, tmpname_sz);
1428         EXIT;
1429 }
1430
1431 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1432 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
1433 {
1434         struct super_block *sb = vfsmnt->mnt_sb;
1435 #else
1436 static void server_umount_begin(struct super_block *sb)
1437 {
1438 #endif
1439         struct lustre_sb_info *lsi = s2lsi(sb);
1440         ENTRY;
1441
1442 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1443         if (!(flags & MNT_FORCE)) {
1444                 EXIT;
1445                 return;
1446         }
1447 #endif
1448
1449         CDEBUG(D_MOUNT, "umount -f\n");
1450         /* umount = failover
1451            umount -f = force
1452            no third way to do non-force, non-failover */
1453         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
1454         lsi->lsi_flags |= LSI_UMOUNT_FORCE;
1455         EXIT;
1456 }
1457
1458 #ifndef HAVE_STATFS_DENTRY_PARAM
1459 static int server_statfs (struct super_block *sb, struct kstatfs *buf)
1460 {
1461 #else
1462 static int server_statfs (struct dentry *dentry, struct kstatfs *buf)
1463 {
1464         struct super_block *sb = dentry->d_sb;
1465 #endif
1466         struct vfsmount *mnt = s2lsi(sb)->lsi_srv_mnt;
1467         ENTRY;
1468
1469         if (mnt && mnt->mnt_sb && mnt->mnt_sb->s_op->statfs) {
1470 #ifdef HAVE_STATFS_DENTRY_PARAM
1471                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_root, buf);
1472 #else
1473                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_sb, buf);
1474 #endif
1475                 if (!rc) {
1476                         buf->f_type = sb->s_magic;
1477                         RETURN(0);
1478                 }
1479         }
1480
1481         /* just return 0 */
1482         buf->f_type = sb->s_magic;
1483         buf->f_bsize = sb->s_blocksize;
1484         buf->f_blocks = 1;
1485         buf->f_bfree = 0;
1486         buf->f_bavail = 0;
1487         buf->f_files = 1;
1488         buf->f_ffree = 0;
1489         buf->f_namelen = NAME_MAX;
1490         RETURN(0);
1491 }
1492
1493 static struct super_operations server_ops =
1494 {
1495         .put_super      = server_put_super,
1496         .umount_begin   = server_umount_begin, /* umount -f */
1497         .statfs         = server_statfs,
1498 };
1499
1500 #define log2(n) ffz(~(n))
1501 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
1502
1503 static int server_fill_super_common(struct super_block *sb)
1504 {
1505         struct inode *root = 0;
1506         ENTRY;
1507
1508         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
1509
1510         sb->s_blocksize = 4096;
1511         sb->s_blocksize_bits = log2(sb->s_blocksize);
1512         sb->s_magic = LUSTRE_SUPER_MAGIC;
1513         sb->s_maxbytes = 0; //PAGE_CACHE_MAXBYTES;
1514         sb->s_flags |= MS_RDONLY;
1515         sb->s_op = &server_ops;
1516
1517         root = new_inode(sb);
1518         if (!root) {
1519                 CERROR("Can't make root inode\n");
1520                 RETURN(-EIO);
1521         }
1522
1523         /* returns -EIO for every operation */
1524         /* make_bad_inode(root); -- badness - can't umount */
1525         /* apparently we need to be a directory for the mount to finish */
1526         root->i_mode = S_IFDIR;
1527
1528         sb->s_root = d_alloc_root(root);
1529         if (!sb->s_root) {
1530                 CERROR("Can't make root dentry\n");
1531                 iput(root);
1532                 RETURN(-EIO);
1533         }
1534
1535         RETURN(0);
1536 }
1537
1538 static int server_fill_super(struct super_block *sb)
1539 {
1540         struct lustre_sb_info *lsi = s2lsi(sb);
1541         struct vfsmount *mnt;
1542         int rc;
1543         ENTRY;
1544
1545         /* the One True Mount */
1546         mnt = server_kernel_mount(sb);
1547         if (IS_ERR(mnt)) {
1548                 rc = PTR_ERR(mnt);
1549                 CERROR("Unable to mount device %s: %d\n",
1550                       lsi->lsi_lmd->lmd_dev, rc);
1551                 lustre_put_lsi(sb);
1552                 GOTO(out, rc);
1553         }
1554         lsi->lsi_srv_mnt = mnt;
1555
1556         LASSERT(lsi->lsi_ldd);
1557         CDEBUG(D_MOUNT, "Found service %s for fs '%s' on device %s\n",
1558                lsi->lsi_ldd->ldd_svname, lsi->lsi_ldd->ldd_fsname,
1559                lsi->lsi_lmd->lmd_dev);
1560
1561         if (class_name2obd(lsi->lsi_ldd->ldd_svname)) {
1562                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
1563                                    "running. Double-mount may have compromised"
1564                                    " the disk journal.\n",
1565                                    lsi->lsi_ldd->ldd_svname);
1566                 unlock_mntput(mnt);
1567                 lustre_put_lsi(sb);
1568                 GOTO(out, rc = -EALREADY);
1569         }
1570
1571         /* start MGS before MGC */
1572         if (IS_MGS(lsi->lsi_ldd)) {
1573                 rc = server_start_mgs(sb);
1574                 if (rc)
1575                         GOTO(out_mnt, rc);
1576         }
1577
1578         rc = lustre_start_mgc(sb);
1579         if (rc)
1580                 GOTO(out_mnt, rc);
1581
1582         /* Set up all obd devices for service */
1583         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1584                 (IS_OST(lsi->lsi_ldd) || IS_MDT(lsi->lsi_ldd))) {
1585                 rc = server_start_targets(sb, mnt);
1586                 if (rc < 0) {
1587                         CERROR("Unable to start targets: %d\n", rc);
1588                         GOTO(out_mnt, rc);
1589                 }
1590         /* FIXME overmount client here,
1591            or can we just start a client log and client_fill_super on this sb?
1592            We need to make sure server_put_super gets called too - ll_put_super
1593            calls lustre_common_put_super; check there for LSI_SERVER flag,
1594            call s_p_s if so.
1595            Probably should start client from new thread so we can return.
1596            Client will not finish until all servers are connected.
1597            Note - MGS-only server does NOT get a client, since there is no
1598            lustre fs associated - the MGS is for all lustre fs's */
1599         }
1600
1601         rc = server_fill_super_common(sb);
1602         if (rc)
1603                 GOTO(out_mnt, rc);
1604
1605         LCONSOLE_WARN("Server %s on device %s has started\n",
1606                       lsi->lsi_ldd->ldd_svname, lsi->lsi_lmd->lmd_dev);
1607
1608         RETURN(0);
1609
1610 out_mnt:
1611         server_put_super(sb);
1612 out:
1613         RETURN(rc);
1614 }
1615
1616 /* Get the index from the obd name.
1617    rc = server type, or
1618    rc < 0  on error
1619    if endptr isn't NULL it is set to end of name */
1620 int server_name2index(char *svname, __u32 *idx, char **endptr)
1621 {
1622         unsigned long index;
1623         int rc;
1624         char *dash = strchr(svname, '-');
1625         if (!dash)
1626                 return(-EINVAL);
1627
1628         if (strncmp(dash + 1, "MDT", 3) == 0)
1629                 rc = LDD_F_SV_TYPE_MDT;
1630         else if (strncmp(dash + 1, "OST", 3) == 0)
1631                 rc = LDD_F_SV_TYPE_OST;
1632         else
1633                 return(-EINVAL);
1634
1635         index = simple_strtoul(dash + 4, endptr, 16);
1636         *idx = index;
1637         return rc;
1638 }
1639
1640 /*************** mount common betweeen server and client ***************/
1641
1642 /* Common umount */
1643 int lustre_common_put_super(struct super_block *sb)
1644 {
1645         int rc;
1646         ENTRY;
1647
1648         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
1649
1650         /* Drop a ref to the MGC */
1651         rc = lustre_stop_mgc(sb);
1652         if (rc && (rc != -ENOENT)) {
1653                 if (rc != -EBUSY) {
1654                         CERROR("Can't stop MGC: %d\n", rc);
1655                         RETURN(rc);
1656                 }
1657                 /* BUSY just means that there's some other obd that
1658                    needs the mgc.  Let him clean it up. */
1659                 CDEBUG(D_MOUNT, "MGC still in use\n");
1660         }
1661         /* Drop a ref to the mounted disk */
1662         lustre_put_lsi(sb);
1663         RETURN(rc);
1664 }
1665
1666 #if 0
1667 static void lmd_print(struct lustre_mount_data *lmd)
1668 {
1669         int i;
1670
1671         PRINT_CMD(PRINT_MASK, "  mount data:\n");
1672         if (lmd_is_client(lmd))
1673                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
1674         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
1675         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
1676         if (lmd->lmd_opts)
1677                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
1678         for (i = 0; i < lmd->lmd_exclude_count; i++) {
1679                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
1680                           lmd->lmd_exclude[i]);
1681         }
1682 }
1683 #endif
1684
1685 /* Is this server on the exclusion list */
1686 int lustre_check_exclusion(struct super_block *sb, char *svname)
1687 {
1688         struct lustre_sb_info *lsi = s2lsi(sb);
1689         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1690         __u32 index;
1691         int i, rc;
1692         ENTRY;
1693
1694         rc = server_name2index(svname, &index, NULL);
1695         if (rc != LDD_F_SV_TYPE_OST)
1696                 /* Only exclude OSTs */
1697                 RETURN(0);
1698
1699         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
1700                index, lmd->lmd_exclude_count, lmd->lmd_dev);
1701
1702         for(i = 0; i < lmd->lmd_exclude_count; i++) {
1703                 if (index == lmd->lmd_exclude[i]) {
1704                         CWARN("Excluding %s (on exclusion list)\n", svname);
1705                         RETURN(1);
1706                 }
1707         }
1708         RETURN(0);
1709 }
1710
1711 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
1712 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
1713 {
1714         char *s1 = ptr, *s2;
1715         __u32 index, *exclude_list;
1716         int rc = 0, devmax;
1717         ENTRY;
1718
1719         /* The shortest an ost name can be is 8 chars: -OST0000.
1720            We don't actually know the fsname at this time, so in fact
1721            a user could specify any fsname. */
1722         devmax = strlen(ptr) / 8 + 1;
1723
1724         /* temp storage until we figure out how many we have */
1725         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
1726         if (!exclude_list)
1727                 RETURN(-ENOMEM);
1728
1729         /* we enter this fn pointing at the '=' */
1730         while (*s1 && *s1 != ' ' && *s1 != ',') {
1731                 s1++;
1732                 rc = server_name2index(s1, &index, &s2);
1733                 if (rc < 0) {
1734                         CERROR("Can't parse server name '%s'\n", s1);
1735                         break;
1736                 }
1737                 if (rc == LDD_F_SV_TYPE_OST)
1738                         exclude_list[lmd->lmd_exclude_count++] = index;
1739                 else
1740                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
1741                 s1 = s2;
1742                 /* now we are pointing at ':' (next exclude)
1743                    or ',' (end of excludes) */
1744                 if (lmd->lmd_exclude_count >= devmax)
1745                         break;
1746         }
1747         if (rc >= 0) /* non-err */
1748                 rc = 0;
1749
1750         if (lmd->lmd_exclude_count) {
1751                 /* permanent, freed in lustre_free_lsi */
1752                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
1753                           lmd->lmd_exclude_count);
1754                 if (lmd->lmd_exclude) {
1755                         memcpy(lmd->lmd_exclude, exclude_list,
1756                                sizeof(index) * lmd->lmd_exclude_count);
1757                 } else {
1758                         rc = -ENOMEM;
1759                         lmd->lmd_exclude_count = 0;
1760                 }
1761         }
1762         OBD_FREE(exclude_list, sizeof(index) * devmax);
1763         RETURN(rc);
1764 }
1765
1766 /* mount -v -t lustre uml1:uml2:/lustre-client /mnt/lustre */
1767 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
1768 {
1769         char *s1, *s2, *devname = NULL;
1770         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
1771         int rc = 0;
1772         ENTRY;
1773
1774         LASSERT(lmd);
1775         if (!options) {
1776                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
1777                                    "/sbin/mount.lustre is installed.\n");
1778                 RETURN(-EINVAL);
1779         }
1780
1781         /* Options should be a string - try to detect old lmd data */
1782         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
1783                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
1784                                    "/sbin/mount.lustre.  Please install "
1785                                    "version %s\n", LUSTRE_VERSION_STRING);
1786                 RETURN(-EINVAL);
1787         }
1788         lmd->lmd_magic = LMD_MAGIC;
1789
1790         /* Set default flags here */
1791
1792         s1 = options;
1793         while (*s1) {
1794                 int clear = 0;
1795                 /* Skip whitespace and extra commas */
1796                 while (*s1 == ' ' || *s1 == ',')
1797                         s1++;
1798
1799                 /* Client options are parsed in ll_options: eg. flock,
1800                    user_xattr, acl */
1801
1802                 /* Parse non-ldiskfs options here. Rather than modifying
1803                    ldiskfs, we just zero these out here */
1804                 if (strncmp(s1, "abort_recov", 11) == 0) {
1805                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
1806                         clear++;
1807                 } else if (strncmp(s1, "nosvc", 5) == 0) {
1808                         lmd->lmd_flags |= LMD_FLG_NOSVC;
1809                         clear++;
1810                 /* ost exclusion list */
1811                 } else if (strncmp(s1, "exclude=", 8) == 0) {
1812                         rc = lmd_make_exclusion(lmd, s1 + 7);
1813                         if (rc)
1814                                 goto invalid;
1815                         clear++;
1816                 }
1817                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
1818                    end of the options. */
1819                 else if (strncmp(s1, "device=", 7) == 0) {
1820                         devname = s1 + 7;
1821                         /* terminate options right before device.  device
1822                            must be the last one. */
1823                         *s1 = '\0';
1824                         break;
1825                 }
1826
1827                 /* Find next opt */
1828                 s2 = strchr(s1, ',');
1829                 if (s2 == NULL) {
1830                         if (clear)
1831                                 *s1 = '\0';
1832                         break;
1833                 }
1834                 s2++;
1835                 if (clear)
1836                         memmove(s1, s2, strlen(s2) + 1);
1837                 else
1838                         s1 = s2;
1839         }
1840
1841         if (!devname) {
1842                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
1843                                    "(need mount option 'device=...')\n");
1844                 goto invalid;
1845         }
1846
1847         s1 = strrchr(devname, ':');
1848         if (s1) {
1849                 lmd->lmd_flags = LMD_FLG_CLIENT;
1850                 /* Remove leading /s from fsname */
1851                 while (*++s1 == '/') ;
1852                 /* Freed in lustre_free_lsi */
1853                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
1854                 if (!lmd->lmd_profile)
1855                         RETURN(-ENOMEM);
1856                 sprintf(lmd->lmd_profile, "%s-client", s1);
1857         }
1858
1859         /* Freed in lustre_free_lsi */
1860         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
1861         if (!lmd->lmd_dev)
1862                 RETURN(-ENOMEM);
1863         strcpy(lmd->lmd_dev, devname);
1864
1865         /* Save mount options */
1866         s1 = options + strlen(options) - 1;
1867         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
1868                 *s1-- = 0;
1869         if (*options != 0) {
1870                 /* Freed in lustre_free_lsi */
1871                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
1872                 if (!lmd->lmd_opts)
1873                         RETURN(-ENOMEM);
1874                 strcpy(lmd->lmd_opts, options);
1875         }
1876
1877         lmd->lmd_magic = LMD_MAGIC;
1878
1879         RETURN(rc);
1880
1881 invalid:
1882         CERROR("Bad mount options %s\n", options);
1883         RETURN(-EINVAL);
1884 }
1885
1886
1887 /* Common mount */
1888 int lustre_fill_super(struct super_block *sb, void *data, int silent)
1889 {
1890         struct lustre_mount_data *lmd;
1891         struct lustre_sb_info *lsi;
1892         int rc;
1893         ENTRY;
1894
1895         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
1896
1897         lsi = lustre_init_lsi(sb);
1898         if (!lsi)
1899                 RETURN(-ENOMEM);
1900         lmd = lsi->lsi_lmd;
1901
1902         /* Figure out the lmd from the mount options */
1903         if (lmd_parse((char *)data, lmd)) {
1904                 lustre_put_lsi(sb);
1905                 RETURN(-EINVAL);
1906         }
1907
1908         if (lmd_is_client(lmd)) {
1909                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
1910                 if (!client_fill_super) {
1911                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
1912                                            "client mount! Is the 'lustre' "
1913                                            "module loaded?\n");
1914                         rc = -ENODEV;
1915                 } else {
1916                         rc = lustre_start_mgc(sb);
1917                         if (rc) {
1918                                 lustre_stop_mgc(sb);
1919                                 goto out;
1920                         }
1921                         /* Connect and start */
1922                         /* (should always be ll_fill_super) */
1923                         rc = (*client_fill_super)(sb);
1924                         /* c_f_s will call lustre_common_put_super on failure */
1925                 }
1926         } else {
1927                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
1928                 lsi->lsi_flags |= LSI_SERVER;
1929                 rc = server_fill_super(sb);
1930                 /* s_f_s calls lustre_start_mgc after the mount because we need
1931                    the MGS nids which are stored on disk.  Plus, we may
1932                    need to start the MGS first. */
1933                 /* s_f_s will call server_put_super on failure */
1934         }
1935
1936 out:
1937         if (rc){
1938                 CERROR("Unable to mount %s (%d)\n",
1939                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
1940         } else {
1941                 CDEBUG(D_SUPER, "mount %s complete\n", lmd->lmd_dev);
1942         }
1943         RETURN(rc);
1944 }
1945
1946
1947 /* We can't call ll_fill_super by name because it lives in a module that
1948    must be loaded after this one. */
1949 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb))
1950 {
1951         client_fill_super = cfs;
1952 }
1953
1954 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
1955 {
1956         kill_super_cb = cfs;
1957 }
1958
1959 /***************** FS registration ******************/
1960
1961 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
1962 struct super_block * lustre_get_sb(struct file_system_type *fs_type,
1963                                int flags, const char *devname, void * data)
1964 {
1965         /* calls back in fill super */
1966         /* we could append devname= onto options (*data) here,
1967            but 2.4 doesn't get devname.  So we do it in mount_lustre.c */
1968         return get_sb_nodev(fs_type, flags, data, lustre_fill_super);
1969 }
1970 #else
1971 int lustre_get_sb(struct file_system_type *fs_type,
1972                                int flags, const char *devname, void * data,
1973                                struct vfsmount *mnt)
1974 {
1975         /* calls back in fill super */
1976         /* we could append devname= onto options (*data) here,
1977            but 2.4 doesn't get devname.  So we do it in mount_lustre.c */
1978         return get_sb_nodev(fs_type, flags, data, lustre_fill_super, mnt);
1979 }
1980 #endif
1981
1982 void lustre_kill_super(struct super_block *sb)
1983 {
1984         struct lustre_sb_info *lsi = s2lsi(sb);
1985
1986         if (kill_super_cb && lsi &&(lsi->lsi_flags & LSI_SERVER))
1987                 (*kill_super_cb)(sb);
1988
1989         kill_anon_super(sb);
1990 }
1991
1992 struct file_system_type lustre_fs_type = {
1993         .owner        = THIS_MODULE,
1994         .name         = "lustre",
1995         .get_sb       = lustre_get_sb,
1996         .kill_sb      = lustre_kill_super,
1997         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV,
1998 };
1999
2000 int lustre_register_fs(void)
2001 {
2002         return register_filesystem(&lustre_fs_type);
2003 }
2004
2005 int lustre_unregister_fs(void)
2006 {
2007         return unregister_filesystem(&lustre_fs_type);
2008 }
2009
2010 EXPORT_SYMBOL(lustre_register_client_fill_super);
2011 EXPORT_SYMBOL(lustre_register_kill_super_cb);
2012 EXPORT_SYMBOL(lustre_common_put_super);
2013 EXPORT_SYMBOL(lustre_process_log);
2014 EXPORT_SYMBOL(lustre_end_log);
2015 EXPORT_SYMBOL(server_get_mount);
2016 EXPORT_SYMBOL(server_get_mount_2);
2017 EXPORT_SYMBOL(server_put_mount);
2018 EXPORT_SYMBOL(server_put_mount_2);
2019 EXPORT_SYMBOL(server_register_target);
2020 EXPORT_SYMBOL(server_name2index);
2021 EXPORT_SYMBOL(server_mti_print);
2022 EXPORT_SYMBOL(do_lcfg);
2023
2024