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