lustre/obdclass/obd_mount.c

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