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