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