lustre/obdclass/obd_mount.c

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