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->mnt_devname,
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 #ifndef HAVE_STATFS_DENTRY_PARAM
1804 static int server_statfs (struct super_block *sb, cfs_kstatfs_t *buf)
1805 {
1806 #else
1807 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
1808 {
1809         struct super_block *sb = dentry->d_sb;
1810 #endif
1811         struct vfsmount *mnt = s2lsi(sb)->lsi_srv_mnt;
1812         ENTRY;
1813
1814         if (mnt && mnt->mnt_sb && mnt->mnt_sb->s_op->statfs) {
1815 #ifdef HAVE_STATFS_DENTRY_PARAM
1816                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_root, buf);
1817 #else
1818                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_sb, buf);
1819 #endif
1820                 if (!rc) {
1821                         buf->f_type = sb->s_magic;
1822                         RETURN(0);
1823                 }
1824         }
1825
1826         /* just return 0 */
1827         buf->f_type = sb->s_magic;
1828         buf->f_bsize = sb->s_blocksize;
1829         buf->f_blocks = 1;
1830         buf->f_bfree = 0;
1831         buf->f_bavail = 0;
1832         buf->f_files = 1;
1833         buf->f_ffree = 0;
1834         buf->f_namelen = NAME_MAX;
1835         RETURN(0);
1836 }
1837
1838 /** The operations we support directly on the superblock:
1839  * mount, umount, and df.
1840  */
1841 static struct super_operations server_ops =
1842 {
1843         .put_super      = server_put_super,
1844         .umount_begin   = server_umount_begin, /* umount -f */
1845         .statfs         = server_statfs,
1846 };
1847
1848 #define log2(n) cfs_ffz(~(n))
1849 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
1850
1851 static int server_fill_super_common(struct super_block *sb)
1852 {
1853         struct inode *root = 0;
1854         ENTRY;
1855
1856         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
1857
1858         sb->s_blocksize = 4096;
1859         sb->s_blocksize_bits = log2(sb->s_blocksize);
1860         sb->s_magic = LUSTRE_SUPER_MAGIC;
1861         sb->s_maxbytes = 0; /* we don't allow file IO on server mountpoints */
1862         sb->s_flags |= MS_RDONLY;
1863         sb->s_op = &server_ops;
1864
1865         root = new_inode(sb);
1866         if (!root) {
1867                 CERROR("Can't make root inode\n");
1868                 RETURN(-EIO);
1869         }
1870
1871         /* returns -EIO for every operation */
1872         /* make_bad_inode(root); -- badness - can't umount */
1873         /* apparently we need to be a directory for the mount to finish */
1874         root->i_mode = S_IFDIR;
1875
1876         sb->s_root = d_alloc_root(root);
1877         if (!sb->s_root) {
1878                 CERROR("Can't make root dentry\n");
1879                 iput(root);
1880                 RETURN(-EIO);
1881         }
1882
1883         RETURN(0);
1884 }
1885
1886 /** Fill in the superblock info for a Lustre server.
1887  * Mount the device with the correct options.
1888  * Read the on-disk config file.
1889  * Start the services.
1890  */
1891 static int server_fill_super(struct super_block *sb)
1892 {
1893         struct lustre_sb_info *lsi = s2lsi(sb);
1894         struct vfsmount *mnt;
1895         int rc;
1896         ENTRY;
1897
1898         /* the One True Mount */
1899         mnt = server_kernel_mount(sb);
1900         if (IS_ERR(mnt)) {
1901                 rc = PTR_ERR(mnt);
1902                 CERROR("Unable to mount device %s: %d\n",
1903                        lsi->lsi_lmd->lmd_dev, rc);
1904                 lustre_put_lsi(sb);
1905                 RETURN(rc);
1906         }
1907         lsi->lsi_srv_mnt = mnt;
1908
1909         LASSERT(lsi->lsi_ldd);
1910         CDEBUG(D_MOUNT, "Found service %s for fs '%s' on device %s\n",
1911                lsi->lsi_ldd->ldd_svname, lsi->lsi_ldd->ldd_fsname,
1912                lsi->lsi_lmd->lmd_dev);
1913
1914         if (class_name2obd(lsi->lsi_ldd->ldd_svname)) {
1915                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
1916                                    "running. Double-mount may have compromised"
1917                                    " the disk journal.\n",
1918                                    lsi->lsi_ldd->ldd_svname);
1919                 lustre_put_lsi(sb);
1920                 unlock_mntput(mnt);
1921                 RETURN(-EALREADY);
1922         }
1923
1924         /* Start MGS before MGC */
1925         if (IS_MGS(lsi->lsi_ldd) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
1926                 rc = server_start_mgs(sb);
1927                 if (rc)
1928                         GOTO(out_mnt, rc);
1929         }
1930
1931         /* Start MGC before servers */
1932         rc = lustre_start_mgc(sb);
1933         if (rc)
1934                 GOTO(out_mnt, rc);
1935
1936         /* Set up all obd devices for service */
1937         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1938                 (IS_OST(lsi->lsi_ldd) || IS_MDT(lsi->lsi_ldd))) {
1939                 rc = server_start_targets(sb, mnt);
1940                 if (rc < 0) {
1941                         CERROR("Unable to start targets: %d\n", rc);
1942                         GOTO(out_mnt, rc);
1943                 }
1944         /* FIXME overmount client here,
1945            or can we just start a client log and client_fill_super on this sb?
1946            We need to make sure server_put_super gets called too - ll_put_super
1947            calls lustre_common_put_super; check there for LSI_SERVER flag,
1948            call s_p_s if so.
1949            Probably should start client from new thread so we can return.
1950            Client will not finish until all servers are connected.
1951            Note - MGS-only server does NOT get a client, since there is no
1952            lustre fs associated - the MGS is for all lustre fs's */
1953         }
1954
1955         rc = server_fill_super_common(sb);
1956         if (rc)
1957                 GOTO(out_mnt, rc);
1958
1959         RETURN(0);
1960 out_mnt:
1961         /* We jump here in case of failure while starting targets or MGS.
1962          * In this case we can't just put @mnt and have to do real cleanup
1963          * with stoping targets, etc. */
1964         server_put_super(sb);
1965         return rc;
1966 }
1967
1968 /* Get the index from the obd name.
1969    rc = server type, or
1970    rc < 0  on error
1971    if endptr isn't NULL it is set to end of name */
1972 int server_name2index(char *svname, __u32 *idx, char **endptr)
1973 {
1974         unsigned long index;
1975         int rc;
1976         char *dash = strrchr(svname, '-');
1977         if (!dash)
1978                 return(-EINVAL);
1979
1980         /* intepret <fsname>-MDTXXXXX-mdc as mdt, the better way is to pass
1981          * in the fsname, then determine the server index */
1982         if (!strcmp(LUSTRE_MDC_NAME, dash + 1)) {
1983                 dash--;
1984                 for (; dash > svname && *dash != '-'; dash--);
1985                 if (dash == svname)
1986                         return(-EINVAL);
1987         }
1988
1989         if (strncmp(dash + 1, "MDT", 3) == 0)
1990                 rc = LDD_F_SV_TYPE_MDT;
1991         else if (strncmp(dash + 1, "OST", 3) == 0)
1992                 rc = LDD_F_SV_TYPE_OST;
1993         else
1994                 return(-EINVAL);
1995         if (strcmp(dash + 4, "all") == 0)
1996                 return rc | LDD_F_SV_ALL;
1997
1998         index = simple_strtoul(dash + 4, endptr, 16);
1999         *idx = index;
2000         return rc;
2001 }
2002
2003 /*
2004  * Calculate timeout value for a target.
2005  */
2006 void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
2007 {
2008         struct lustre_mount_data *lmd;
2009         int soft = 0;
2010         int hard = 0;
2011         int factor = 0;
2012         bool has_ir = !!(lsi->lsi_flags & LSI_IR_CAPABLE);
2013         int min = OBD_RECOVERY_TIME_MIN;
2014
2015         LASSERT(lsi->lsi_flags & LSI_SERVER);
2016
2017         lmd = lsi->lsi_lmd;
2018         if (lmd) {
2019                 soft   = lmd->lmd_recovery_time_soft;
2020                 hard   = lmd->lmd_recovery_time_hard;
2021                 has_ir = has_ir && !(lmd->lmd_flags & LMD_FLG_NOIR);
2022                 obd->obd_no_ir = !has_ir;
2023         }
2024
2025         if (soft == 0)
2026                 soft = OBD_RECOVERY_TIME_SOFT;
2027         if (hard == 0)
2028                 hard = OBD_RECOVERY_TIME_HARD;
2029
2030         /* target may have ir_factor configured. */
2031         factor = OBD_IR_FACTOR_DEFAULT;
2032         if (obd->obd_recovery_ir_factor)
2033                 factor = obd->obd_recovery_ir_factor;
2034
2035         if (has_ir) {
2036                 int new_soft = soft;
2037                 int new_hard = hard;
2038
2039                 /* adjust timeout value by imperative recovery */
2040
2041                 new_soft = (soft * factor) / OBD_IR_FACTOR_MAX;
2042                 new_hard = (hard * factor) / OBD_IR_FACTOR_MAX;
2043
2044                 /* make sure the timeout is not too short */
2045                 new_soft = max(min, new_soft);
2046                 new_hard = max(new_soft, new_hard);
2047
2048                 LCONSOLE_INFO("%s: Imperative Recovery enabled, recovery "
2049                               "window shrunk from %d-%d down to %d-%d\n",
2050                               obd->obd_name, soft, hard, new_soft, new_hard);
2051
2052                 soft = new_soft;
2053                 hard = new_hard;
2054         }
2055
2056         /* we're done */
2057         obd->obd_recovery_timeout   = max(obd->obd_recovery_timeout, soft);
2058         obd->obd_recovery_time_hard = hard;
2059         obd->obd_recovery_ir_factor = factor;
2060 }
2061 EXPORT_SYMBOL(server_calc_timeout);
2062
2063 /*************** mount common betweeen server and client ***************/
2064
2065 /* Common umount */
2066 int lustre_common_put_super(struct super_block *sb)
2067 {
2068         int rc;
2069         ENTRY;
2070
2071         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
2072
2073         /* Drop a ref to the MGC */
2074         rc = lustre_stop_mgc(sb);
2075         if (rc && (rc != -ENOENT)) {
2076                 if (rc != -EBUSY) {
2077                         CERROR("Can't stop MGC: %d\n", rc);
2078                         RETURN(rc);
2079                 }
2080                 /* BUSY just means that there's some other obd that
2081                    needs the mgc.  Let him clean it up. */
2082                 CDEBUG(D_MOUNT, "MGC still in use\n");
2083         }
2084         /* Drop a ref to the mounted disk */
2085         lustre_put_lsi(sb);
2086         lu_types_stop();
2087         RETURN(rc);
2088 }
2089
2090 static void lmd_print(struct lustre_mount_data *lmd)
2091 {
2092         int i;
2093
2094         PRINT_CMD(PRINT_MASK, "  mount data:\n");
2095         if (lmd_is_client(lmd))
2096                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
2097         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
2098         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
2099
2100         if (lmd->lmd_opts)
2101                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
2102
2103         if (lmd->lmd_recovery_time_soft)
2104                 PRINT_CMD(PRINT_MASK, "recovery time soft: %d\n",
2105                           lmd->lmd_recovery_time_soft);
2106
2107         if (lmd->lmd_recovery_time_hard)
2108                 PRINT_CMD(PRINT_MASK, "recovery time hard: %d\n",
2109                           lmd->lmd_recovery_time_hard);
2110
2111         for (i = 0; i < lmd->lmd_exclude_count; i++) {
2112                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
2113                           lmd->lmd_exclude[i]);
2114         }
2115 }
2116
2117 /* Is this server on the exclusion list */
2118 int lustre_check_exclusion(struct super_block *sb, char *svname)
2119 {
2120         struct lustre_sb_info *lsi = s2lsi(sb);
2121         struct lustre_mount_data *lmd = lsi->lsi_lmd;
2122         __u32 index;
2123         int i, rc;
2124         ENTRY;
2125
2126         rc = server_name2index(svname, &index, NULL);
2127         if (rc != LDD_F_SV_TYPE_OST)
2128                 /* Only exclude OSTs */
2129                 RETURN(0);
2130
2131         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
2132                index, lmd->lmd_exclude_count, lmd->lmd_dev);
2133
2134         for(i = 0; i < lmd->lmd_exclude_count; i++) {
2135                 if (index == lmd->lmd_exclude[i]) {
2136                         CWARN("Excluding %s (on exclusion list)\n", svname);
2137                         RETURN(1);
2138                 }
2139         }
2140         RETURN(0);
2141 }
2142
2143 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
2144 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
2145 {
2146         char *s1 = ptr, *s2;
2147         __u32 index, *exclude_list;
2148         int rc = 0, devmax;
2149         ENTRY;
2150
2151         /* The shortest an ost name can be is 8 chars: -OST0000.
2152            We don't actually know the fsname at this time, so in fact
2153            a user could specify any fsname. */
2154         devmax = strlen(ptr) / 8 + 1;
2155
2156         /* temp storage until we figure out how many we have */
2157         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
2158         if (!exclude_list)
2159                 RETURN(-ENOMEM);
2160
2161         /* we enter this fn pointing at the '=' */
2162         while (*s1 && *s1 != ' ' && *s1 != ',') {
2163                 s1++;
2164                 rc = server_name2index(s1, &index, &s2);
2165                 if (rc < 0) {
2166                         CERROR("Can't parse server name '%s'\n", s1);
2167                         break;
2168                 }
2169                 if (rc == LDD_F_SV_TYPE_OST)
2170                         exclude_list[lmd->lmd_exclude_count++] = index;
2171                 else
2172                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
2173                 s1 = s2;
2174                 /* now we are pointing at ':' (next exclude)
2175                    or ',' (end of excludes) */
2176                 if (lmd->lmd_exclude_count >= devmax)
2177                         break;
2178         }
2179         if (rc >= 0) /* non-err */
2180                 rc = 0;
2181
2182         if (lmd->lmd_exclude_count) {
2183                 /* permanent, freed in lustre_free_lsi */
2184                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
2185                           lmd->lmd_exclude_count);
2186                 if (lmd->lmd_exclude) {
2187                         memcpy(lmd->lmd_exclude, exclude_list,
2188                                sizeof(index) * lmd->lmd_exclude_count);
2189                 } else {
2190                         rc = -ENOMEM;
2191                         lmd->lmd_exclude_count = 0;
2192                 }
2193         }
2194         OBD_FREE(exclude_list, sizeof(index) * devmax);
2195         RETURN(rc);
2196 }
2197
2198 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
2199 {
2200         char   *tail;
2201         int     length;
2202
2203         if (lmd->lmd_mgssec != NULL) {
2204                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
2205                 lmd->lmd_mgssec = NULL;
2206         }
2207
2208         tail = strchr(ptr, ',');
2209         if (tail == NULL)
2210                 length = strlen(ptr);
2211         else
2212                 length = tail - ptr;
2213
2214         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
2215         if (lmd->lmd_mgssec == NULL)
2216                 return -ENOMEM;
2217
2218         memcpy(lmd->lmd_mgssec, ptr, length);
2219         lmd->lmd_mgssec[length] = '\0';
2220         return 0;
2221 }
2222
2223 static int lmd_parse_string(char **handle, char *ptr)
2224 {
2225         char   *tail;
2226         int     length;
2227
2228         if ((handle == NULL) || (ptr == NULL))
2229                 return -EINVAL;
2230
2231         if (*handle != NULL) {
2232                 OBD_FREE(*handle, strlen(*handle) + 1);
2233                 *handle = NULL;
2234         }
2235
2236         tail = strchr(ptr, ',');
2237         if (tail == NULL)
2238                 length = strlen(ptr);
2239         else
2240                 length = tail - ptr;
2241
2242         OBD_ALLOC(*handle, length + 1);
2243         if (*handle == NULL)
2244                 return -ENOMEM;
2245
2246         memcpy(*handle, ptr, length);
2247         (*handle)[length] = '\0';
2248
2249         return 0;
2250 }
2251
2252 /* Collect multiple values for mgsnid specifiers */
2253 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
2254 {
2255         lnet_nid_t nid;
2256         char *tail = *ptr;
2257         char *mgsnid;
2258         int   length;
2259         int   oldlen = 0;
2260
2261         /* Find end of nidlist */
2262         while (class_parse_nid(tail, &nid, &tail) == 0) {}
2263         length = tail - *ptr;
2264         if (length == 0) {
2265                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
2266                 return -EINVAL;
2267         }
2268
2269         if (lmd->lmd_mgs != NULL)
2270                 oldlen = strlen(lmd->lmd_mgs) + 1;
2271
2272         OBD_ALLOC(mgsnid, oldlen + length + 1);
2273         if (mgsnid == NULL)
2274                 return -ENOMEM;
2275
2276         if (lmd->lmd_mgs != NULL) {
2277                 /* Multiple mgsnid= are taken to mean failover locations */
2278                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
2279                 mgsnid[oldlen - 1] = ':';
2280                 OBD_FREE(lmd->lmd_mgs, oldlen);
2281         }
2282         memcpy(mgsnid + oldlen, *ptr, length);
2283         mgsnid[oldlen + length] = '\0';
2284         lmd->lmd_mgs = mgsnid;
2285         *ptr = tail;
2286
2287         return 0;
2288 }
2289
2290 /** Parse mount line options
2291  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
2292  * dev is passed as device=uml1:/lustre by mount.lustre
2293  */
2294 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
2295 {
2296         char *s1, *s2, *devname = NULL;
2297         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
2298         int rc = 0;
2299         ENTRY;
2300
2301         LASSERT(lmd);
2302         if (!options) {
2303                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
2304                                    "/sbin/mount.lustre is installed.\n");
2305                 RETURN(-EINVAL);
2306         }
2307
2308         /* Options should be a string - try to detect old lmd data */
2309         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
2310                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
2311                                    "/sbin/mount.lustre.  Please install "
2312                                    "version %s\n", LUSTRE_VERSION_STRING);
2313                 RETURN(-EINVAL);
2314         }
2315         lmd->lmd_magic = LMD_MAGIC;
2316
2317         /* Set default flags here */
2318
2319         s1 = options;
2320         while (*s1) {
2321                 int clear = 0;
2322                 int time_min = OBD_RECOVERY_TIME_MIN;
2323
2324                 /* Skip whitespace and extra commas */
2325                 while (*s1 == ' ' || *s1 == ',')
2326                         s1++;
2327
2328                 /* Client options are parsed in ll_options: eg. flock,
2329                    user_xattr, acl */
2330
2331                 /* Parse non-ldiskfs options here. Rather than modifying
2332                    ldiskfs, we just zero these out here */
2333                 if (strncmp(s1, "abort_recov", 11) == 0) {
2334                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
2335                         clear++;
2336                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
2337                         lmd->lmd_recovery_time_soft = max_t(int,
2338                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2339                         clear++;
2340                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
2341                         lmd->lmd_recovery_time_hard = max_t(int,
2342                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2343                         clear++;
2344                 } else if (strncmp(s1, "noir", 4) == 0) {
2345                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
2346                         clear++;
2347                 } else if (strncmp(s1, "nosvc", 5) == 0) {
2348                         lmd->lmd_flags |= LMD_FLG_NOSVC;
2349                         clear++;
2350                 } else if (strncmp(s1, "nomgs", 5) == 0) {
2351                         lmd->lmd_flags |= LMD_FLG_NOMGS;
2352                         clear++;
2353                 } else if (strncmp(s1, "noscrub", 7) == 0) {
2354                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
2355                         clear++;
2356                 } else if (strncmp(s1, PARAM_MGSNODE,
2357                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
2358                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
2359                         /* Assume the next mount opt is the first
2360                            invalid nid we get to. */
2361                         rc = lmd_parse_mgs(lmd, &s2);
2362                         if (rc)
2363                                 goto invalid;
2364                         clear++;
2365                 } else if (strncmp(s1, "writeconf", 9) == 0) {
2366                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
2367                         clear++;
2368                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
2369                         rc = lmd_parse_mgssec(lmd, s1 + 7);
2370                         if (rc)
2371                                 goto invalid;
2372                         clear++;
2373                 /* ost exclusion list */
2374                 } else if (strncmp(s1, "exclude=", 8) == 0) {
2375                         rc = lmd_make_exclusion(lmd, s1 + 7);
2376                         if (rc)
2377                                 goto invalid;
2378                         clear++;
2379                 } else if (strncmp(s1, "svname=", 7) == 0) {
2380                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
2381                         if (rc)
2382                                 goto invalid;
2383                         clear++;
2384                 } else if (strncmp(s1, "osd=", 4) == 0) {
2385                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
2386                         if (rc)
2387                                 goto invalid;
2388                         /* with ldiskfs we're still doing ldd parsing
2389                          * in the kernel space */
2390                         if (!strcmp(lmd->lmd_osd_type, "osd-ldiskfs")) {
2391                                 OBD_FREE(lmd->lmd_osd_type,
2392                                          strlen(lmd->lmd_osd_type) + 1);
2393                                 lmd->lmd_osd_type = NULL;
2394                         }
2395                         clear++;
2396                 }
2397                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
2398                    end of the options. */
2399                 else if (strncmp(s1, "device=", 7) == 0) {
2400                         devname = s1 + 7;
2401                         /* terminate options right before device.  device
2402                            must be the last one. */
2403                         *s1 = '\0';
2404                         break;
2405                 }
2406
2407                 /* Find next opt */
2408                 s2 = strchr(s1, ',');
2409                 if (s2 == NULL) {
2410                         if (clear)
2411                                 *s1 = '\0';
2412                         break;
2413                 }
2414                 s2++;
2415                 if (clear)
2416                         memmove(s1, s2, strlen(s2) + 1);
2417                 else
2418                         s1 = s2;
2419         }
2420
2421         if (!devname) {
2422                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
2423                                    "(need mount option 'device=...')\n");
2424                 goto invalid;
2425         }
2426
2427         s1 = strstr(devname, ":/");
2428         if (s1) {
2429                 ++s1;
2430                 lmd->lmd_flags |= LMD_FLG_CLIENT;
2431                 /* Remove leading /s from fsname */
2432                 while (*++s1 == '/') ;
2433                 /* Freed in lustre_free_lsi */
2434                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
2435                 if (!lmd->lmd_profile)
2436                         RETURN(-ENOMEM);
2437                 sprintf(lmd->lmd_profile, "%s-client", s1);
2438         }
2439
2440         /* Freed in lustre_free_lsi */
2441         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
2442         if (!lmd->lmd_dev)
2443                 RETURN(-ENOMEM);
2444         strcpy(lmd->lmd_dev, devname);
2445
2446         /* Save mount options */
2447         s1 = options + strlen(options) - 1;
2448         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
2449                 *s1-- = 0;
2450         if (*options != 0) {
2451                 /* Freed in lustre_free_lsi */
2452                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
2453                 if (!lmd->lmd_opts)
2454                         RETURN(-ENOMEM);
2455                 strcpy(lmd->lmd_opts, options);
2456         }
2457
2458         lmd_print(lmd);
2459         lmd->lmd_magic = LMD_MAGIC;
2460
2461         RETURN(rc);
2462
2463 invalid:
2464         CERROR("Bad mount options %s\n", options);
2465         RETURN(-EINVAL);
2466 }
2467
2468 struct lustre_mount_data2 {
2469         void *lmd2_data;
2470         struct vfsmount *lmd2_mnt;
2471 };
2472
2473 /** This is the entry point for the mount call into Lustre.
2474  * This is called when a server or client is mounted,
2475  * and this is where we start setting things up.
2476  * @param data Mount options (e.g. -o flock,abort_recov)
2477  */
2478 int lustre_fill_super(struct super_block *sb, void *data, int silent)
2479 {
2480         struct lustre_mount_data *lmd;
2481         struct lustre_mount_data2 *lmd2 = data;
2482         struct lustre_sb_info *lsi;
2483         int rc;
2484         ENTRY;
2485
2486         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
2487
2488         lsi = lustre_init_lsi(sb);
2489         if (!lsi)
2490                 RETURN(-ENOMEM);
2491         lmd = lsi->lsi_lmd;
2492
2493         /*
2494          * Disable lockdep during mount, because mount locking patterns are
2495          * `special'.
2496          */
2497         cfs_lockdep_off();
2498
2499         /*
2500          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
2501          */
2502         obd_zombie_barrier();
2503
2504         /* Figure out the lmd from the mount options */
2505         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
2506                 lustre_put_lsi(sb);
2507                 GOTO(out, rc = -EINVAL);
2508         }
2509
2510         if (lmd_is_client(lmd)) {
2511                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
2512                 if (!client_fill_super) {
2513                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
2514                                            "client mount! Is the 'lustre' "
2515                                            "module loaded?\n");
2516                         lustre_put_lsi(sb);
2517                         rc = -ENODEV;
2518                 } else {
2519                         rc = lustre_start_mgc(sb);
2520                         if (rc) {
2521                                 lustre_put_lsi(sb);
2522                                 GOTO(out, rc);
2523                         }
2524                         /* Connect and start */
2525                         /* (should always be ll_fill_super) */
2526                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
2527                         /* c_f_s will call lustre_common_put_super on failure */
2528                 }
2529         } else {
2530                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
2531                 lsi->lsi_flags |= LSI_SERVER;
2532                 rc = server_fill_super(sb);
2533                 /* s_f_s calls lustre_start_mgc after the mount because we need
2534                    the MGS nids which are stored on disk.  Plus, we may
2535                    need to start the MGS first. */
2536                 /* s_f_s will call server_put_super on failure */
2537         }
2538
2539         /* If error happens in fill_super() call, @lsi will be killed there.
2540          * This is why we do not put it here. */
2541         GOTO(out, rc);
2542 out:
2543         if (rc) {
2544                 CERROR("Unable to mount %s (%d)\n",
2545                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
2546         } else {
2547                 CDEBUG(D_SUPER, "Mount %s complete\n",
2548                        lmd->lmd_dev);
2549         }
2550         cfs_lockdep_on();
2551         return rc;
2552 }
2553
2554
2555 /* We can't call ll_fill_super by name because it lives in a module that
2556    must be loaded after this one. */
2557 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
2558                                                   struct vfsmount *mnt))
2559 {
2560         client_fill_super = cfs;
2561 }
2562
2563 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
2564 {
2565         kill_super_cb = cfs;
2566 }
2567
2568 /***************** FS registration ******************/
2569
2570 int lustre_get_sb(struct file_system_type *fs_type, int flags,
2571                   const char *devname, void * data, struct vfsmount *mnt)
2572 {
2573         struct lustre_mount_data2 lmd2 = {data, mnt};
2574
2575         return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
2576 }
2577
2578 void lustre_kill_super(struct super_block *sb)
2579 {
2580         struct lustre_sb_info *lsi = s2lsi(sb);
2581
2582         if (kill_super_cb && lsi && !(lsi->lsi_flags & LSI_SERVER))
2583                 (*kill_super_cb)(sb);
2584
2585         kill_anon_super(sb);
2586 }
2587
2588 /** Register the "lustre" fs type
2589  */
2590 struct file_system_type lustre_fs_type = {
2591         .owner        = THIS_MODULE,
2592         .name         = "lustre",
2593         .get_sb       = lustre_get_sb,
2594         .kill_sb      = lustre_kill_super,
2595         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
2596 #ifdef FS_HAS_FIEMAP
2597                         FS_HAS_FIEMAP |
2598 #endif
2599                         LL_RENAME_DOES_D_MOVE,
2600 };
2601
2602 int lustre_register_fs(void)
2603 {
2604         return register_filesystem(&lustre_fs_type);
2605 }
2606
2607 int lustre_unregister_fs(void)
2608 {
2609         return unregister_filesystem(&lustre_fs_type);
2610 }
2611
2612 EXPORT_SYMBOL(lustre_register_client_fill_super);
2613 EXPORT_SYMBOL(lustre_register_kill_super_cb);
2614 EXPORT_SYMBOL(lustre_common_put_super);
2615 EXPORT_SYMBOL(lustre_process_log);
2616 EXPORT_SYMBOL(lustre_end_log);
2617 EXPORT_SYMBOL(server_get_mount);
2618 EXPORT_SYMBOL(server_get_mount_2);
2619 EXPORT_SYMBOL(server_put_mount);
2620 EXPORT_SYMBOL(server_put_mount_2);
2621 EXPORT_SYMBOL(server_register_target);
2622 EXPORT_SYMBOL(server_name2index);
2623 EXPORT_SYMBOL(server_mti_print);
2624 EXPORT_SYMBOL(do_lcfg);