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