lustre/obdclass/obd_mount.c

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