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, Intel Corporation.
  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 #ifdef HAVE_KERNEL_LOCKED
  59 #include <linux/smp_lock.h>
  60 #endif
  61
  62 static int (*client_fill_super)(struct super_block *sb,
  63                                 struct vfsmount *mnt) = NULL;
  64 static void (*kill_super_cb)(struct super_block *sb) = NULL;
  65
  66 /*********** mount lookup *********/
  67
  68 DEFINE_MUTEX(lustre_mount_info_lock);
  69 static CFS_LIST_HEAD(server_mount_info_list);
  70
  71 static struct lustre_mount_info *server_find_mount(const char *name)
  72 {
  73         cfs_list_t *tmp;
  74         struct lustre_mount_info *lmi;
  75         ENTRY;
  76
  77         cfs_list_for_each(tmp, &server_mount_info_list) {
  78                 lmi = cfs_list_entry(tmp, struct lustre_mount_info,
  79                                      lmi_list_chain);
  80                 if (strcmp(name, lmi->lmi_name) == 0)
  81                         RETURN(lmi);
  82         }
  83         RETURN(NULL);
  84 }
  85
  86 /* we must register an obd for a mount before we call the setup routine.
  87    *_setup will call lustre_get_mount to get the mnt struct
  88    by obd_name, since we can't pass the pointer to setup. */
  89 static int server_register_mount(const char *name, struct super_block *sb,
  90                           struct vfsmount *mnt)
  91 {
  92         struct lustre_mount_info *lmi;
  93         char *name_cp;
  94         ENTRY;
  95
  96         LASSERT(sb);
  97
  98         OBD_ALLOC(lmi, sizeof(*lmi));
  99         if (!lmi)
 100                 RETURN(-ENOMEM);
 101         OBD_ALLOC(name_cp, strlen(name) + 1);
 102         if (!name_cp) {
 103                 OBD_FREE(lmi, sizeof(*lmi));
 104                 RETURN(-ENOMEM);
 105         }
 106         strcpy(name_cp, name);
 107
 108         mutex_lock(&lustre_mount_info_lock);
 109
 110         if (server_find_mount(name)) {
 111                 mutex_unlock(&lustre_mount_info_lock);
 112                 OBD_FREE(lmi, sizeof(*lmi));
 113                 OBD_FREE(name_cp, strlen(name) + 1);
 114                 CERROR("Already registered %s\n", name);
 115                 RETURN(-EEXIST);
 116         }
 117         lmi->lmi_name = name_cp;
 118         lmi->lmi_sb = sb;
 119         lmi->lmi_mnt = mnt;
 120         cfs_list_add(&lmi->lmi_list_chain, &server_mount_info_list);
 121
 122         mutex_unlock(&lustre_mount_info_lock);
 123
 124         CDEBUG(D_MOUNT, "reg_mnt %p from %s\n", lmi->lmi_mnt, name);
 125
 126         RETURN(0);
 127 }
 128
 129 /* when an obd no longer needs a mount */
 130 static int server_deregister_mount(const char *name)
 131 {
 132         struct lustre_mount_info *lmi;
 133         ENTRY;
 134
 135         mutex_lock(&lustre_mount_info_lock);
 136         lmi = server_find_mount(name);
 137         if (!lmi) {
 138                 mutex_unlock(&lustre_mount_info_lock);
 139                 CERROR("%s not registered\n", name);
 140                 RETURN(-ENOENT);
 141         }
 142
 143         CDEBUG(D_MOUNT, "dereg_mnt %p from %s\n", lmi->lmi_mnt, name);
 144
 145         OBD_FREE(lmi->lmi_name, strlen(lmi->lmi_name) + 1);
 146         cfs_list_del(&lmi->lmi_list_chain);
 147         OBD_FREE(lmi, sizeof(*lmi));
 148         mutex_unlock(&lustre_mount_info_lock);
 149
 150         RETURN(0);
 151 }
 152
 153 /* obd's look up a registered mount using their obdname. This is just
 154    for initial obd setup to find the mount struct.  It should not be
 155    called every time you want to mntget. */
 156 struct lustre_mount_info *server_get_mount(const char *name)
 157 {
 158         struct lustre_mount_info *lmi;
 159         struct lustre_sb_info *lsi;
 160         ENTRY;
 161
 162         mutex_lock(&lustre_mount_info_lock);
 163         lmi = server_find_mount(name);
 164         mutex_unlock(&lustre_mount_info_lock);
 165         if (!lmi) {
 166                 CERROR("Can't find mount for %s\n", name);
 167                 RETURN(NULL);
 168         }
 169         lsi = s2lsi(lmi->lmi_sb);
 170
 171         cfs_atomic_inc(&lsi->lsi_mounts);
 172
 173         CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d\n", lmi->lmi_mnt,
 174                name, cfs_atomic_read(&lsi->lsi_mounts));
 175
 176         RETURN(lmi);
 177 }
 178 EXPORT_SYMBOL(server_get_mount);
 179
 180 /*
 181  * Used by mdt to get mount_info from obdname.
 182  * There are no blocking when using the mount_info.
 183  * Do not use server_get_mount for this purpose.
 184  */
 185 struct lustre_mount_info *server_get_mount_2(const char *name)
 186 {
 187         struct lustre_mount_info *lmi;
 188         ENTRY;
 189
 190         mutex_lock(&lustre_mount_info_lock);
 191         lmi = server_find_mount(name);
 192         mutex_unlock(&lustre_mount_info_lock);
 193         if (!lmi)
 194                 CERROR("Can't find mount for %s\n", name);
 195
 196         RETURN(lmi);
 197 }
 198 EXPORT_SYMBOL(server_get_mount_2);
 199
 200 static int lustre_put_lsi(struct super_block *sb);
 201
 202 /* to be called from obd_cleanup methods */
 203 int server_put_mount(const char *name, struct vfsmount *mnt)
 204 {
 205         struct lustre_mount_info *lmi;
 206         struct lustre_sb_info *lsi;
 207         ENTRY;
 208
 209         mutex_lock(&lustre_mount_info_lock);
 210         lmi = server_find_mount(name);
 211         mutex_unlock(&lustre_mount_info_lock);
 212         if (!lmi) {
 213                 CERROR("Can't find mount for %s\n", name);
 214                 RETURN(-ENOENT);
 215         }
 216         lsi = s2lsi(lmi->lmi_sb);
 217
 218         CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d\n",
 219                lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts));
 220
 221         if (lustre_put_lsi(lmi->lmi_sb))
 222                 CDEBUG(D_MOUNT, "Last put of mnt %p from %s\n",
 223                        lmi->lmi_mnt, name);
 224
 225         /* this obd should never need the mount again */
 226         server_deregister_mount(name);
 227
 228         RETURN(0);
 229 }
 230 EXPORT_SYMBOL(server_put_mount);
 231
 232 /* Corresponding to server_get_mount_2 */
 233 int server_put_mount_2(const char *name, struct vfsmount *mnt)
 234 {
 235         ENTRY;
 236         RETURN(0);
 237 }
 238 EXPORT_SYMBOL(server_put_mount_2);
 239
 240 /**************** config llog ********************/
 241
 242 /** Get a config log from the MGS and process it.
 243  * This func is called for both clients and servers.
 244  * Continue to process new statements appended to the logs
 245  * (whenever the config lock is revoked) until lustre_end_log
 246  * is called.
 247  * @param sb The superblock is used by the MGC to write to the local copy of
 248  *   the config log
 249  * @param logname The name of the llog to replicate from the MGS
 250  * @param cfg Since the same mgc may be used to follow multiple config logs
 251  *   (e.g. ost1, ost2, client), the config_llog_instance keeps the state for
 252  *   this log, and is added to the mgc's list of logs to follow.
 253  */
 254 int lustre_process_log(struct super_block *sb, char *logname,
 255                      struct config_llog_instance *cfg)
 256 {
 257         struct lustre_cfg *lcfg;
 258         struct lustre_cfg_bufs *bufs;
 259         struct lustre_sb_info *lsi = s2lsi(sb);
 260         struct obd_device *mgc = lsi->lsi_mgc;
 261         int rc;
 262         ENTRY;
 263
 264         LASSERT(mgc);
 265         LASSERT(cfg);
 266
 267         OBD_ALLOC_PTR(bufs);
 268         if (bufs == NULL)
 269                 RETURN(-ENOMEM);
 270
 271         /* mgc_process_config */
 272         lustre_cfg_bufs_reset(bufs, mgc->obd_name);
 273         lustre_cfg_bufs_set_string(bufs, 1, logname);
 274         lustre_cfg_bufs_set(bufs, 2, cfg, sizeof(*cfg));
 275         lustre_cfg_bufs_set(bufs, 3, &sb, sizeof(sb));
 276         lcfg = lustre_cfg_new(LCFG_LOG_START, bufs);
 277         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 278         lustre_cfg_free(lcfg);
 279
 280         OBD_FREE_PTR(bufs);
 281
 282         if (rc == -EINVAL)
 283                 LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
 284                                    "failed from the MGS (%d).  Make sure this "
 285                                    "client and the MGS are running compatible "
 286                                    "versions of Lustre.\n",
 287                                    mgc->obd_name, logname, rc);
 288
 289         if (rc)
 290                 LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
 291                                    "failed (%d). This may be the result of "
 292                                    "communication errors between this node and "
 293                                    "the MGS, a bad configuration, or other "
 294                                    "errors. See the syslog for more "
 295                                    "information.\n", mgc->obd_name, logname,
 296                                    rc);
 297
 298         /* class_obd_list(); */
 299         RETURN(rc);
 300 }
 301 EXPORT_SYMBOL(lustre_process_log);
 302
 303 /* Stop watching this config log for updates */
 304 int lustre_end_log(struct super_block *sb, char *logname,
 305                        struct config_llog_instance *cfg)
 306 {
 307         struct lustre_cfg *lcfg;
 308         struct lustre_cfg_bufs bufs;
 309         struct lustre_sb_info *lsi = s2lsi(sb);
 310         struct obd_device *mgc = lsi->lsi_mgc;
 311         int rc;
 312         ENTRY;
 313
 314         if (!mgc)
 315                 RETURN(-ENOENT);
 316
 317         /* mgc_process_config */
 318         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
 319         lustre_cfg_bufs_set_string(&bufs, 1, logname);
 320         if (cfg)
 321                 lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
 322         lcfg = lustre_cfg_new(LCFG_LOG_END, &bufs);
 323         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 324         lustre_cfg_free(lcfg);
 325         RETURN(rc);
 326 }
 327 EXPORT_SYMBOL(lustre_end_log);
 328
 329 /**************** obd start *******************/
 330
 331 /** lustre_cfg_bufs are a holdover from 1.4; we can still set these up from
 332  * lctl (and do for echo cli/srv.
 333  */
 334 int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
 335             char *s1, char *s2, char *s3, char *s4)
 336 {
 337         struct lustre_cfg_bufs bufs;
 338         struct lustre_cfg    * lcfg = NULL;
 339         int rc;
 340
 341         CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
 342                cmd, s1, s2, s3, s4);
 343
 344         lustre_cfg_bufs_reset(&bufs, cfgname);
 345         if (s1)
 346                 lustre_cfg_bufs_set_string(&bufs, 1, s1);
 347         if (s2)
 348                 lustre_cfg_bufs_set_string(&bufs, 2, s2);
 349         if (s3)
 350                 lustre_cfg_bufs_set_string(&bufs, 3, s3);
 351         if (s4)
 352                 lustre_cfg_bufs_set_string(&bufs, 4, s4);
 353
 354         lcfg = lustre_cfg_new(cmd, &bufs);
 355         lcfg->lcfg_nid = nid;
 356         rc = class_process_config(lcfg);
 357         lustre_cfg_free(lcfg);
 358         return(rc);
 359 }
 360 EXPORT_SYMBOL(do_lcfg);
 361
 362 /** Call class_attach and class_setup.  These methods in turn call
 363  * obd type-specific methods.
 364  */
 365 static int lustre_start_simple(char *obdname, char *type, char *uuid,
 366                                char *s1, char *s2, char *s3, char *s4)
 367 {
 368         int rc;
 369         CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
 370
 371         rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, 0, 0);
 372         if (rc) {
 373                 CERROR("%s attach error %d\n", obdname, rc);
 374                 return(rc);
 375         }
 376         rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, s3, s4);
 377         if (rc) {
 378                 CERROR("%s setup error %d\n", obdname, rc);
 379                 do_lcfg(obdname, 0, LCFG_DETACH, 0, 0, 0, 0);
 380         }
 381         return rc;
 382 }
 383
 384 /* Set up a MGS to serve startup logs */
 385 static int server_start_mgs(struct super_block *sb)
 386 {
 387         struct lustre_sb_info    *lsi = s2lsi(sb);
 388         struct vfsmount          *mnt = lsi->lsi_srv_mnt;
 389         struct lustre_mount_info *lmi;
 390         int    rc = 0;
 391         ENTRY;
 392
 393         /* It is impossible to have more than 1 MGS per node, since
 394            MGC wouldn't know which to connect to */
 395         lmi = server_find_mount(LUSTRE_MGS_OBDNAME);
 396         if (lmi) {
 397                 lsi = s2lsi(lmi->lmi_sb);
 398                 LCONSOLE_ERROR_MSG(0x15d, "The MGS service was already started"
 399                                    " from server\n");
 400                 RETURN(-EALREADY);
 401         }
 402
 403         CDEBUG(D_CONFIG, "Start MGS service %s\n", LUSTRE_MGS_OBDNAME);
 404
 405         rc = server_register_mount(LUSTRE_MGS_OBDNAME, sb, mnt);
 406
 407         if (!rc) {
 408                 rc = lustre_start_simple(LUSTRE_MGS_OBDNAME, LUSTRE_MGS_NAME,
 409                                          LUSTRE_MGS_OBDNAME, 0, 0,
 410                                          lsi->lsi_osd_obdname, 0);
 411                 /* Do NOT call server_deregister_mount() here. This leads to
 412                  * inability cleanup cleanly and free lsi and other stuff when
 413                  * mgs calls server_put_mount() in error handling case. -umka */
 414         }
 415
 416         if (rc)
 417                 LCONSOLE_ERROR_MSG(0x15e, "Failed to start MGS '%s' (%d). "
 418                                    "Is the 'mgs' module loaded?\n",
 419                                    LUSTRE_MGS_OBDNAME, rc);
 420         RETURN(rc);
 421 }
 422
 423 static int server_stop_mgs(struct super_block *sb)
 424 {
 425         struct obd_device *obd;
 426         int rc;
 427         ENTRY;
 428
 429         CDEBUG(D_MOUNT, "Stop MGS service %s\n", LUSTRE_MGS_OBDNAME);
 430
 431         /* There better be only one MGS */
 432         obd = class_name2obd(LUSTRE_MGS_OBDNAME);
 433         if (!obd) {
 434                 CDEBUG(D_CONFIG, "mgs %s not running\n", LUSTRE_MGS_OBDNAME);
 435                 RETURN(-EALREADY);
 436         }
 437
 438         /* The MGS should always stop when we say so */
 439         obd->obd_force = 1;
 440         rc = class_manual_cleanup(obd);
 441         RETURN(rc);
 442 }
 443
 444 DEFINE_MUTEX(mgc_start_lock);
 445
 446 /** Set up a mgc obd to process startup logs
 447  *
 448  * \param sb [in] super block of the mgc obd
 449  *
 450  * \retval 0 success, otherwise error code
 451  */
 452 static int lustre_start_mgc(struct super_block *sb)
 453 {
 454         struct obd_connect_data *data = NULL;
 455         struct lustre_sb_info *lsi = s2lsi(sb);
 456         struct obd_device *obd;
 457         struct obd_export *exp;
 458         struct obd_uuid *uuid;
 459         class_uuid_t uuidc;
 460         lnet_nid_t nid;
 461         char *mgcname = NULL, *niduuid = NULL, *mgssec = NULL;
 462         char *ptr;
 463         int recov_bk;
 464         int rc = 0, i = 0, j, len;
 465         ENTRY;
 466
 467         LASSERT(lsi->lsi_lmd);
 468
 469         /* Find the first non-lo MGS nid for our MGC name */
 470         if (IS_SERVER(lsi)) {
 471                 /* mount -o mgsnode=nid */
 472                 ptr = lsi->lsi_lmd->lmd_mgs;
 473                 if (lsi->lsi_lmd->lmd_mgs &&
 474                     (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
 475                         i++;
 476                 } else if (IS_MGS(lsi)) {
 477                         lnet_process_id_t id;
 478                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 479                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
 480                                         continue;
 481                                 nid = id.nid;
 482                                 i++;
 483                                 break;
 484                         }
 485                 }
 486         } else { /* client */
 487                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 488                 ptr = lsi->lsi_lmd->lmd_dev;
 489                 if (class_parse_nid(ptr, &nid, &ptr) == 0)
 490                         i++;
 491         }
 492         if (i == 0) {
 493                 CERROR("No valid MGS nids found.\n");
 494                 RETURN(-EINVAL);
 495         }
 496
 497         mutex_lock(&mgc_start_lock);
 498
 499         len = strlen(LUSTRE_MGC_OBDNAME) + strlen(libcfs_nid2str(nid)) + 1;
 500         OBD_ALLOC(mgcname, len);
 501         OBD_ALLOC(niduuid, len + 2);
 502         if (!mgcname || !niduuid)
 503                 GOTO(out_free, rc = -ENOMEM);
 504         sprintf(mgcname, "%s%s", LUSTRE_MGC_OBDNAME, libcfs_nid2str(nid));
 505
 506         mgssec = lsi->lsi_lmd->lmd_mgssec ? lsi->lsi_lmd->lmd_mgssec : "";
 507
 508         OBD_ALLOC_PTR(data);
 509         if (data == NULL)
 510                 GOTO(out_free, rc = -ENOMEM);
 511
 512         obd = class_name2obd(mgcname);
 513         if (obd && !obd->obd_stopping) {
 514                 rc = obd_set_info_async(NULL, obd->obd_self_export,
 515                                         strlen(KEY_MGSSEC), KEY_MGSSEC,
 516                                         strlen(mgssec), mgssec, NULL);
 517                 if (rc)
 518                         GOTO(out_free, rc);
 519
 520                 /* Re-using an existing MGC */
 521                 cfs_atomic_inc(&obd->u.cli.cl_mgc_refcount);
 522
 523                 /* IR compatibility check, only for clients */
 524                 if (lmd_is_client(lsi->lsi_lmd)) {
 525                         int has_ir;
 526                         int vallen = sizeof(*data);
 527                         __u32 *flags = &lsi->lsi_lmd->lmd_flags;
 528
 529                         rc = obd_get_info(NULL, obd->obd_self_export,
 530                                           strlen(KEY_CONN_DATA), KEY_CONN_DATA,
 531                                           &vallen, data, NULL);
 532                         LASSERT(rc == 0);
 533                         has_ir = OCD_HAS_FLAG(data, IMP_RECOV);
 534                         if (has_ir ^ !(*flags & LMD_FLG_NOIR)) {
 535                                 /* LMD_FLG_NOIR is for test purpose only */
 536                                 LCONSOLE_WARN(
 537                                     "Trying to mount a client with IR setting "
 538                                     "not compatible with current mgc. "
 539                                     "Force to use current mgc setting that is "
 540                                     "IR %s.\n",
 541                                     has_ir ? "enabled" : "disabled");
 542                                 if (has_ir)
 543                                         *flags &= ~LMD_FLG_NOIR;
 544                                 else
 545                                         *flags |= LMD_FLG_NOIR;
 546                         }
 547                 }
 548
 549                 recov_bk = 0;
 550                 /* If we are restarting the MGS, don't try to keep the MGC's
 551                    old connection, or registration will fail. */
 552                 if (IS_MGS(lsi)) {
 553                         CDEBUG(D_MOUNT, "New MGS with live MGC\n");
 554                         recov_bk = 1;
 555                 }
 556
 557                 /* Try all connections, but only once (again).
 558                    We don't want to block another target from starting
 559                    (using its local copy of the log), but we do want to connect
 560                    if at all possible. */
 561                 recov_bk++;
 562                 CDEBUG(D_MOUNT, "%s: Set MGC reconnect %d\n", mgcname,recov_bk);
 563                 rc = obd_set_info_async(NULL, obd->obd_self_export,
 564                                         sizeof(KEY_INIT_RECOV_BACKUP),
 565                                         KEY_INIT_RECOV_BACKUP,
 566                                         sizeof(recov_bk), &recov_bk, NULL);
 567                 GOTO(out, rc = 0);
 568         }
 569
 570         CDEBUG(D_MOUNT, "Start MGC '%s'\n", mgcname);
 571
 572         /* Add the primary nids for the MGS */
 573         i = 0;
 574         sprintf(niduuid, "%s_%x", mgcname, i);
 575         if (IS_SERVER(lsi)) {
 576                 ptr = lsi->lsi_lmd->lmd_mgs;
 577                 if (IS_MGS(lsi)) {
 578                         /* Use local nids (including LO) */
 579                         lnet_process_id_t id;
 580                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
 581                                 rc = do_lcfg(mgcname, id.nid,
 582                                              LCFG_ADD_UUID, niduuid, 0,0,0);
 583                         }
 584                 } else {
 585                         /* Use mgsnode= nids */
 586                         /* mount -o mgsnode=nid */
 587                         if (lsi->lsi_lmd->lmd_mgs) {
 588                                 ptr = lsi->lsi_lmd->lmd_mgs;
 589                         } else if (class_find_param(ptr, PARAM_MGSNODE,
 590                                                     &ptr) != 0) {
 591                                 CERROR("No MGS nids given.\n");
 592                                 GOTO(out_free, rc = -EINVAL);
 593                         }
 594                         while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 595                                 rc = do_lcfg(mgcname, nid,
 596                                              LCFG_ADD_UUID, niduuid, 0,0,0);
 597                                 i++;
 598                         }
 599                 }
 600         } else { /* client */
 601                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
 602                 ptr = lsi->lsi_lmd->lmd_dev;
 603                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
 604                         rc = do_lcfg(mgcname, nid,
 605                                      LCFG_ADD_UUID, niduuid, 0,0,0);
 606                         i++;
 607                         /* Stop at the first failover nid */
 608                         if (*ptr == ':')
 609                                 break;
 610                 }
 611         }
 612         if (i == 0) {
 613                 CERROR("No valid MGS nids found.\n");
 614                 GOTO(out_free, rc = -EINVAL);
 615         }
 616         lsi->lsi_lmd->lmd_mgs_failnodes = 1;
 617
 618         /* Random uuid for MGC allows easier reconnects */
 619         OBD_ALLOC_PTR(uuid);
 620         ll_generate_random_uuid(uuidc);
 621         class_uuid_unparse(uuidc, uuid);
 622
 623         /* Start the MGC */
 624         rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
 625                                  (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
 626                                  niduuid, 0, 0);
 627         OBD_FREE_PTR(uuid);
 628         if (rc)
 629                 GOTO(out_free, rc);
 630
 631         /* Add any failover MGS nids */
 632         i = 1;
 633         while (ptr && ((*ptr == ':' ||
 634                class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0))) {
 635                 /* New failover node */
 636                 sprintf(niduuid, "%s_%x", mgcname, i);
 637                 j = 0;
 638                 while (class_parse_nid_quiet(ptr, &nid, &ptr) == 0) {
 639                         j++;
 640                         rc = do_lcfg(mgcname, nid,
 641                                      LCFG_ADD_UUID, niduuid, 0,0,0);
 642                         if (*ptr == ':')
 643                                 break;
 644                 }
 645                 if (j > 0) {
 646                         rc = do_lcfg(mgcname, 0, LCFG_ADD_CONN,
 647                                      niduuid, 0, 0, 0);
 648                         i++;
 649                 } else {
 650                         /* at ":/fsname" */
 651                         break;
 652                 }
 653         }
 654         lsi->lsi_lmd->lmd_mgs_failnodes = i;
 655
 656         obd = class_name2obd(mgcname);
 657         if (!obd) {
 658                 CERROR("Can't find mgcobd %s\n", mgcname);
 659                 GOTO(out_free, rc = -ENOTCONN);
 660         }
 661
 662         rc = obd_set_info_async(NULL, obd->obd_self_export,
 663                                 strlen(KEY_MGSSEC), KEY_MGSSEC,
 664                                 strlen(mgssec), mgssec, NULL);
 665         if (rc)
 666                 GOTO(out_free, rc);
 667
 668         /* Keep a refcount of servers/clients who started with "mount",
 669            so we know when we can get rid of the mgc. */
 670         cfs_atomic_set(&obd->u.cli.cl_mgc_refcount, 1);
 671
 672         /* Try all connections, but only once. */
 673         recov_bk = 1;
 674         rc = obd_set_info_async(NULL, obd->obd_self_export,
 675                                 sizeof(KEY_INIT_RECOV_BACKUP),
 676                                 KEY_INIT_RECOV_BACKUP,
 677                                 sizeof(recov_bk), &recov_bk, NULL);
 678         if (rc)
 679                 /* nonfatal */
 680                 CWARN("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
 681
 682         /* We connect to the MGS at setup, and don't disconnect until cleanup */
 683         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
 684                                   OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV |
 685                                   OBD_CONNECT_LVB_TYPE;
 686
 687 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 2, 50, 0)
 688         data->ocd_connect_flags |= OBD_CONNECT_MNE_SWAB;
 689 #else
 690 #warning "LU-1644: Remove old OBD_CONNECT_MNE_SWAB fixup and imp_need_mne_swab"
 691 #endif
 692
 693         if (lmd_is_client(lsi->lsi_lmd) &&
 694             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
 695                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
 696         data->ocd_version = LUSTRE_VERSION_CODE;
 697         rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
 698         if (rc) {
 699                 CERROR("connect failed %d\n", rc);
 700                 GOTO(out, rc);
 701         }
 702
 703         obd->u.cli.cl_mgc_mgsexp = exp;
 704
 705 out:
 706         /* Keep the mgc info in the sb. Note that many lsi's can point
 707            to the same mgc.*/
 708         lsi->lsi_mgc = obd;
 709 out_free:
 710         mutex_unlock(&mgc_start_lock);
 711
 712         if (data)
 713                 OBD_FREE_PTR(data);
 714         if (mgcname)
 715                 OBD_FREE(mgcname, len);
 716         if (niduuid)
 717                 OBD_FREE(niduuid, len + 2);
 718         RETURN(rc);
 719 }
 720
 721 static int lustre_stop_mgc(struct super_block *sb)
 722 {
 723         struct lustre_sb_info *lsi = s2lsi(sb);
 724         struct obd_device *obd;
 725         char *niduuid = 0, *ptr = 0;
 726         int i, rc = 0, len = 0;
 727         ENTRY;
 728
 729         if (!lsi)
 730                 RETURN(-ENOENT);
 731         obd = lsi->lsi_mgc;
 732         if (!obd)
 733                 RETURN(-ENOENT);
 734         lsi->lsi_mgc = NULL;
 735
 736         mutex_lock(&mgc_start_lock);
 737         LASSERT(cfs_atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
 738         if (!cfs_atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 739                 /* This is not fatal, every client that stops
 740                    will call in here. */
 741                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 742                        cfs_atomic_read(&obd->u.cli.cl_mgc_refcount));
 743                 GOTO(out, rc = -EBUSY);
 744         }
 745
 746         /* The MGC has no recoverable data in any case.
 747          * force shotdown set in umount_begin */
 748         obd->obd_no_recov = 1;
 749
 750         if (obd->u.cli.cl_mgc_mgsexp) {
 751                 /* An error is not fatal, if we are unable to send the
 752                    disconnect mgs ping evictor cleans up the export */
 753                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 754                 if (rc)
 755                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 756         }
 757
 758         /* Save the obdname for cleaning the nid uuids, which are
 759            obdname_XX */
 760         len = strlen(obd->obd_name) + 6;
 761         OBD_ALLOC(niduuid, len);
 762         if (niduuid) {
 763                 strcpy(niduuid, obd->obd_name);
 764                 ptr = niduuid + strlen(niduuid);
 765         }
 766
 767         rc = class_manual_cleanup(obd);
 768         if (rc)
 769                 GOTO(out, rc);
 770
 771         /* Clean the nid uuids */
 772         if (!niduuid)
 773                 GOTO(out, rc = -ENOMEM);
 774
 775         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 776                 sprintf(ptr, "_%x", i);
 777                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 778                              niduuid, 0, 0, 0);
 779                 if (rc)
 780                         CERROR("del MDC UUID %s failed: rc = %d\n",
 781                                niduuid, rc);
 782         }
 783 out:
 784         if (niduuid)
 785                 OBD_FREE(niduuid, len);
 786
 787         /* class_import_put will get rid of the additional connections */
 788         mutex_unlock(&mgc_start_lock);
 789         RETURN(rc);
 790 }
 791
 792 /* Since there's only one mgc per node, we have to change it's fs to get
 793    access to the right disk. */
 794 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
 795 {
 796         struct lustre_sb_info *lsi = s2lsi(sb);
 797         int rc;
 798         ENTRY;
 799
 800         CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
 801
 802         /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
 803         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 804                                 sizeof(KEY_SET_FS), KEY_SET_FS,
 805                                 sizeof(*sb), sb, NULL);
 806         if (rc) {
 807                 CERROR("can't set_fs %d\n", rc);
 808         }
 809
 810         RETURN(rc);
 811 }
 812
 813 static int server_mgc_clear_fs(struct obd_device *mgc)
 814 {
 815         int rc;
 816         ENTRY;
 817
 818         CDEBUG(D_MOUNT, "Unassign mgc disk\n");
 819
 820         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 821                                 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
 822                                 0, NULL, NULL);
 823         RETURN(rc);
 824 }
 825
 826 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
 827  * @param [in] svname server name including type and index
 828  * @param [out] fsname Buffer to copy filesystem name prefix into.
 829  *  Must have at least 'strlen(fsname) + 1' chars.
 830  * @param [out] endptr if endptr isn't NULL it is set to end of fsname
 831  * rc < 0  on error
 832  */
 833 int server_name2fsname(char *svname, char *fsname, char **endptr)
 834 {
 835         char *dash = strrchr(svname, '-');
 836         if (!dash) {
 837                 dash = strrchr(svname, ':');
 838                 if (!dash)
 839                         return -EINVAL;
 840         }
 841
 842         /* interpret <fsname>-MDTXXXXX-mdc as mdt, the better way is to pass
 843          * in the fsname, then determine the server index */
 844         if (!strcmp(LUSTRE_MDC_NAME, dash + 1)) {
 845                 dash--;
 846                 for (; dash > svname && *dash != '-' && *dash != ':'; dash--)
 847                         ;
 848                 if (dash == svname)
 849                         return -EINVAL;
 850         }
 851
 852         if (fsname != NULL) {
 853                 strncpy(fsname, svname, dash - svname);
 854                 fsname[dash - svname] = '\0';
 855         }
 856
 857         if (endptr != NULL)
 858                 *endptr = dash;
 859
 860         return 0;
 861 }
 862 EXPORT_SYMBOL(server_name2fsname);
 863
 864 static int is_mdc_device(char *devname)
 865 {
 866         char *ptr;
 867         ptr = strrchr(devname, '-');
 868         if (ptr != NULL && strcmp(ptr, "-mdc") == 0)
 869                 return 1;
 870         return 0;
 871 }
 872
 873 static int inline tgt_is_mdt0(char *tgtname)
 874 {
 875         __u32 idx;
 876         int   type;
 877
 878         type = server_name2index(tgtname, &idx, NULL);
 879         if (type != LDD_F_SV_TYPE_MDT)
 880                 return 0;
 881
 882         return (idx == 0) ? 1 :0;
 883 }
 884
 885 static int inline is_mdc_for_mdt0(char *devname)
 886 {
 887         char   *ptr;
 888
 889         if (!is_mdc_device(devname))
 890                 return 0;
 891
 892         ptr = strrchr(devname, '-');
 893         if (ptr == NULL)
 894                 return 0;
 895
 896         *ptr = 0;
 897         if (tgt_is_mdt0(devname)) {
 898                 *ptr = '-';
 899                 return 1;
 900         }
 901         *ptr = '-';
 902         return 0;
 903 }
 904
 905 /**
 906  * Convert OST/MDT name(fsname-OSTxxxx) to an osp name
 907  * (fsname-MDT0000-osp-OSTxxxx), which will be used to
 908  * communicate with MDT0 for this target.
 909  **/
 910 int tgt_name2ospname(char *svname, char *ospname)
 911 {
 912         char *fsname;
 913         char *tgt;
 914         int   rc;
 915         ENTRY;
 916
 917         OBD_ALLOC(fsname, MTI_NAME_MAXLEN);
 918         if (fsname == NULL)
 919                 RETURN(-ENOMEM);
 920
 921         rc = server_name2fsname(svname, fsname, &tgt);
 922         if (rc != 0) {
 923                 CERROR("%s change fsname error: rc %d\n", svname, rc);
 924                 GOTO(cleanup, rc);
 925         }
 926
 927         if (*tgt != '-' && *tgt != ':') {
 928                 CERROR("%s wrong svname name!\n", svname);
 929                 GOTO(cleanup, rc = -EINVAL);
 930         }
 931
 932         tgt++;
 933         if (strncmp(tgt, "OST", 3) != 0 && strncmp(tgt, "MDT", 3) != 0) {
 934                 CERROR("%s is not an OST or MDT target!\n", svname);
 935                 GOTO(cleanup, rc = -EINVAL);
 936         }
 937         sprintf(ospname, "%s-MDT0000-%s-%s", fsname, LUSTRE_OSP_NAME, tgt);
 938 cleanup:
 939         if (fsname != NULL)
 940                 OBD_FREE(fsname, MTI_NAME_MAXLEN);
 941         RETURN(rc);
 942 }
 943 EXPORT_SYMBOL(tgt_name2ospname);
 944
 945 static CFS_LIST_HEAD(osp_register_list);
 946 DEFINE_MUTEX(osp_register_list_lock);
 947
 948 int lustre_register_osp_item(char *ospname, struct obd_export **exp,
 949                              register_osp_cb cb_func, void *cb_data)
 950 {
 951         struct obd_device        *osp;
 952         struct osp_register_item *ori;
 953         ENTRY;
 954
 955         LASSERTF(strlen(ospname) < MTI_NAME_MAXLEN, "ospname is too long %s\n",
 956                  ospname);
 957         LASSERT(exp != NULL && *exp == NULL);
 958
 959         OBD_ALLOC_PTR(ori);
 960         if (ori == NULL)
 961                 RETURN(-ENOMEM);
 962
 963         mutex_lock(&osp_register_list_lock);
 964
 965         osp = class_name2obd(ospname);
 966         if (osp != NULL && osp->obd_set_up == 1) {
 967                 struct obd_uuid *uuid;
 968
 969                 OBD_ALLOC_PTR(uuid);
 970                 if (uuid == NULL) {
 971                         mutex_unlock(&osp_register_list_lock);
 972                         OBD_FREE_PTR(ori);
 973                         RETURN(-ENOMEM);
 974                 }
 975                 memcpy(uuid->uuid, ospname, strlen(ospname));
 976                 *exp = cfs_hash_lookup(osp->obd_uuid_hash, uuid);
 977                 OBD_FREE_PTR(uuid);
 978         }
 979
 980         memcpy(ori->ori_name, ospname, strlen(ospname));
 981         ori->ori_exp = exp;
 982         ori->ori_cb_func = cb_func;
 983         ori->ori_cb_data = cb_data;
 984         CFS_INIT_LIST_HEAD(&ori->ori_list);
 985         cfs_list_add(&ori->ori_list, &osp_register_list);
 986
 987         if (*exp != NULL && cb_func != NULL)
 988                 cb_func(cb_data);
 989
 990         mutex_unlock(&osp_register_list_lock);
 991         RETURN(0);
 992 }
 993 EXPORT_SYMBOL(lustre_register_osp_item);
 994
 995 void lustre_deregister_osp_item(struct obd_export **exp)
 996 {
 997         struct osp_register_item *ori, *tmp;
 998
 999         mutex_lock(&osp_register_list_lock);
1000         cfs_list_for_each_entry_safe(ori, tmp, &osp_register_list, ori_list) {
1001                 if (exp == ori->ori_exp) {
1002                         if (*exp)
1003                                 class_export_put(*exp);
1004                         cfs_list_del(&ori->ori_list);
1005                         OBD_FREE_PTR(ori);
1006                         break;
1007                 }
1008         }
1009         mutex_unlock(&osp_register_list_lock);
1010 }
1011 EXPORT_SYMBOL(lustre_deregister_osp_item);
1012
1013 static void lustre_notify_osp_list(struct obd_export *exp)
1014 {
1015         struct osp_register_item *ori, *tmp;
1016         LASSERT(exp != NULL);
1017
1018         mutex_lock(&osp_register_list_lock);
1019         cfs_list_for_each_entry_safe(ori, tmp, &osp_register_list, ori_list) {
1020                 if (strcmp(exp->exp_obd->obd_name, ori->ori_name))
1021                         continue;
1022                 if (*ori->ori_exp != NULL)
1023                         continue;
1024                 *ori->ori_exp = class_export_get(exp);
1025                 if (ori->ori_cb_func != NULL)
1026                         ori->ori_cb_func(ori->ori_cb_data);
1027         }
1028         mutex_unlock(&osp_register_list_lock);
1029 }
1030
1031 static int lustre_osp_connect(struct obd_device *osp)
1032 {
1033         struct lu_env            env;
1034         struct lu_context        session_ctx;
1035         struct obd_export       *exp;
1036         struct obd_uuid         *uuid = NULL;
1037         struct obd_connect_data *data = NULL;
1038         int                      rc;
1039         ENTRY;
1040
1041         /* log has been fully processed, let clients connect */
1042         rc = lu_env_init(&env, osp->obd_lu_dev->ld_type->ldt_ctx_tags);
1043         if (rc != 0)
1044                 RETURN(rc);
1045
1046         lu_context_init(&session_ctx, LCT_SESSION);
1047         session_ctx.lc_thread = NULL;
1048         lu_context_enter(&session_ctx);
1049         env.le_ses = &session_ctx;
1050
1051         OBD_ALLOC_PTR(data);
1052         if (data == NULL)
1053                 GOTO(out, rc = -ENOMEM);
1054
1055         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX;
1056         data->ocd_version = LUSTRE_VERSION_CODE;
1057         data->ocd_connect_flags |= OBD_CONNECT_MDS_MDS | OBD_CONNECT_FID |
1058                                    OBD_CONNECT_AT | OBD_CONNECT_LRU_RESIZE |
1059                                    OBD_CONNECT_FULL20 | OBD_CONNECT_LVB_TYPE |
1060                                    OBD_CONNECT_LIGHTWEIGHT;
1061         OBD_ALLOC_PTR(uuid);
1062         if (uuid == NULL)
1063                 GOTO(out, rc = -ENOMEM);
1064
1065         if (strlen(osp->obd_name) > sizeof(uuid->uuid)) {
1066                 CERROR("%s: Too long osp name %s, max_size is %d\n",
1067                        osp->obd_name, osp->obd_name, (int)sizeof(uuid->uuid));
1068                 GOTO(out, rc = -EINVAL);
1069         }
1070         /* Use osp name as the uuid, so we find the export by
1071          * osp name later */
1072         memcpy(uuid->uuid, osp->obd_name, strlen(osp->obd_name));
1073         rc = obd_connect(&env, &exp, osp, uuid, data, NULL);
1074         if (rc != 0)
1075                 CERROR("%s: connect failed: rc = %d\n", osp->obd_name, rc);
1076         else
1077                 lustre_notify_osp_list(exp);
1078
1079 out:
1080         if (data != NULL)
1081                 OBD_FREE_PTR(data);
1082         if (uuid != NULL)
1083                 OBD_FREE_PTR(uuid);
1084
1085         lu_env_fini(&env);
1086         lu_context_exit(&session_ctx);
1087         lu_context_fini(&session_ctx);
1088
1089         RETURN(rc);
1090 }
1091
1092 /**
1093  * osp-on-ost is used by slaves (Non-MDT0 targets) to manage the connection
1094  * to MDT0.
1095  *
1096  * The OSTs will communicate with MDT0 by the connection established by the
1097  * osp-on-ost to get quota and fid sequence.
1098  *
1099  **/
1100 static int lustre_osp_setup(struct lustre_cfg *lcfg, struct lustre_sb_info *lsi)
1101 {
1102         struct obd_connect_data *data = NULL;
1103         struct obd_device       *obd;
1104         char                    *ospname = NULL;
1105         char                    *ospuuid = NULL;
1106         int                      rc;
1107         ENTRY;
1108
1109         rc = class_add_uuid(lustre_cfg_string(lcfg, 1),
1110                             lcfg->lcfg_nid);
1111         if (rc) {
1112                 CERROR("%s: Can't add uuid: rc =%d\n", lsi->lsi_svname, rc);
1113                 GOTO(out, rc);
1114         }
1115
1116         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1117         if (ospname == NULL)
1118                 GOTO(out, rc = -ENOMEM);
1119
1120         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1121         if (rc != 0) {
1122                 CERROR("%s change ospname error: rc %d\n",
1123                        lsi->lsi_svname, rc);
1124                 GOTO(out, rc);
1125         }
1126
1127         OBD_ALLOC(ospuuid, MTI_NAME_MAXLEN);
1128         if (ospuuid == NULL)
1129                 GOTO(out, rc = -ENOMEM);
1130
1131         sprintf(ospuuid, "%s_UUID", ospname);
1132         rc = lustre_start_simple(ospname, LUSTRE_OSP_NAME,
1133                                  ospuuid, lustre_cfg_string(lcfg, 1),
1134                                  0, 0, 0);
1135         if (rc) {
1136                 CERROR("%s: setup up failed: rc %d\n", ospname, rc);
1137                 GOTO(out, rc);
1138         }
1139
1140         obd = class_name2obd(ospname);
1141         LASSERT(obd != NULL);
1142
1143         rc = lustre_osp_connect(obd);
1144         if (rc != 0)
1145                 CERROR("%s: connect failed: rc = %d\n", ospname, rc);
1146 out:
1147         if (data != NULL)
1148                 OBD_FREE_PTR(data);
1149         if (ospname != NULL)
1150                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1151         if (ospuuid != NULL)
1152                 OBD_FREE(ospuuid, MTI_NAME_MAXLEN);
1153
1154         RETURN(rc);
1155 }
1156
1157 static int lustre_osp_add_conn(struct lustre_cfg *cfg,
1158                                struct lustre_sb_info *lsi)
1159 {
1160         struct lustre_cfg_bufs *bufs = NULL;
1161         struct lustre_cfg      *lcfg = NULL;
1162         char                   *ospname = NULL;
1163         struct obd_device      *osp;
1164         int                     rc;
1165         ENTRY;
1166
1167         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1168         if (ospname == NULL)
1169                 GOTO(out, rc = -ENOMEM);
1170
1171         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1172         if (rc != 0) {
1173                 CERROR("%s change ospname error: rc %d\n",
1174                        lsi->lsi_svname, rc);
1175                 GOTO(out, rc);
1176         }
1177
1178         OBD_ALLOC_PTR(bufs);
1179         if (bufs == NULL)
1180                 GOTO(out, rc = -ENOMEM);
1181
1182         lustre_cfg_bufs_reset(bufs, ospname);
1183         lustre_cfg_bufs_set_string(bufs, 1,
1184                                    lustre_cfg_string(cfg, 1));
1185
1186         lcfg = lustre_cfg_new(LCFG_ADD_CONN, bufs);
1187
1188         osp = class_name2obd(ospname);
1189         if (osp == NULL) {
1190                 CERROR("Can not find %s\n", ospname);
1191                 GOTO(out, rc = -EINVAL);
1192         }
1193
1194         rc = class_add_conn(osp, lcfg);
1195         if (rc)
1196                 CERROR("%s: can't add conn: rc = %d\n", ospname, rc);
1197
1198 out:
1199         if (bufs != NULL)
1200                 OBD_FREE_PTR(bufs);
1201         if (lcfg != NULL)
1202                 lustre_cfg_free(lcfg);
1203         if (ospname != NULL)
1204                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1205
1206         RETURN(rc);
1207 }
1208
1209 /**
1210  * Retrieve MDT nids from the client log, then start the osp-on-ost device.
1211  * there are only two scenarios which would include mdt nid.
1212  * 1.
1213  * marker   5 (flags=0x01, v2.1.54.0) lustre-MDT0000  'add mdc' xxx-
1214  * add_uuid  nid=192.168.122.162@tcp(0x20000c0a87aa2)  0:  1:192.168.122.162@tcp
1215  * attach    0:lustre-MDT0000-mdc  1:mdc  2:lustre-clilmv_UUID
1216  * setup     0:lustre-MDT0000-mdc  1:lustre-MDT0000_UUID  2:192.168.122.162@tcp
1217  * add_uuid  nid=192.168.172.1@tcp(0x20000c0a8ac01)  0:  1:192.168.172.1@tcp
1218  * add_conn  0:lustre-MDT0000-mdc  1:192.168.172.1@tcp
1219  * modify_mdc_tgts add 0:lustre-clilmv  1:lustre-MDT0000_UUID xxxx
1220  * marker   5 (flags=0x02, v2.1.54.0) lustre-MDT0000  'add mdc' xxxx-
1221  * 2.
1222  * marker   7 (flags=0x01, v2.1.54.0) lustre-MDT0000  'add failnid' xxxx-
1223  * add_uuid  nid=192.168.122.2@tcp(0x20000c0a87a02)  0:  1:192.168.122.2@tcp
1224  * add_conn  0:lustre-MDT0000-mdc  1:192.168.122.2@tcp
1225  * marker   7 (flags=0x02, v2.1.54.0) lustre-MDT0000  'add failnid' xxxx-
1226 **/
1227 static int client_osp_config_process(const struct lu_env *env,
1228                                      struct llog_handle *handle,
1229                                      struct llog_rec_hdr *rec, void *data)
1230 {
1231         struct config_llog_instance *clli = data;
1232         int                          cfg_len = rec->lrh_len;
1233         char                        *cfg_buf = (char *) (rec + 1);
1234         struct lustre_cfg           *lcfg = NULL;
1235         struct lustre_sb_info       *lsi;
1236         int                          rc = 0, swab = 0;
1237         ENTRY;
1238
1239         if (rec->lrh_type != OBD_CFG_REC) {
1240                 CERROR("Unknown llog record type %#x encountered\n",
1241                        rec->lrh_type);
1242                 RETURN(-EINVAL);
1243         }
1244
1245         LASSERT(clli->cfg_sb != NULL);
1246         lsi = s2lsi(clli->cfg_sb);
1247
1248         lcfg = (struct lustre_cfg *)cfg_buf;
1249         if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION)) {
1250                 lustre_swab_lustre_cfg(lcfg);
1251                 swab = 1;
1252         }
1253
1254         rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
1255         if (rc)
1256                 GOTO(out, rc);
1257
1258         switch (lcfg->lcfg_command) {
1259         case LCFG_MARKER: {
1260                 struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
1261
1262                 lustre_swab_cfg_marker(marker, swab,
1263                                        LUSTRE_CFG_BUFLEN(lcfg, 1));
1264                 if (marker->cm_flags & CM_SKIP ||
1265                     marker->cm_flags & CM_EXCLUDE)
1266                         GOTO(out, rc = 0);
1267
1268                 if (!tgt_is_mdt0(marker->cm_tgtname))
1269                         GOTO(out, rc = 0);
1270
1271                 if(!strncmp(marker->cm_comment, "add mdc", 7) ||
1272                    !strncmp(marker->cm_comment, "add failnid", 11)) {
1273                         if (marker->cm_flags & CM_START) {
1274                                 clli->cfg_flags = CFG_F_MARKER;
1275                                 /* This hack is to differentiate the
1276                                  * ADD_UUID is come from "add mdc" record
1277                                  * or from "add failnid" record. */
1278                                 if (!strncmp(marker->cm_comment,
1279                                              "add failnid", 11))
1280                                         clli->cfg_flags |= CFG_F_SKIP;
1281                         } else if (marker->cm_flags & CM_END) {
1282                                 clli->cfg_flags = 0;
1283                         }
1284                 }
1285                 break;
1286         }
1287         case LCFG_ADD_UUID: {
1288                 if (clli->cfg_flags == CFG_F_MARKER) {
1289                         rc = lustre_osp_setup(lcfg, lsi);
1290                         /* XXX: process only the first nid as
1291                          * we don't need another instance of osp */
1292                         clli->cfg_flags |= CFG_F_SKIP;
1293                 } else if (clli->cfg_flags == (CFG_F_MARKER | CFG_F_SKIP)) {
1294                         rc = class_add_uuid(lustre_cfg_string(lcfg, 1),
1295                                         lcfg->lcfg_nid);
1296                         if (rc)
1297                                 CERROR("%s: Fail to add uuid, rc:%d\n",
1298                                        lsi->lsi_svname, rc);
1299                 }
1300                 break;
1301         }
1302         case LCFG_ADD_CONN: {
1303                 if (is_mdc_for_mdt0(lustre_cfg_string(lcfg, 0)))
1304                         rc = lustre_osp_add_conn(lcfg, lsi);
1305                 break;
1306         }
1307         default:
1308                 break;
1309         }
1310 out:
1311         RETURN(rc);
1312 }
1313
1314 static int lustre_disconnect_osp(struct super_block *sb)
1315 {
1316         struct lustre_sb_info           *lsi = s2lsi(sb);
1317         struct obd_device               *osp;
1318         char                            *ospname = NULL;
1319         char                            *logname = NULL;
1320         struct lustre_cfg               *lcfg = NULL;
1321         struct lustre_cfg_bufs          *bufs = NULL;
1322         struct config_llog_instance     *cfg = NULL;
1323         int                              rc;
1324         ENTRY;
1325
1326         LASSERT(IS_OST(lsi) || IS_MDT(lsi));
1327         if (IS_MDT(lsi)) {
1328                 int     index;
1329
1330                 /* Only disconnect MDT0-osp-MDT0 here, other osp on MDT
1331                  * will be disconnect during MDT stack cleanup.
1332                  * FIXME: remove later when quota on DNE is finished */
1333                 rc = server_name2index(lsi->lsi_svname, &index, NULL);
1334                 if (rc < 0)
1335                         RETURN(rc);
1336                 if (index != 0)
1337                         RETURN(0);
1338         }
1339         OBD_ALLOC(logname, MTI_NAME_MAXLEN);
1340         if (logname == NULL)
1341                 RETURN(-ENOMEM);
1342
1343         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1344         if (ospname == NULL)
1345                 GOTO(out, rc = -ENOMEM);
1346
1347         rc = server_name2fsname(lsi->lsi_svname, ospname, NULL);
1348         if (rc != 0) {
1349                 CERROR("%s: get fsname error: %d\n",
1350                        lsi->lsi_svname, rc);
1351                 GOTO(out, rc);
1352         }
1353         sprintf(logname, "%s-client", ospname);
1354
1355         OBD_ALLOC_PTR(cfg);
1356         if (cfg == NULL)
1357                 GOTO(out, rc = -ENOMEM);
1358
1359         /* end log first */
1360         cfg->cfg_instance = sb;
1361         rc = lustre_end_log(sb, logname, cfg);
1362         if (rc != 0) {
1363                 CERROR("Can't end config log %s\n", ospname);
1364                 GOTO(out, rc);
1365         }
1366
1367         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1368         if (rc != 0) {
1369                 CERROR("%s: get osp name error: %d\n",
1370                        lsi->lsi_svname, rc);
1371                 GOTO(out, rc);
1372         }
1373
1374         osp = class_name2obd(ospname);
1375         if (osp == NULL) {
1376                 CERROR("Can't find osp-on-ost %s\n", ospname);
1377                 GOTO(out, rc = -ENOENT);
1378         }
1379
1380         OBD_ALLOC_PTR(bufs);
1381         if (bufs == NULL)
1382                 GOTO(out, rc = -ENOMEM);
1383
1384         lustre_cfg_bufs_reset(bufs, osp->obd_name);
1385         lustre_cfg_bufs_set_string(bufs, 1, NULL);
1386         lcfg = lustre_cfg_new(LCFG_CLEANUP, bufs);
1387         if (!lcfg)
1388                 GOTO(out, rc = -ENOMEM);
1389
1390         /* Disconnect import first. NULL is passed for the '@env', since
1391          * it will not be used for the 'osp-on-ost'. (see osp_shutdown()) */
1392         rc = osp->obd_lu_dev->ld_ops->ldo_process_config(NULL, osp->obd_lu_dev,
1393                                                          lcfg);
1394 out:
1395         if (lcfg)
1396                 lustre_cfg_free(lcfg);
1397         if (bufs)
1398                 OBD_FREE_PTR(bufs);
1399         if (cfg)
1400                 OBD_FREE_PTR(cfg);
1401         if (ospname)
1402                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1403         if (logname)
1404                 OBD_FREE(logname, MTI_NAME_MAXLEN);
1405         RETURN(rc);
1406 }
1407
1408 /**
1409  * Stop the osp(fsname-MDT0000-osp-OSTxxxx) or (fsname-MDT0000-osp-MDT0000) for an OST target.
1410  **/
1411 static int lustre_stop_osp(struct super_block *sb)
1412 {
1413         struct lustre_sb_info   *lsi = s2lsi(sb);
1414         struct obd_device       *osp = NULL;
1415         char                    *ospname = NULL;
1416         int                      rc = 0;
1417         ENTRY;
1418
1419         LASSERT(IS_OST(lsi) || IS_MDT(lsi));
1420         if (IS_MDT(lsi)) {
1421                 int     index;
1422
1423                 /* Only disconnect MDT0-osp-MDT0 here, other osp on MDT
1424                  * will be disconnect during MDT stack cleanup.
1425                  * FIXME: remove later when quota on DNE is finished */
1426                 rc = server_name2index(lsi->lsi_svname, &index, NULL);
1427                 if (rc < 0)
1428                         RETURN(rc);
1429                 if (index != 0)
1430                         RETURN(0);
1431         }
1432
1433         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1434         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1435         if (rc != 0) {
1436                 CERROR("%s get fsname error: rc %d\n",
1437                        lsi->lsi_svname, rc);
1438                 GOTO(cleanup, rc);
1439         }
1440
1441         osp = class_name2obd(ospname);
1442         if (osp == NULL) {
1443                 CERROR("Can not find osp-on-ost %s\n", ospname);
1444                 GOTO(cleanup, rc = -ENOENT);
1445         }
1446
1447         osp->obd_force = 1;
1448         rc = class_manual_cleanup(osp);
1449
1450 cleanup:
1451         if (ospname != NULL)
1452                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1453         RETURN(rc);
1454 }
1455
1456 DEFINE_MUTEX(server_start_lock);
1457
1458 /* Stop MDS/OSS if nobody is using them */
1459 static int server_stop_servers(int lsiflags)
1460 {
1461         struct obd_device *obd = NULL;
1462         struct obd_type *type = NULL;
1463         int rc = 0;
1464         ENTRY;
1465
1466         mutex_lock(&server_start_lock);
1467
1468         /* Either an MDT or an OST or neither  */
1469         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
1470         if ((lsiflags & LDD_F_SV_TYPE_MDT) &&
1471             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
1472                 type = class_search_type(LUSTRE_MDT_NAME);
1473         }
1474        /* if this was an OST, and there are no more OST's, clean up the OSS */
1475         if ((lsiflags & LDD_F_SV_TYPE_OST) &&
1476             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
1477                 type = class_search_type(LUSTRE_OST_NAME);
1478         }
1479
1480         if (obd && (!type || !type->typ_refcnt)) {
1481                 int err;
1482                 obd->obd_force = 1;
1483                 /* obd_fail doesn't mean much on a server obd */
1484                 err = class_manual_cleanup(obd);
1485                 if (!rc)
1486                         rc = err;
1487         }
1488
1489         mutex_unlock(&server_start_lock);
1490
1491         RETURN(rc);
1492 }
1493
1494 int server_mti_print(char *title, struct mgs_target_info *mti)
1495 {
1496         PRINT_CMD(PRINT_MASK, "mti %s\n", title);
1497         PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
1498         PRINT_CMD(PRINT_MASK, "fs:     %s\n", mti->mti_fsname);
1499         PRINT_CMD(PRINT_MASK, "uuid:   %s\n", mti->mti_uuid);
1500         PRINT_CMD(PRINT_MASK, "ver: %d  flags: %#x\n",
1501                   mti->mti_config_ver, mti->mti_flags);
1502         return(0);
1503 }
1504
1505 /**
1506  * Get service name (svname) from string
1507  * rc < 0 on error
1508  * if endptr isn't NULL it is set to end of fsname *
1509  */
1510 int server_name2svname(char *label, char *svname, char **endptr)
1511 {
1512         int rc;
1513         char *dash;
1514
1515         /* We use server_name2fsname() just for parsing */
1516         rc = server_name2fsname(label, NULL, &dash);
1517         if (rc != 0)
1518                 return rc;
1519
1520         if (*dash != '-')
1521                 return -1;
1522
1523         strncpy(svname, dash + 1, MTI_NAME_MAXLEN);
1524
1525         return 0;
1526 }
1527 EXPORT_SYMBOL(server_name2svname);
1528
1529
1530 /* Get the index from the obd name.
1531    rc = server type, or
1532    rc < 0  on error
1533    if endptr isn't NULL it is set to end of name */
1534 int server_name2index(char *svname, __u32 *idx, char **endptr)
1535 {
1536         unsigned long index;
1537         int rc;
1538         char *dash;
1539
1540         /* We use server_name2fsname() just for parsing */
1541         rc = server_name2fsname(svname, NULL, &dash);
1542         if (rc != 0)
1543                 return rc;
1544
1545         if (*dash != '-')
1546                 return -EINVAL;
1547
1548         dash++;
1549
1550         if (strncmp(dash, "MDT", 3) == 0)
1551                 rc = LDD_F_SV_TYPE_MDT;
1552         else if (strncmp(dash, "OST", 3) == 0)
1553                 rc = LDD_F_SV_TYPE_OST;
1554         else
1555                 return -EINVAL;
1556
1557         dash += 3;
1558
1559         if (strcmp(dash, "all") == 0)
1560                 return rc | LDD_F_SV_ALL;
1561
1562         index = simple_strtoul(dash, endptr, 16);
1563         *idx = index;
1564
1565         return rc;
1566 }
1567 EXPORT_SYMBOL(server_name2index);
1568
1569 /* Generate data for registration */
1570 static int server_lsi2mti(struct lustre_sb_info *lsi,
1571                           struct mgs_target_info *mti)
1572 {
1573         lnet_process_id_t id;
1574         int rc, i = 0;
1575         ENTRY;
1576
1577         if (!IS_SERVER(lsi))
1578                 RETURN(-EINVAL);
1579
1580         strncpy(mti->mti_svname, lsi->lsi_svname, sizeof(mti->mti_svname));
1581
1582         mti->mti_nid_count = 0;
1583         while (LNetGetId(i++, &id) != -ENOENT) {
1584                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
1585                         continue;
1586
1587                 /* server use --servicenode param, only allow specified
1588                  * nids be registered */
1589                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) != 0 &&
1590                     class_match_nid(lsi->lsi_lmd->lmd_params,
1591                                     PARAM_FAILNODE, id.nid) < 1)
1592                         continue;
1593
1594                 /* match specified network */
1595                 if (!class_match_net(lsi->lsi_lmd->lmd_params,
1596                                      PARAM_NETWORK, LNET_NIDNET(id.nid)))
1597                         continue;
1598
1599                 mti->mti_nids[mti->mti_nid_count] = id.nid;
1600                 mti->mti_nid_count++;
1601                 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
1602                         CWARN("Only using first %d nids for %s\n",
1603                               mti->mti_nid_count, mti->mti_svname);
1604                         break;
1605                 }
1606         }
1607
1608         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
1609         mti->mti_config_ver = 0;
1610
1611         rc = server_name2fsname(lsi->lsi_svname, mti->mti_fsname, NULL);
1612         if (rc != 0)
1613                 return rc;
1614
1615         rc = server_name2index(lsi->lsi_svname, &mti->mti_stripe_index, NULL);
1616         if (rc < 0)
1617                 return rc;
1618         /* Orion requires index to be set */
1619         LASSERT(!(rc & LDD_F_NEED_INDEX));
1620         /* keep only LDD flags */
1621         mti->mti_flags = lsi->lsi_flags & LDD_F_MASK;
1622         if (mti->mti_flags & (LDD_F_WRITECONF | LDD_F_VIRGIN))
1623                 mti->mti_flags |= LDD_F_UPDATE;
1624         strncpy(mti->mti_params, lsi->lsi_lmd->lmd_params,
1625                 sizeof(mti->mti_params));
1626         return 0;
1627 }
1628
1629 /* Register an old or new target with the MGS. If needed MGS will construct
1630    startup logs and assign index */
1631 static int server_register_target(struct lustre_sb_info *lsi)
1632 {
1633         struct obd_device *mgc = lsi->lsi_mgc;
1634         struct mgs_target_info *mti = NULL;
1635         bool writeconf;
1636         int rc;
1637         ENTRY;
1638
1639         LASSERT(mgc);
1640
1641         if (!IS_SERVER(lsi))
1642                 RETURN(-EINVAL);
1643
1644         OBD_ALLOC_PTR(mti);
1645         if (!mti)
1646                 RETURN(-ENOMEM);
1647
1648         rc = server_lsi2mti(lsi, mti);
1649         if (rc)
1650                 GOTO(out, rc);
1651
1652         CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
1653                mti->mti_svname, mti->mti_fsname,
1654                libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
1655                mti->mti_flags);
1656
1657         /* if write_conf is true, the registration must succeed */
1658         writeconf = !!(lsi->lsi_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE));
1659         mti->mti_flags |= LDD_F_OPC_REG;
1660
1661         /* Register the target */
1662         /* FIXME use mgc_process_config instead */
1663         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1664                                 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1665                                 sizeof(*mti), mti, NULL);
1666         if (rc) {
1667                 if (mti->mti_flags & LDD_F_ERROR) {
1668                         LCONSOLE_ERROR_MSG(0x160,
1669                                 "The MGS is refusing to allow this "
1670                                 "server (%s) to start. Please see messages"
1671                                 " on the MGS node.\n", lsi->lsi_svname);
1672                 } else if (writeconf) {
1673                         LCONSOLE_ERROR_MSG(0x15f,
1674                                 "Communication to the MGS return error %d. "
1675                                 "Is the MGS running?\n", rc);
1676                 } else {
1677                         CERROR("Cannot talk to the MGS: %d, not fatal\n", rc);
1678                         /* reset the error code for non-fatal error. */
1679                         rc = 0;
1680                 }
1681                 GOTO(out, rc);
1682         }
1683
1684 out:
1685         if (mti)
1686                 OBD_FREE_PTR(mti);
1687         RETURN(rc);
1688 }
1689
1690 /**
1691  * Notify the MGS that this target is ready.
1692  * Used by IR - if the MGS receives this message, it will notify clients.
1693  */
1694 static int server_notify_target(struct super_block *sb, struct obd_device *obd)
1695 {
1696         struct lustre_sb_info *lsi = s2lsi(sb);
1697         struct obd_device *mgc = lsi->lsi_mgc;
1698         struct mgs_target_info *mti = NULL;
1699         int rc;
1700         ENTRY;
1701
1702         LASSERT(mgc);
1703
1704         if (!(IS_SERVER(lsi)))
1705                 RETURN(-EINVAL);
1706
1707         OBD_ALLOC_PTR(mti);
1708         if (!mti)
1709                 RETURN(-ENOMEM);
1710         rc = server_lsi2mti(lsi, mti);
1711         if (rc)
1712                 GOTO(out, rc);
1713
1714         mti->mti_instance = obd->u.obt.obt_instance;
1715         mti->mti_flags |= LDD_F_OPC_READY;
1716
1717         /* FIXME use mgc_process_config instead */
1718         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1719                                 sizeof(KEY_REGISTER_TARGET),
1720                                 KEY_REGISTER_TARGET,
1721                                 sizeof(*mti), mti, NULL);
1722
1723         /* Imperative recovery: if the mgs informs us to use IR? */
1724         if (!rc && !(mti->mti_flags & LDD_F_ERROR) &&
1725             (mti->mti_flags & LDD_F_IR_CAPABLE))
1726                 lsi->lsi_flags |= LDD_F_IR_CAPABLE;
1727
1728 out:
1729         if (mti)
1730                 OBD_FREE_PTR(mti);
1731         RETURN(rc);
1732
1733 }
1734
1735 /**
1736  * Start the osp(fsname-MDT0000-osp-OSTxxxx) for an OST target,
1737  * which would be used to communicate with MDT0 for quota and FID.
1738  **/
1739 static int lustre_start_osp(struct super_block *sb)
1740 {
1741         struct lustre_sb_info       *lsi = s2lsi(sb);
1742         struct config_llog_instance *cfg = NULL;
1743         struct obd_device           *osp;
1744         char                        *ospname = NULL;
1745         char                        *logname = NULL;
1746         char                        *tgt;
1747         int                          rc;
1748         ENTRY;
1749
1750         LASSERT(IS_OST(lsi) || IS_MDT(lsi));
1751         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1752         OBD_ALLOC(logname, MTI_NAME_MAXLEN);
1753         if (ospname == NULL || logname == NULL)
1754                 GOTO(cleanup, rc = -ENOMEM);
1755
1756         rc = server_name2fsname(lsi->lsi_svname, ospname, &tgt);
1757         if (rc != 0) {
1758                 CERROR("%s change fsname error: rc %d\n",
1759                        lsi->lsi_svname, rc);
1760                 GOTO(cleanup, rc);
1761         }
1762         sprintf(logname, "%s-client", ospname);
1763
1764         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1765         if (rc != 0) {
1766                 CERROR("%s change ospname error: rc %d\n",
1767                        lsi->lsi_svname, rc);
1768                 GOTO(cleanup, rc);
1769         }
1770
1771         osp = class_name2obd(ospname);
1772         if (osp != NULL)
1773                 GOTO(cleanup, rc = 0);
1774
1775         OBD_ALLOC_PTR(cfg);
1776         if (cfg == NULL)
1777                 GOTO(cleanup, rc = -ENOMEM);
1778
1779         cfg->cfg_callback = client_osp_config_process;
1780         cfg->cfg_instance = sb;
1781
1782         rc = lustre_process_log(sb, logname, cfg);
1783
1784 cleanup:
1785         if (ospname != NULL)
1786                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1787         if (logname != NULL)
1788                 OBD_FREE(logname, MTI_NAME_MAXLEN);
1789         if (cfg != NULL)
1790                 OBD_FREE_PTR(cfg);
1791
1792         RETURN(rc);
1793 }
1794
1795 /** Start server targets: MDTs and OSTs
1796  */
1797 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1798 {
1799         struct obd_device *obd;
1800         struct lustre_sb_info *lsi = s2lsi(sb);
1801         struct config_llog_instance cfg;
1802         struct lu_env env;
1803         struct lu_device *dev;
1804         int rc;
1805         ENTRY;
1806
1807         CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_svname);
1808
1809         if (IS_MDT(lsi)) {
1810                 /* make sure the MDS is started */
1811                 mutex_lock(&server_start_lock);
1812                 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1813                 if (!obd) {
1814                         rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1815                                                  LUSTRE_MDS_NAME,
1816                                                  LUSTRE_MDS_OBDNAME"_uuid",
1817                                                  0, 0, 0, 0);
1818                         if (rc) {
1819                                 mutex_unlock(&server_start_lock);
1820                                 CERROR("failed to start MDS: %d\n", rc);
1821                                 RETURN(rc);
1822                         }
1823                 }
1824                 mutex_unlock(&server_start_lock);
1825         }
1826
1827         /* If we're an OST, make sure the global OSS is running */
1828         if (IS_OST(lsi)) {
1829                 /* make sure OSS is started */
1830                 mutex_lock(&server_start_lock);
1831                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1832                 if (!obd) {
1833                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1834                                                  LUSTRE_OSS_NAME,
1835                                                  LUSTRE_OSS_OBDNAME"_uuid",
1836                                                  0, 0, 0, 0);
1837                         if (rc) {
1838                                 mutex_unlock(&server_start_lock);
1839                                 CERROR("failed to start OSS: %d\n", rc);
1840                                 RETURN(rc);
1841                         }
1842                 }
1843                 mutex_unlock(&server_start_lock);
1844         }
1845
1846         /* Set the mgc fs to our server disk.  This allows the MGC to
1847          * read and write configs locally, in case it can't talk to the MGS. */
1848         if (lsi->lsi_srv_mnt) {
1849                 rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1850                 if (rc)
1851                         GOTO(out_stop_service, rc);
1852         }
1853
1854         /* Register with MGS */
1855         rc = server_register_target(lsi);
1856         if (rc)
1857                 GOTO(out_mgc, rc);
1858
1859         /* Let the target look up the mount using the target's name
1860            (we can't pass the sb or mnt through class_process_config.) */
1861         rc = server_register_mount(lsi->lsi_svname, sb, mnt);
1862         if (rc)
1863                 GOTO(out_mgc, rc);
1864
1865         /* Start targets using the llog named for the target */
1866         memset(&cfg, 0, sizeof(cfg));
1867         cfg.cfg_callback = class_config_llog_handler;
1868         rc = lustre_process_log(sb, lsi->lsi_svname, &cfg);
1869         if (rc) {
1870                 CERROR("failed to start server %s: %d\n",
1871                        lsi->lsi_svname, rc);
1872                 /* Do NOT call server_deregister_mount() here. This makes it
1873                  * impossible to find mount later in cleanup time and leaves
1874                  * @lsi and othder stuff leaked. -umka */
1875                 GOTO(out_mgc, rc);
1876         }
1877
1878         obd = class_name2obd(lsi->lsi_svname);
1879         if (!obd) {
1880                 CERROR("no server named %s was started\n", lsi->lsi_svname);
1881                 GOTO(out_mgc, rc = -ENXIO);
1882         }
1883
1884         if (IS_OST(lsi) || IS_MDT(lsi)) {
1885                 rc = lustre_start_osp(sb);
1886                 if (rc) {
1887                         CERROR("%s: failed to start OSP: %d\n",
1888                                lsi->lsi_svname, rc);
1889                         GOTO(out_mgc, rc);
1890                 }
1891         }
1892
1893         server_notify_target(sb, obd);
1894
1895         /* calculate recovery timeout, do it after lustre_process_log */
1896         server_calc_timeout(lsi, obd);
1897
1898         /* log has been fully processed */
1899         obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1900
1901         /* log has been fully processed, let clients connect */
1902         dev = obd->obd_lu_dev;
1903         if (dev && dev->ld_ops->ldo_prepare) {
1904                 rc = lu_env_init(&env, dev->ld_type->ldt_ctx_tags);
1905                 if (rc == 0) {
1906                         struct lu_context  session_ctx;
1907
1908                         lu_context_init(&session_ctx, LCT_SESSION);
1909                         session_ctx.lc_thread = NULL;
1910                         lu_context_enter(&session_ctx);
1911                         env.le_ses = &session_ctx;
1912
1913                         dev->ld_ops->ldo_prepare(&env, NULL, dev);
1914
1915                         lu_env_fini(&env);
1916                         lu_context_exit(&session_ctx);
1917                         lu_context_fini(&session_ctx);
1918                 }
1919         }
1920
1921         /* abort recovery only on the complete stack:
1922          * many devices can be involved */
1923         if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1924             (OBP(obd, iocontrol))) {
1925                 obd_iocontrol(OBD_IOC_ABORT_RECOVERY, obd->obd_self_export, 0,
1926                               NULL, NULL);
1927         }
1928
1929 out_mgc:
1930         /* Release the mgc fs for others to use */
1931         if (lsi->lsi_srv_mnt)
1932                 server_mgc_clear_fs(lsi->lsi_mgc);
1933
1934 out_stop_service:
1935         if (rc != 0)
1936                 server_stop_servers(lsi->lsi_flags);
1937
1938         RETURN(rc);
1939 }
1940
1941 /***************** lustre superblock **************/
1942
1943 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1944 {
1945         struct lustre_sb_info *lsi;
1946         ENTRY;
1947
1948         OBD_ALLOC_PTR(lsi);
1949         if (!lsi)
1950                 RETURN(NULL);
1951         OBD_ALLOC_PTR(lsi->lsi_lmd);
1952         if (!lsi->lsi_lmd) {
1953                 OBD_FREE_PTR(lsi);
1954                 RETURN(NULL);
1955         }
1956
1957         lsi->lsi_lmd->lmd_exclude_count = 0;
1958         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
1959         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
1960         s2lsi_nocast(sb) = lsi;
1961         /* we take 1 extra ref for our setup */
1962         cfs_atomic_set(&lsi->lsi_mounts, 1);
1963
1964         /* Default umount style */
1965         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1966
1967         RETURN(lsi);
1968 }
1969
1970 static int lustre_free_lsi(struct super_block *sb)
1971 {
1972         struct lustre_sb_info *lsi = s2lsi(sb);
1973         ENTRY;
1974
1975         LASSERT(lsi != NULL);
1976         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
1977
1978         /* someone didn't call server_put_mount. */
1979         LASSERT(cfs_atomic_read(&lsi->lsi_mounts) == 0);
1980
1981         if (lsi->lsi_lmd != NULL) {
1982                 if (lsi->lsi_lmd->lmd_dev != NULL)
1983                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
1984                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
1985                 if (lsi->lsi_lmd->lmd_profile != NULL)
1986                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
1987                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
1988                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
1989                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
1990                                  strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
1991                 if (lsi->lsi_lmd->lmd_opts != NULL)
1992                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
1993                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
1994                 if (lsi->lsi_lmd->lmd_exclude_count)
1995                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1996                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1997                                  lsi->lsi_lmd->lmd_exclude_count);
1998                 if (lsi->lsi_lmd->lmd_mgs != NULL)
1999                         OBD_FREE(lsi->lsi_lmd->lmd_mgs,
2000                                  strlen(lsi->lsi_lmd->lmd_mgs) + 1);
2001                 if (lsi->lsi_lmd->lmd_osd_type != NULL)
2002                         OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
2003                                  strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
2004                 if (lsi->lsi_lmd->lmd_params != NULL)
2005                         OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
2006
2007                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
2008         }
2009
2010         LASSERT(lsi->lsi_llsbi == NULL);
2011         OBD_FREE(lsi, sizeof(*lsi));
2012         s2lsi_nocast(sb) = NULL;
2013
2014         RETURN(0);
2015 }
2016
2017 /* The lsi has one reference for every server that is using the disk -
2018    e.g. MDT, MGS, and potentially MGC */
2019 static int lustre_put_lsi(struct super_block *sb)
2020 {
2021         struct lustre_sb_info *lsi = s2lsi(sb);
2022         ENTRY;
2023
2024         LASSERT(lsi != NULL);
2025
2026         CDEBUG(D_MOUNT, "put %p %d\n", sb, cfs_atomic_read(&lsi->lsi_mounts));
2027         if (cfs_atomic_dec_and_test(&lsi->lsi_mounts)) {
2028                 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
2029                         obd_disconnect(lsi->lsi_osd_exp);
2030                         /* wait till OSD is gone */
2031                         obd_zombie_barrier();
2032                 }
2033                 lustre_free_lsi(sb);
2034                 RETURN(1);
2035         }
2036         RETURN(0);
2037 }
2038
2039 static int lsi_prepare(struct lustre_sb_info *lsi)
2040 {
2041         __u32 index;
2042         int rc;
2043         ENTRY;
2044
2045         LASSERT(lsi);
2046         LASSERT(lsi->lsi_lmd);
2047
2048         /* The server name is given as a mount line option */
2049         if (lsi->lsi_lmd->lmd_profile == NULL) {
2050                 LCONSOLE_ERROR("Can't determine server name\n");
2051                 RETURN(-EINVAL);
2052         }
2053
2054         if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname))
2055                 RETURN(-ENAMETOOLONG);
2056
2057         strcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile);
2058
2059         /* Determine osd type */
2060         if (lsi->lsi_lmd->lmd_osd_type != NULL) {
2061                 if (strlen(lsi->lsi_lmd->lmd_osd_type) >=
2062                            sizeof(lsi->lsi_osd_type))
2063                         RETURN(-ENAMETOOLONG);
2064
2065                 strcpy(lsi->lsi_osd_type, lsi->lsi_lmd->lmd_osd_type);
2066         } else {
2067                 strcpy(lsi->lsi_osd_type, LUSTRE_OSD_LDISKFS_NAME);
2068         }
2069
2070         /* XXX: a temp. solution for components using fsfilt
2071          *      to be removed in one of the subsequent patches */
2072         if (!strcmp(lsi->lsi_lmd->lmd_osd_type, "osd-ldiskfs")) {
2073                 strcpy(lsi->lsi_fstype, "ldiskfs");
2074         } else {
2075                 strcpy(lsi->lsi_fstype, lsi->lsi_lmd->lmd_osd_type);
2076         }
2077
2078         /* Determine server type */
2079         rc = server_name2index(lsi->lsi_svname, &index, NULL);
2080         if (rc < 0) {
2081                 if (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) {
2082                         /* Assume we're a bare MGS */
2083                         rc = 0;
2084                         lsi->lsi_lmd->lmd_flags |= LMD_FLG_NOSVC;
2085                 } else {
2086                         LCONSOLE_ERROR("Can't determine server type of '%s'\n",
2087                                        lsi->lsi_svname);
2088                         RETURN(rc);
2089                 }
2090         }
2091         lsi->lsi_flags |= rc;
2092
2093         /* Add mount line flags that used to be in ldd:
2094          * writeconf, mgs, anything else?
2095          */
2096         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_WRITECONF) ?
2097                 LDD_F_WRITECONF : 0;
2098         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_VIRGIN) ?
2099                 LDD_F_VIRGIN : 0;
2100         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) ?
2101                 LDD_F_SV_TYPE_MGS : 0;
2102         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) ?
2103                 LDD_F_NO_PRIMNODE : 0;
2104
2105         RETURN(0);
2106 }
2107
2108 /*************** server mount ******************/
2109
2110 /** Start the shutdown of servers at umount.
2111  */
2112 static void server_put_super(struct super_block *sb)
2113 {
2114         struct lustre_sb_info *lsi = s2lsi(sb);
2115         struct obd_device     *obd;
2116         char *tmpname, *extraname = NULL;
2117         int tmpname_sz;
2118         int lsiflags = lsi->lsi_flags;
2119         ENTRY;
2120
2121         LASSERT(IS_SERVER(lsi));
2122
2123         tmpname_sz = strlen(lsi->lsi_svname) + 1;
2124         OBD_ALLOC(tmpname, tmpname_sz);
2125         memcpy(tmpname, lsi->lsi_svname, tmpname_sz);
2126         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
2127         if (IS_MDT(lsi) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
2128                 snprintf(tmpname, tmpname_sz, "MGS");
2129
2130         /* disconnect the osp-on-ost first to drain off the inflight request */
2131         if (IS_OST(lsi) || IS_MDT(lsi)) {
2132                 int     rc;
2133
2134                 rc = lustre_disconnect_osp(sb);
2135                 if (rc && rc != ETIMEDOUT)
2136                         CERROR("%s: failed to disconnect osp-on-ost (rc=%d)!\n",
2137                                tmpname, rc);
2138         }
2139
2140         /* Stop the target */
2141         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
2142             (IS_MDT(lsi) || IS_OST(lsi))) {
2143                 struct lustre_profile *lprof = NULL;
2144
2145                 /* tell the mgc to drop the config log */
2146                 lustre_end_log(sb, lsi->lsi_svname, NULL);
2147
2148                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
2149                    If there are any setup/cleanup errors, save the lov
2150                    name for safety cleanup later. */
2151                 lprof = class_get_profile(lsi->lsi_svname);
2152                 if (lprof && lprof->lp_dt) {
2153                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
2154                         strcpy(extraname, lprof->lp_dt);
2155                 }
2156
2157                 obd = class_name2obd(lsi->lsi_svname);
2158                 if (obd) {
2159                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
2160                         if (lsiflags & LSI_UMOUNT_FAILOVER)
2161                                 obd->obd_fail = 1;
2162                         /* We can't seem to give an error return code
2163                          * to .put_super, so we better make sure we clean up! */
2164                         obd->obd_force = 1;
2165                         class_manual_cleanup(obd);
2166                 } else {
2167                         CERROR("no obd %s\n", lsi->lsi_svname);
2168                         server_deregister_mount(lsi->lsi_svname);
2169                 }
2170         }
2171
2172         /* If they wanted the mgs to stop separately from the mdt, they
2173            should have put it on a different device. */
2174         if (IS_MGS(lsi)) {
2175                 /* if MDS start with --nomgs, don't stop MGS then */
2176                 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
2177                         server_stop_mgs(sb);
2178         }
2179
2180         if (IS_OST(lsi) || IS_MDT(lsi)) {
2181                 if (lustre_stop_osp(sb) < 0)
2182                         CERROR("%s: Fail to stop osp-on-ost!\n", tmpname);
2183         }
2184
2185         /* Clean the mgc and sb */
2186         lustre_common_put_super(sb);
2187
2188         /* wait till all in-progress cleanups are done
2189          * specifically we're interested in ofd cleanup
2190          * as it pins OSS */
2191         obd_zombie_barrier();
2192
2193         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
2194            until the target is really gone so that our type refcount check
2195            is right. */
2196         server_stop_servers(lsiflags);
2197
2198         /* In case of startup or cleanup err, stop related obds */
2199         if (extraname) {
2200                 obd = class_name2obd(extraname);
2201                 if (obd) {
2202                         CWARN("Cleaning orphaned obd %s\n", extraname);
2203                         obd->obd_force = 1;
2204                         class_manual_cleanup(obd);
2205                 }
2206                 OBD_FREE(extraname, strlen(extraname) + 1);
2207         }
2208
2209         LCONSOLE_WARN("server umount %s complete\n", tmpname);
2210         OBD_FREE(tmpname, tmpname_sz);
2211         EXIT;
2212 }
2213
2214 /** Called only for 'umount -f'
2215  */
2216 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
2217 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
2218 {
2219         struct super_block *sb = vfsmnt->mnt_sb;
2220 #else
2221 static void server_umount_begin(struct super_block *sb)
2222 {
2223 #endif
2224         struct lustre_sb_info *lsi = s2lsi(sb);
2225         ENTRY;
2226
2227 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
2228         if (!(flags & MNT_FORCE)) {
2229                 EXIT;
2230                 return;
2231         }
2232 #endif
2233
2234         CDEBUG(D_MOUNT, "umount -f\n");
2235         /* umount = failover
2236            umount -f = force
2237            no third way to do non-force, non-failover */
2238         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
2239         EXIT;
2240 }
2241
2242 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
2243 {
2244         struct super_block *sb = dentry->d_sb;
2245         struct lustre_sb_info *lsi = s2lsi(sb);
2246         struct obd_statfs statfs;
2247         int rc;
2248         ENTRY;
2249
2250         if (lsi->lsi_dt_dev) {
2251                 rc = dt_statfs(NULL, lsi->lsi_dt_dev, &statfs);
2252                 if (rc == 0) {
2253                         statfs_unpack(buf, &statfs);
2254                         buf->f_type = sb->s_magic;
2255                         RETURN(0);
2256                 }
2257         }
2258
2259         /* just return 0 */
2260         buf->f_type = sb->s_magic;
2261         buf->f_bsize = sb->s_blocksize;
2262         buf->f_blocks = 1;
2263         buf->f_bfree = 0;
2264         buf->f_bavail = 0;
2265         buf->f_files = 1;
2266         buf->f_ffree = 0;
2267         buf->f_namelen = NAME_MAX;
2268         RETURN(0);
2269 }
2270
2271 /** The operations we support directly on the superblock:
2272  * mount, umount, and df.
2273  */
2274 static struct super_operations server_ops =
2275 {
2276         .put_super      = server_put_super,
2277         .umount_begin   = server_umount_begin, /* umount -f */
2278         .statfs         = server_statfs,
2279 };
2280
2281 #define log2(n) ffz(~(n))
2282 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
2283
2284 static int server_fill_super_common(struct super_block *sb)
2285 {
2286         struct inode *root = 0;
2287         ENTRY;
2288
2289         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
2290
2291         sb->s_blocksize = 4096;
2292         sb->s_blocksize_bits = log2(sb->s_blocksize);
2293         sb->s_magic = LUSTRE_SUPER_MAGIC;
2294         sb->s_maxbytes = 0; /* we don't allow file IO on server mountpoints */
2295         sb->s_flags |= MS_RDONLY;
2296         sb->s_op = &server_ops;
2297
2298         root = new_inode(sb);
2299         if (!root) {
2300                 CERROR("Can't make root inode\n");
2301                 RETURN(-EIO);
2302         }
2303
2304         /* returns -EIO for every operation */
2305         /* make_bad_inode(root); -- badness - can't umount */
2306         /* apparently we need to be a directory for the mount to finish */
2307         root->i_mode = S_IFDIR;
2308
2309         sb->s_root = d_make_root(root);
2310         if (!sb->s_root) {
2311                 CERROR("%s: can't make root dentry\n", sb->s_id);
2312                 RETURN(-EIO);
2313         }
2314
2315         RETURN(0);
2316 }
2317
2318 static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags)
2319 {
2320         struct lustre_mount_data *lmd = lsi->lsi_lmd;
2321         struct obd_device        *obd;
2322         struct dt_device_param    p;
2323         char                      flagstr[16];
2324         int                       rc;
2325         ENTRY;
2326
2327         CDEBUG(D_MOUNT,
2328                "Attempting to start %s, type=%s, lsifl=%x, mountfl=%lx\n",
2329                lsi->lsi_svname, lsi->lsi_osd_type, lsi->lsi_flags, mflags);
2330
2331         sprintf(lsi->lsi_osd_obdname, "%s-osd", lsi->lsi_svname);
2332         strcpy(lsi->lsi_osd_uuid, lsi->lsi_osd_obdname);
2333         strcat(lsi->lsi_osd_uuid, "_UUID");
2334         sprintf(flagstr, "%lu:%lu", mflags, (unsigned long) lmd->lmd_flags);
2335
2336         obd = class_name2obd(lsi->lsi_osd_obdname);
2337         if (obd == NULL) {
2338                 rc = lustre_start_simple(lsi->lsi_osd_obdname,
2339                                 lsi->lsi_osd_type,
2340                                 lsi->lsi_osd_uuid, lmd->lmd_dev,
2341                                 flagstr, lsi->lsi_lmd->lmd_opts,
2342                                 lsi->lsi_svname);
2343                 if (rc)
2344                         GOTO(out, rc);
2345                 obd = class_name2obd(lsi->lsi_osd_obdname);
2346                 LASSERT(obd);
2347         }
2348
2349         rc = obd_connect(NULL, &lsi->lsi_osd_exp, obd, &obd->obd_uuid, NULL, NULL);
2350         if (rc) {
2351                 obd->obd_force = 1;
2352                 class_manual_cleanup(obd);
2353                 lsi->lsi_dt_dev = NULL;
2354         }
2355
2356         /* XXX: to keep support old components relying on lsi_srv_mnt
2357          *      we get this info from OSD just started */
2358         LASSERT(obd->obd_lu_dev);
2359         lsi->lsi_dt_dev = lu2dt_dev(obd->obd_lu_dev);
2360         LASSERT(lsi->lsi_dt_dev);
2361
2362         dt_conf_get(NULL, lsi->lsi_dt_dev, &p);
2363
2364         lsi->lsi_srv_mnt = p.ddp_mnt;
2365
2366 out:
2367         RETURN(rc);
2368 }
2369
2370 /** Fill in the superblock info for a Lustre server.
2371  * Mount the device with the correct options.
2372  * Read the on-disk config file.
2373  * Start the services.
2374  */
2375 static int server_fill_super(struct super_block *sb)
2376 {
2377         struct lustre_sb_info *lsi = s2lsi(sb);
2378         int rc;
2379         ENTRY;
2380
2381         rc = lsi_prepare(lsi);
2382         if (rc)
2383                 RETURN(rc);
2384
2385         /* Start low level OSD */
2386         rc = osd_start(lsi, sb->s_flags);
2387         if (rc) {
2388                 CERROR("Unable to start osd on %s: %d\n",
2389                        lsi->lsi_lmd->lmd_dev, rc);
2390                 lustre_put_lsi(sb);
2391                 RETURN(rc);
2392         }
2393
2394         CDEBUG(D_MOUNT, "Found service %s on device %s\n",
2395                lsi->lsi_svname, lsi->lsi_lmd->lmd_dev);
2396
2397         if (class_name2obd(lsi->lsi_svname)) {
2398                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
2399                                    "running. Double-mount may have compromised"
2400                                    " the disk journal.\n",
2401                                    lsi->lsi_svname);
2402                 lustre_put_lsi(sb);
2403                 RETURN(-EALREADY);
2404         }
2405
2406         /* Start MGS before MGC */
2407         if (IS_MGS(lsi) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
2408                 rc = server_start_mgs(sb);
2409                 if (rc)
2410                         GOTO(out_mnt, rc);
2411         }
2412
2413         /* Start MGC before servers */
2414         rc = lustre_start_mgc(sb);
2415         if (rc)
2416                 GOTO(out_mnt, rc);
2417
2418         /* Set up all obd devices for service */
2419         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
2420                         (IS_OST(lsi) || IS_MDT(lsi))) {
2421                 rc = server_start_targets(sb, lsi->lsi_srv_mnt);
2422                 if (rc < 0) {
2423                         CERROR("Unable to start targets: %d\n", rc);
2424                         GOTO(out_mnt, rc);
2425                 }
2426         /* FIXME overmount client here,
2427            or can we just start a client log and client_fill_super on this sb?
2428            We need to make sure server_put_super gets called too - ll_put_super
2429            calls lustre_common_put_super; check there for LSI_SERVER flag,
2430            call s_p_s if so.
2431            Probably should start client from new thread so we can return.
2432            Client will not finish until all servers are connected.
2433            Note - MGS-only server does NOT get a client, since there is no
2434            lustre fs associated - the MGS is for all lustre fs's */
2435         }
2436
2437         rc = server_fill_super_common(sb);
2438         if (rc)
2439                 GOTO(out_mnt, rc);
2440
2441         RETURN(0);
2442 out_mnt:
2443         /* We jump here in case of failure while starting targets or MGS.
2444          * In this case we can't just put @mnt and have to do real cleanup
2445          * with stoping targets, etc. */
2446         server_put_super(sb);
2447         return rc;
2448 }
2449
2450 /*
2451  * Calculate timeout value for a target.
2452  */
2453 void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
2454 {
2455         struct lustre_mount_data *lmd;
2456         int soft = 0;
2457         int hard = 0;
2458         int factor = 0;
2459         bool has_ir = !!(lsi->lsi_flags & LDD_F_IR_CAPABLE);
2460         int min = OBD_RECOVERY_TIME_MIN;
2461
2462         LASSERT(IS_SERVER(lsi));
2463
2464         lmd = lsi->lsi_lmd;
2465         if (lmd) {
2466                 soft   = lmd->lmd_recovery_time_soft;
2467                 hard   = lmd->lmd_recovery_time_hard;
2468                 has_ir = has_ir && !(lmd->lmd_flags & LMD_FLG_NOIR);
2469                 obd->obd_no_ir = !has_ir;
2470         }
2471
2472         if (soft == 0)
2473                 soft = OBD_RECOVERY_TIME_SOFT;
2474         if (hard == 0)
2475                 hard = OBD_RECOVERY_TIME_HARD;
2476
2477         /* target may have ir_factor configured. */
2478         factor = OBD_IR_FACTOR_DEFAULT;
2479         if (obd->obd_recovery_ir_factor)
2480                 factor = obd->obd_recovery_ir_factor;
2481
2482         if (has_ir) {
2483                 int new_soft = soft;
2484                 int new_hard = hard;
2485
2486                 /* adjust timeout value by imperative recovery */
2487
2488                 new_soft = (soft * factor) / OBD_IR_FACTOR_MAX;
2489                 new_hard = (hard * factor) / OBD_IR_FACTOR_MAX;
2490
2491                 /* make sure the timeout is not too short */
2492                 new_soft = max(min, new_soft);
2493                 new_hard = max(new_soft, new_hard);
2494
2495                 LCONSOLE_INFO("%s: Imperative Recovery enabled, recovery "
2496                               "window shrunk from %d-%d down to %d-%d\n",
2497                               obd->obd_name, soft, hard, new_soft, new_hard);
2498
2499                 soft = new_soft;
2500                 hard = new_hard;
2501         }
2502
2503         /* we're done */
2504         obd->obd_recovery_timeout   = max(obd->obd_recovery_timeout, soft);
2505         obd->obd_recovery_time_hard = hard;
2506         obd->obd_recovery_ir_factor = factor;
2507 }
2508 EXPORT_SYMBOL(server_calc_timeout);
2509
2510 /*************** mount common betweeen server and client ***************/
2511
2512 /* Common umount */
2513 int lustre_common_put_super(struct super_block *sb)
2514 {
2515         int rc;
2516         ENTRY;
2517
2518         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
2519
2520         /* Drop a ref to the MGC */
2521         rc = lustre_stop_mgc(sb);
2522         if (rc && (rc != -ENOENT)) {
2523                 if (rc != -EBUSY) {
2524                         CERROR("Can't stop MGC: %d\n", rc);
2525                         RETURN(rc);
2526                 }
2527                 /* BUSY just means that there's some other obd that
2528                    needs the mgc.  Let him clean it up. */
2529                 CDEBUG(D_MOUNT, "MGC still in use\n");
2530         }
2531         /* Drop a ref to the mounted disk */
2532         lustre_put_lsi(sb);
2533         lu_types_stop();
2534         RETURN(rc);
2535 }
2536 EXPORT_SYMBOL(lustre_common_put_super);
2537
2538 static void lmd_print(struct lustre_mount_data *lmd)
2539 {
2540         int i;
2541
2542         PRINT_CMD(PRINT_MASK, "  mount data:\n");
2543         if (lmd_is_client(lmd))
2544                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
2545         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
2546         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
2547
2548         if (lmd->lmd_opts)
2549                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
2550
2551         if (lmd->lmd_recovery_time_soft)
2552                 PRINT_CMD(PRINT_MASK, "recovery time soft: %d\n",
2553                           lmd->lmd_recovery_time_soft);
2554
2555         if (lmd->lmd_recovery_time_hard)
2556                 PRINT_CMD(PRINT_MASK, "recovery time hard: %d\n",
2557                           lmd->lmd_recovery_time_hard);
2558
2559         for (i = 0; i < lmd->lmd_exclude_count; i++) {
2560                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
2561                           lmd->lmd_exclude[i]);
2562         }
2563 }
2564
2565 /* Is this server on the exclusion list */
2566 int lustre_check_exclusion(struct super_block *sb, char *svname)
2567 {
2568         struct lustre_sb_info *lsi = s2lsi(sb);
2569         struct lustre_mount_data *lmd = lsi->lsi_lmd;
2570         __u32 index;
2571         int i, rc;
2572         ENTRY;
2573
2574         rc = server_name2index(svname, &index, NULL);
2575         if (rc != LDD_F_SV_TYPE_OST)
2576                 /* Only exclude OSTs */
2577                 RETURN(0);
2578
2579         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
2580                index, lmd->lmd_exclude_count, lmd->lmd_dev);
2581
2582         for(i = 0; i < lmd->lmd_exclude_count; i++) {
2583                 if (index == lmd->lmd_exclude[i]) {
2584                         CWARN("Excluding %s (on exclusion list)\n", svname);
2585                         RETURN(1);
2586                 }
2587         }
2588         RETURN(0);
2589 }
2590
2591 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
2592 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
2593 {
2594         char *s1 = ptr, *s2;
2595         __u32 index, *exclude_list;
2596         int rc = 0, devmax;
2597         ENTRY;
2598
2599         /* The shortest an ost name can be is 8 chars: -OST0000.
2600            We don't actually know the fsname at this time, so in fact
2601            a user could specify any fsname. */
2602         devmax = strlen(ptr) / 8 + 1;
2603
2604         /* temp storage until we figure out how many we have */
2605         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
2606         if (!exclude_list)
2607                 RETURN(-ENOMEM);
2608
2609         /* we enter this fn pointing at the '=' */
2610         while (*s1 && *s1 != ' ' && *s1 != ',') {
2611                 s1++;
2612                 rc = server_name2index(s1, &index, &s2);
2613                 if (rc < 0) {
2614                         CERROR("Can't parse server name '%s'\n", s1);
2615                         break;
2616                 }
2617                 if (rc == LDD_F_SV_TYPE_OST)
2618                         exclude_list[lmd->lmd_exclude_count++] = index;
2619                 else
2620                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
2621                 s1 = s2;
2622                 /* now we are pointing at ':' (next exclude)
2623                    or ',' (end of excludes) */
2624                 if (lmd->lmd_exclude_count >= devmax)
2625                         break;
2626         }
2627         if (rc >= 0) /* non-err */
2628                 rc = 0;
2629
2630         if (lmd->lmd_exclude_count) {
2631                 /* permanent, freed in lustre_free_lsi */
2632                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
2633                           lmd->lmd_exclude_count);
2634                 if (lmd->lmd_exclude) {
2635                         memcpy(lmd->lmd_exclude, exclude_list,
2636                                sizeof(index) * lmd->lmd_exclude_count);
2637                 } else {
2638                         rc = -ENOMEM;
2639                         lmd->lmd_exclude_count = 0;
2640                 }
2641         }
2642         OBD_FREE(exclude_list, sizeof(index) * devmax);
2643         RETURN(rc);
2644 }
2645
2646 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
2647 {
2648         char   *tail;
2649         int     length;
2650
2651         if (lmd->lmd_mgssec != NULL) {
2652                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
2653                 lmd->lmd_mgssec = NULL;
2654         }
2655
2656         tail = strchr(ptr, ',');
2657         if (tail == NULL)
2658                 length = strlen(ptr);
2659         else
2660                 length = tail - ptr;
2661
2662         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
2663         if (lmd->lmd_mgssec == NULL)
2664                 return -ENOMEM;
2665
2666         memcpy(lmd->lmd_mgssec, ptr, length);
2667         lmd->lmd_mgssec[length] = '\0';
2668         return 0;
2669 }
2670
2671 static int lmd_parse_string(char **handle, char *ptr)
2672 {
2673         char   *tail;
2674         int     length;
2675
2676         if ((handle == NULL) || (ptr == NULL))
2677                 return -EINVAL;
2678
2679         if (*handle != NULL) {
2680                 OBD_FREE(*handle, strlen(*handle) + 1);
2681                 *handle = NULL;
2682         }
2683
2684         tail = strchr(ptr, ',');
2685         if (tail == NULL)
2686                 length = strlen(ptr);
2687         else
2688                 length = tail - ptr;
2689
2690         OBD_ALLOC(*handle, length + 1);
2691         if (*handle == NULL)
2692                 return -ENOMEM;
2693
2694         memcpy(*handle, ptr, length);
2695         (*handle)[length] = '\0';
2696
2697         return 0;
2698 }
2699
2700 /* Collect multiple values for mgsnid specifiers */
2701 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
2702 {
2703         lnet_nid_t nid;
2704         char *tail = *ptr;
2705         char *mgsnid;
2706         int   length;
2707         int   oldlen = 0;
2708
2709         /* Find end of nidlist */
2710         while (class_parse_nid_quiet(tail, &nid, &tail) == 0) {}
2711         length = tail - *ptr;
2712         if (length == 0) {
2713                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
2714                 return -EINVAL;
2715         }
2716
2717         if (lmd->lmd_mgs != NULL)
2718                 oldlen = strlen(lmd->lmd_mgs) + 1;
2719
2720         OBD_ALLOC(mgsnid, oldlen + length + 1);
2721         if (mgsnid == NULL)
2722                 return -ENOMEM;
2723
2724         if (lmd->lmd_mgs != NULL) {
2725                 /* Multiple mgsnid= are taken to mean failover locations */
2726                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
2727                 mgsnid[oldlen - 1] = ':';
2728                 OBD_FREE(lmd->lmd_mgs, oldlen);
2729         }
2730         memcpy(mgsnid + oldlen, *ptr, length);
2731         mgsnid[oldlen + length] = '\0';
2732         lmd->lmd_mgs = mgsnid;
2733         *ptr = tail;
2734
2735         return 0;
2736 }
2737
2738 /** Parse mount line options
2739  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
2740  * dev is passed as device=uml1:/lustre by mount.lustre
2741  */
2742 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
2743 {
2744         char *s1, *s2, *devname = NULL;
2745         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
2746         int rc = 0;
2747         ENTRY;
2748
2749         LASSERT(lmd);
2750         if (!options) {
2751                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
2752                                    "/sbin/mount.lustre is installed.\n");
2753                 RETURN(-EINVAL);
2754         }
2755
2756         /* Options should be a string - try to detect old lmd data */
2757         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
2758                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
2759                                    "/sbin/mount.lustre.  Please install "
2760                                    "version %s\n", LUSTRE_VERSION_STRING);
2761                 RETURN(-EINVAL);
2762         }
2763         lmd->lmd_magic = LMD_MAGIC;
2764
2765         OBD_ALLOC(lmd->lmd_params, 4096);
2766         if (lmd->lmd_params == NULL)
2767                 RETURN(-ENOMEM);
2768         lmd->lmd_params[0] = '\0';
2769
2770         /* Set default flags here */
2771
2772         s1 = options;
2773         while (*s1) {
2774                 int clear = 0;
2775                 int time_min = OBD_RECOVERY_TIME_MIN;
2776
2777                 /* Skip whitespace and extra commas */
2778                 while (*s1 == ' ' || *s1 == ',')
2779                         s1++;
2780
2781                 /* Client options are parsed in ll_options: eg. flock,
2782                    user_xattr, acl */
2783
2784                 /* Parse non-ldiskfs options here. Rather than modifying
2785                    ldiskfs, we just zero these out here */
2786                 if (strncmp(s1, "abort_recov", 11) == 0) {
2787                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
2788                         clear++;
2789                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
2790                         lmd->lmd_recovery_time_soft = max_t(int,
2791                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2792                         clear++;
2793                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
2794                         lmd->lmd_recovery_time_hard = max_t(int,
2795                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2796                         clear++;
2797                 } else if (strncmp(s1, "noir", 4) == 0) {
2798                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
2799                         clear++;
2800                 } else if (strncmp(s1, "nosvc", 5) == 0) {
2801                         lmd->lmd_flags |= LMD_FLG_NOSVC;
2802                         clear++;
2803                 } else if (strncmp(s1, "nomgs", 5) == 0) {
2804                         lmd->lmd_flags |= LMD_FLG_NOMGS;
2805                         clear++;
2806                 } else if (strncmp(s1, "noscrub", 7) == 0) {
2807                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
2808                         clear++;
2809                 } else if (strncmp(s1, PARAM_MGSNODE,
2810                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
2811                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
2812                         /* Assume the next mount opt is the first
2813                            invalid nid we get to. */
2814                         rc = lmd_parse_mgs(lmd, &s2);
2815                         if (rc)
2816                                 goto invalid;
2817                         clear++;
2818                 } else if (strncmp(s1, "writeconf", 9) == 0) {
2819                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
2820                         clear++;
2821                 } else if (strncmp(s1, "virgin", 6) == 0) {
2822                         lmd->lmd_flags |= LMD_FLG_VIRGIN;
2823                         clear++;
2824                 } else if (strncmp(s1, "noprimnode", 10) == 0) {
2825                         lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
2826                         clear++;
2827                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
2828                         rc = lmd_parse_mgssec(lmd, s1 + 7);
2829                         if (rc)
2830                                 goto invalid;
2831                         clear++;
2832                 /* ost exclusion list */
2833                 } else if (strncmp(s1, "exclude=", 8) == 0) {
2834                         rc = lmd_make_exclusion(lmd, s1 + 7);
2835                         if (rc)
2836                                 goto invalid;
2837                         clear++;
2838                 } else if (strncmp(s1, "mgs", 3) == 0) {
2839                         /* We are an MGS */
2840                         lmd->lmd_flags |= LMD_FLG_MGS;
2841                         clear++;
2842                 } else if (strncmp(s1, "svname=", 7) == 0) {
2843                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
2844                         if (rc)
2845                                 goto invalid;
2846                         clear++;
2847                 } else if (strncmp(s1, "param=", 6) == 0) {
2848                         int length;
2849                         char *tail = strchr(s1 + 6, ',');
2850                         if (tail == NULL)
2851                                 length = strlen(s1);
2852                         else
2853                                 length = tail - s1;
2854                         length -= 6;
2855                         strncat(lmd->lmd_params, s1 + 6, length);
2856                         strcat(lmd->lmd_params, " ");
2857                         clear++;
2858                 } else if (strncmp(s1, "osd=", 4) == 0) {
2859                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
2860                         if (rc)
2861                                 goto invalid;
2862                         clear++;
2863                 }
2864                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
2865                    end of the options. */
2866                 else if (strncmp(s1, "device=", 7) == 0) {
2867                         devname = s1 + 7;
2868                         /* terminate options right before device.  device
2869                            must be the last one. */
2870                         *s1 = '\0';
2871                         break;
2872                 }
2873
2874                 /* Find next opt */
2875                 s2 = strchr(s1, ',');
2876                 if (s2 == NULL) {
2877                         if (clear)
2878                                 *s1 = '\0';
2879                         break;
2880                 }
2881                 s2++;
2882                 if (clear)
2883                         memmove(s1, s2, strlen(s2) + 1);
2884                 else
2885                         s1 = s2;
2886         }
2887
2888         if (!devname) {
2889                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
2890                                    "(need mount option 'device=...')\n");
2891                 goto invalid;
2892         }
2893
2894         s1 = strstr(devname, ":/");
2895         if (s1) {
2896                 ++s1;
2897                 lmd->lmd_flags |= LMD_FLG_CLIENT;
2898                 /* Remove leading /s from fsname */
2899                 while (*++s1 == '/') ;
2900                 /* Freed in lustre_free_lsi */
2901                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
2902                 if (!lmd->lmd_profile)
2903                         RETURN(-ENOMEM);
2904                 sprintf(lmd->lmd_profile, "%s-client", s1);
2905         }
2906
2907         /* Freed in lustre_free_lsi */
2908         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
2909         if (!lmd->lmd_dev)
2910                 RETURN(-ENOMEM);
2911         strcpy(lmd->lmd_dev, devname);
2912
2913         /* Save mount options */
2914         s1 = options + strlen(options) - 1;
2915         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
2916                 *s1-- = 0;
2917         if (*options != 0) {
2918                 /* Freed in lustre_free_lsi */
2919                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
2920                 if (!lmd->lmd_opts)
2921                         RETURN(-ENOMEM);
2922                 strcpy(lmd->lmd_opts, options);
2923         }
2924
2925         lmd_print(lmd);
2926         lmd->lmd_magic = LMD_MAGIC;
2927
2928         RETURN(rc);
2929
2930 invalid:
2931         CERROR("Bad mount options %s\n", options);
2932         RETURN(-EINVAL);
2933 }
2934
2935 struct lustre_mount_data2 {
2936         void *lmd2_data;
2937         struct vfsmount *lmd2_mnt;
2938 };
2939
2940 /** This is the entry point for the mount call into Lustre.
2941  * This is called when a server or client is mounted,
2942  * and this is where we start setting things up.
2943  * @param data Mount options (e.g. -o flock,abort_recov)
2944  */
2945 int lustre_fill_super(struct super_block *sb, void *data, int silent)
2946 {
2947         struct lustre_mount_data *lmd;
2948         struct lustre_mount_data2 *lmd2 = data;
2949         struct lustre_sb_info *lsi;
2950         int rc;
2951         ENTRY;
2952
2953         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
2954
2955         lsi = lustre_init_lsi(sb);
2956         if (!lsi)
2957                 RETURN(-ENOMEM);
2958         lmd = lsi->lsi_lmd;
2959
2960         /*
2961          * Disable lockdep during mount, because mount locking patterns are
2962          * `special'.
2963          */
2964         lockdep_off();
2965
2966         /*
2967          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
2968          */
2969         obd_zombie_barrier();
2970
2971         /* Figure out the lmd from the mount options */
2972         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
2973                 lustre_put_lsi(sb);
2974                 GOTO(out, rc = -EINVAL);
2975         }
2976
2977         if (lmd_is_client(lmd)) {
2978                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
2979                 if (!client_fill_super) {
2980                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
2981                                            "client mount! Is the 'lustre' "
2982                                            "module loaded?\n");
2983                         lustre_put_lsi(sb);
2984                         rc = -ENODEV;
2985                 } else {
2986                         rc = lustre_start_mgc(sb);
2987                         if (rc) {
2988                                 lustre_put_lsi(sb);
2989                                 GOTO(out, rc);
2990                         }
2991                         /* Connect and start */
2992                         /* (should always be ll_fill_super) */
2993                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
2994                         /* c_f_s will call lustre_common_put_super on failure */
2995                 }
2996         } else {
2997                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
2998                 rc = server_fill_super(sb);
2999                 /* s_f_s calls lustre_start_mgc after the mount because we need
3000                    the MGS nids which are stored on disk.  Plus, we may
3001                    need to start the MGS first. */
3002                 /* s_f_s will call server_put_super on failure */
3003         }
3004
3005         /* If error happens in fill_super() call, @lsi will be killed there.
3006          * This is why we do not put it here. */
3007         GOTO(out, rc);
3008 out:
3009         if (rc) {
3010                 CERROR("Unable to mount %s (%d)\n",
3011                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
3012         } else {
3013                 CDEBUG(D_SUPER, "Mount %s complete\n",
3014                        lmd->lmd_dev);
3015         }
3016         lockdep_on();
3017         return rc;
3018 }
3019
3020
3021 /* We can't call ll_fill_super by name because it lives in a module that
3022    must be loaded after this one. */
3023 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
3024                                                   struct vfsmount *mnt))
3025 {
3026         client_fill_super = cfs;
3027 }
3028 EXPORT_SYMBOL(lustre_register_client_fill_super);
3029
3030 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
3031 {
3032         kill_super_cb = cfs;
3033 }
3034 EXPORT_SYMBOL(lustre_register_kill_super_cb);
3035
3036 /***************** FS registration ******************/
3037 #ifdef HAVE_FSTYPE_MOUNT
3038 struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
3039                                 const char *devname, void *data)
3040 {
3041         struct lustre_mount_data2 lmd2 = { data, NULL };
3042
3043         return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
3044 }
3045 #else
3046 int lustre_get_sb(struct file_system_type *fs_type, int flags,
3047                   const char *devname, void * data, struct vfsmount *mnt)
3048 {
3049         struct lustre_mount_data2 lmd2 = { data, mnt };
3050
3051         return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
3052 }
3053 #endif
3054
3055 void lustre_kill_super(struct super_block *sb)
3056 {
3057         struct lustre_sb_info *lsi = s2lsi(sb);
3058
3059         if (kill_super_cb && lsi && !IS_SERVER(lsi))
3060                 (*kill_super_cb)(sb);
3061
3062         kill_anon_super(sb);
3063 }
3064
3065 /** Register the "lustre" fs type
3066  */
3067 struct file_system_type lustre_fs_type = {
3068         .owner        = THIS_MODULE,
3069         .name         = "lustre",
3070 #ifdef HAVE_FSTYPE_MOUNT
3071         .mount        = lustre_mount,
3072 #else
3073         .get_sb       = lustre_get_sb,
3074 #endif
3075         .kill_sb      = lustre_kill_super,
3076         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
3077                         FS_HAS_FIEMAP | FS_RENAME_DOES_D_MOVE,
3078 };
3079
3080 int lustre_register_fs(void)
3081 {
3082         return register_filesystem(&lustre_fs_type);
3083 }
3084
3085 int lustre_unregister_fs(void)
3086 {
3087         return unregister_filesystem(&lustre_fs_type);
3088 }
3089
3090 EXPORT_SYMBOL(server_mti_print);