lustre/obdclass/obd_mount.c

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