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