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