lustre/obdclass/obd_mount.c

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