lustre/obdclass/obd_mount.c

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