lustre/obdclass/obd_mount.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2012, Whamcloud, Inc.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/obdclass/obd_mount.c
  37  *
  38  * Client/server mount routines
  39  *
  40  * Author: Nathan Rutman <nathan@clusterfs.com>
  41  */
  42
  43
  44 #define DEBUG_SUBSYSTEM S_CLASS
  45 #define D_MOUNT D_SUPER|D_CONFIG /*|D_WARNING */
  46 #define PRINT_CMD CDEBUG
  47 #define PRINT_MASK D_SUPER|D_CONFIG
  48
  49 #include <obd.h>
  50 #include <lvfs.h>
  51 #include <lustre_fsfilt.h>
  52 #include <obd_class.h>
  53 #include <lustre/lustre_user.h>
  54 #include <linux/version.h>
  55 #include <lustre_log.h>
  56 #include <lustre_disk.h>
  57 #include <lustre_param.h>
  58 #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 CFS_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         cfs_mutex_lock(&lustre_mount_info_lock);
 109
 110         if (server_find_mount(name)) {
 111                 cfs_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         cfs_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         cfs_mutex_lock(&lustre_mount_info_lock);
 136         lmi = server_find_mount(name);
 137         if (!lmi) {
 138                 cfs_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         cfs_mutex_unlock(&lustre_mount_info_lock);
 149
 150         RETURN(0);
 151 }
 152
 153 /* obd's look up a registered mount using their obdname. This is just
 154    for initial obd setup to find the mount struct.  It should not be
 155    called every time you want to mntget. */
 156 struct lustre_mount_info *server_get_mount(const char *name)
 157 {
 158         struct lustre_mount_info *lmi;
 159         struct lustre_sb_info *lsi;
 160         ENTRY;
 161
 162         cfs_mutex_lock(&lustre_mount_info_lock);
 163         lmi = server_find_mount(name);
 164         cfs_mutex_unlock(&lustre_mount_info_lock);
 165         if (!lmi) {
 166                 CERROR("Can't find mount for %s\n", name);
 167                 RETURN(NULL);
 168         }
 169         lsi = s2lsi(lmi->lmi_sb);
 170
 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         cfs_mutex_lock(&lustre_mount_info_lock);
 191         lmi = server_find_mount(name);
 192         cfs_mutex_unlock(&lustre_mount_info_lock);
 193         if (!lmi)
 194                 CERROR("Can't find mount for %s\n", name);
 195
 196         RETURN(lmi);
 197 }
 198 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         cfs_mutex_lock(&lustre_mount_info_lock);
 210         lmi = server_find_mount(name);
 211         cfs_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 CFS_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         cfs_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
 686 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 2, 50, 0)
 687         data->ocd_connect_flags |= OBD_CONNECT_MNE_SWAB;
 688 #else
 689 #warning "LU-1644: Remove old OBD_CONNECT_MNE_SWAB fixup and imp_need_mne_swab"
 690 #endif
 691
 692         if (lmd_is_client(lsi->lsi_lmd) &&
 693             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
 694                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
 695         data->ocd_version = LUSTRE_VERSION_CODE;
 696         rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
 697         if (rc) {
 698                 CERROR("connect failed %d\n", rc);
 699                 GOTO(out, rc);
 700         }
 701
 702         obd->u.cli.cl_mgc_mgsexp = exp;
 703
 704 out:
 705         /* Keep the mgc info in the sb. Note that many lsi's can point
 706            to the same mgc.*/
 707         lsi->lsi_mgc = obd;
 708 out_free:
 709         cfs_mutex_unlock(&mgc_start_lock);
 710
 711         if (data)
 712                 OBD_FREE_PTR(data);
 713         if (mgcname)
 714                 OBD_FREE(mgcname, len);
 715         if (niduuid)
 716                 OBD_FREE(niduuid, len + 2);
 717         RETURN(rc);
 718 }
 719
 720 static int lustre_stop_mgc(struct super_block *sb)
 721 {
 722         struct lustre_sb_info *lsi = s2lsi(sb);
 723         struct obd_device *obd;
 724         char *niduuid = 0, *ptr = 0;
 725         int i, rc = 0, len = 0;
 726         ENTRY;
 727
 728         if (!lsi)
 729                 RETURN(-ENOENT);
 730         obd = lsi->lsi_mgc;
 731         if (!obd)
 732                 RETURN(-ENOENT);
 733         lsi->lsi_mgc = NULL;
 734
 735         cfs_mutex_lock(&mgc_start_lock);
 736         LASSERT(cfs_atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
 737         if (!cfs_atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
 738                 /* This is not fatal, every client that stops
 739                    will call in here. */
 740                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
 741                        cfs_atomic_read(&obd->u.cli.cl_mgc_refcount));
 742                 GOTO(out, rc = -EBUSY);
 743         }
 744
 745         /* The MGC has no recoverable data in any case.
 746          * force shotdown set in umount_begin */
 747         obd->obd_no_recov = 1;
 748
 749         if (obd->u.cli.cl_mgc_mgsexp) {
 750                 /* An error is not fatal, if we are unable to send the
 751                    disconnect mgs ping evictor cleans up the export */
 752                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
 753                 if (rc)
 754                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
 755         }
 756
 757         /* Save the obdname for cleaning the nid uuids, which are
 758            obdname_XX */
 759         len = strlen(obd->obd_name) + 6;
 760         OBD_ALLOC(niduuid, len);
 761         if (niduuid) {
 762                 strcpy(niduuid, obd->obd_name);
 763                 ptr = niduuid + strlen(niduuid);
 764         }
 765
 766         rc = class_manual_cleanup(obd);
 767         if (rc)
 768                 GOTO(out, rc);
 769
 770         /* Clean the nid uuids */
 771         if (!niduuid)
 772                 GOTO(out, rc = -ENOMEM);
 773
 774         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
 775                 sprintf(ptr, "_%x", i);
 776                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
 777                              niduuid, 0, 0, 0);
 778                 if (rc)
 779                         CERROR("del MDC UUID %s failed: rc = %d\n",
 780                                niduuid, rc);
 781         }
 782 out:
 783         if (niduuid)
 784                 OBD_FREE(niduuid, len);
 785
 786         /* class_import_put will get rid of the additional connections */
 787         cfs_mutex_unlock(&mgc_start_lock);
 788         RETURN(rc);
 789 }
 790
 791 /* Since there's only one mgc per node, we have to change it's fs to get
 792    access to the right disk. */
 793 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
 794 {
 795         struct lustre_sb_info *lsi = s2lsi(sb);
 796         int rc;
 797         ENTRY;
 798
 799         CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
 800
 801         /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
 802         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 803                                 sizeof(KEY_SET_FS), KEY_SET_FS,
 804                                 sizeof(*sb), sb, NULL);
 805         if (rc) {
 806                 CERROR("can't set_fs %d\n", rc);
 807         }
 808
 809         RETURN(rc);
 810 }
 811
 812 static int server_mgc_clear_fs(struct obd_device *mgc)
 813 {
 814         int rc;
 815         ENTRY;
 816
 817         CDEBUG(D_MOUNT, "Unassign mgc disk\n");
 818
 819         rc = obd_set_info_async(NULL, mgc->obd_self_export,
 820                                 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
 821                                 0, NULL, NULL);
 822         RETURN(rc);
 823 }
 824
 825 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
 826  * @param [in] svname server name including type and index
 827  * @param [out] fsname Buffer to copy filesystem name prefix into.
 828  *  Must have at least 'strlen(fsname) + 1' chars.
 829  * @param [out] endptr if endptr isn't NULL it is set to end of fsname
 830  * rc < 0  on error
 831  */
 832 int server_name2fsname(char *svname, char *fsname, char **endptr)
 833 {
 834         char *dash = strrchr(svname, '-');
 835         if (!dash) {
 836                 dash = strrchr(svname, ':');
 837                 if (!dash)
 838                         return -EINVAL;
 839         }
 840
 841         /* interpret <fsname>-MDTXXXXX-mdc as mdt, the better way is to pass
 842          * in the fsname, then determine the server index */
 843         if (!strcmp(LUSTRE_MDC_NAME, dash + 1)) {
 844                 dash--;
 845                 for (; dash > svname && *dash != '-' && *dash != ':'; dash--)
 846                         ;
 847                 if (dash == svname)
 848                         return -EINVAL;
 849         }
 850
 851         if (fsname != NULL) {
 852                 strncpy(fsname, svname, dash - svname);
 853                 fsname[dash - svname] = '\0';
 854         }
 855
 856         if (endptr != NULL)
 857                 *endptr = dash;
 858
 859         return 0;
 860 }
 861 EXPORT_SYMBOL(server_name2fsname);
 862
 863 static int is_mdc_device(char *devname)
 864 {
 865         char *ptr;
 866         ptr = strrchr(devname, '-');
 867         if (ptr != NULL && strcmp(ptr, "-mdc") == 0)
 868                 return 1;
 869         return 0;
 870 }
 871
 872 static int inline tgt_is_mdt0(char *tgtname)
 873 {
 874         __u32 idx;
 875         int   type;
 876
 877         type = server_name2index(tgtname, &idx, NULL);
 878         if (type != LDD_F_SV_TYPE_MDT)
 879                 return 0;
 880
 881         return (idx == 0) ? 1 :0;
 882 }
 883
 884 static int inline is_mdc_for_mdt0(char *devname)
 885 {
 886         char   *ptr;
 887
 888         if (!is_mdc_device(devname))
 889                 return 0;
 890
 891         ptr = strrchr(devname, '-');
 892         if (ptr == NULL)
 893                 return 0;
 894
 895         *ptr = 0;
 896         if (tgt_is_mdt0(devname)) {
 897                 *ptr = '-';
 898                 return 1;
 899         }
 900         *ptr = '-';
 901         return 0;
 902 }
 903
 904 /**
 905  * Convert OST/MDT name(fsname-OSTxxxx) to an osp name
 906  * (fsname-MDT0000-osp-OSTxxxx), which will be used to
 907  * communicate with MDT0 for this target.
 908  **/
 909 int tgt_name2ospname(char *svname, char *ospname)
 910 {
 911         char *fsname;
 912         char *tgt;
 913         int   rc;
 914         ENTRY;
 915
 916         OBD_ALLOC(fsname, MTI_NAME_MAXLEN);
 917         if (fsname == NULL)
 918                 RETURN(-ENOMEM);
 919
 920         rc = server_name2fsname(svname, fsname, &tgt);
 921         if (rc != 0) {
 922                 CERROR("%s change fsname error: rc %d\n", svname, rc);
 923                 GOTO(cleanup, rc);
 924         }
 925
 926         if (*tgt != '-' && *tgt != ':') {
 927                 CERROR("%s wrong svname name!\n", svname);
 928                 GOTO(cleanup, rc = -EINVAL);
 929         }
 930
 931         tgt++;
 932         if (strncmp(tgt, "OST", 3) != 0 && strncmp(tgt, "MDT", 3) != 0) {
 933                 CERROR("%s is not an OST or MDT target!\n", svname);
 934                 GOTO(cleanup, rc = -EINVAL);
 935         }
 936         sprintf(ospname, "%s-MDT0000-%s-%s", fsname, LUSTRE_OSP_NAME, tgt);
 937 cleanup:
 938         if (fsname != NULL)
 939                 OBD_FREE(fsname, MTI_NAME_MAXLEN);
 940         RETURN(rc);
 941 }
 942 EXPORT_SYMBOL(tgt_name2ospname);
 943
 944 static CFS_LIST_HEAD(osp_register_list);
 945 CFS_DEFINE_MUTEX(osp_register_list_lock);
 946
 947 int lustre_register_osp_item(char *ospname, struct obd_export **exp,
 948                              register_osp_cb cb_func, void *cb_data)
 949 {
 950         struct obd_device        *osp;
 951         struct osp_register_item *ori;
 952         ENTRY;
 953
 954         LASSERTF(strlen(ospname) < MTI_NAME_MAXLEN, "ospname is too long %s\n",
 955                  ospname);
 956         LASSERT(exp != NULL && *exp == NULL);
 957
 958         OBD_ALLOC_PTR(ori);
 959         if (ori == NULL)
 960                 RETURN(-ENOMEM);
 961
 962         cfs_mutex_lock(&osp_register_list_lock);
 963
 964         osp = class_name2obd(ospname);
 965         if (osp != NULL && osp->obd_set_up == 1) {
 966                 struct obd_uuid *uuid;
 967
 968                 OBD_ALLOC_PTR(uuid);
 969                 if (uuid == NULL) {
 970                         cfs_mutex_unlock(&osp_register_list_lock);
 971                         RETURN(-ENOMEM);
 972                 }
 973                 memcpy(uuid->uuid, ospname, strlen(ospname));
 974                 *exp = cfs_hash_lookup(osp->obd_uuid_hash, uuid);
 975                 OBD_FREE_PTR(uuid);
 976         }
 977
 978         memcpy(ori->ori_name, ospname, strlen(ospname));
 979         ori->ori_exp = exp;
 980         ori->ori_cb_func = cb_func;
 981         ori->ori_cb_data = cb_data;
 982         CFS_INIT_LIST_HEAD(&ori->ori_list);
 983         cfs_list_add(&ori->ori_list, &osp_register_list);
 984
 985         if (*exp != NULL && cb_func != NULL)
 986                 cb_func(cb_data);
 987
 988         cfs_mutex_unlock(&osp_register_list_lock);
 989         RETURN(0);
 990 }
 991 EXPORT_SYMBOL(lustre_register_osp_item);
 992
 993 void lustre_deregister_osp_item(struct obd_export **exp)
 994 {
 995         struct osp_register_item *ori, *tmp;
 996
 997         cfs_mutex_lock(&osp_register_list_lock);
 998         cfs_list_for_each_entry_safe(ori, tmp, &osp_register_list, ori_list) {
 999                 if (exp == ori->ori_exp) {
1000                         if (*exp)
1001                                 class_export_put(*exp);
1002                         cfs_list_del(&ori->ori_list);
1003                         OBD_FREE_PTR(ori);
1004                         break;
1005                 }
1006         }
1007         cfs_mutex_unlock(&osp_register_list_lock);
1008 }
1009 EXPORT_SYMBOL(lustre_deregister_osp_item);
1010
1011 static void lustre_notify_osp_list(struct obd_export *exp)
1012 {
1013         struct osp_register_item *ori, *tmp;
1014         LASSERT(exp != NULL);
1015
1016         cfs_mutex_lock(&osp_register_list_lock);
1017         cfs_list_for_each_entry_safe(ori, tmp, &osp_register_list, ori_list) {
1018                 if (strcmp(exp->exp_obd->obd_name, ori->ori_name))
1019                         continue;
1020                 if (*ori->ori_exp != NULL)
1021                         continue;
1022                 *ori->ori_exp = class_export_get(exp);
1023                 if (ori->ori_cb_func != NULL)
1024                         ori->ori_cb_func(ori->ori_cb_data);
1025         }
1026         cfs_mutex_unlock(&osp_register_list_lock);
1027 }
1028
1029 static int lustre_osp_connect(struct obd_device *osp)
1030 {
1031         struct lu_env            env;
1032         struct lu_context        session_ctx;
1033         struct obd_export       *exp;
1034         struct obd_uuid         *uuid = NULL;
1035         struct obd_connect_data *data = NULL;
1036         int                      rc;
1037         ENTRY;
1038
1039         /* log has been fully processed, let clients connect */
1040         rc = lu_env_init(&env, osp->obd_lu_dev->ld_type->ldt_ctx_tags);
1041         if (rc != 0)
1042                 RETURN(rc);
1043
1044         lu_context_init(&session_ctx, LCT_SESSION);
1045         session_ctx.lc_thread = NULL;
1046         lu_context_enter(&session_ctx);
1047         env.le_ses = &session_ctx;
1048
1049         OBD_ALLOC_PTR(data);
1050         if (data == NULL)
1051                 GOTO(out, rc = -ENOMEM);
1052
1053         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX;
1054         data->ocd_version = LUSTRE_VERSION_CODE;
1055         data->ocd_ibits_known = MDS_INODELOCK_UPDATE;
1056         data->ocd_connect_flags |= OBD_CONNECT_ACL | OBD_CONNECT_IBITS |
1057                                    OBD_CONNECT_MDS_MDS | OBD_CONNECT_FID |
1058                                    OBD_CONNECT_AT | OBD_CONNECT_FULL20 |
1059                                    OBD_CONNECT_LIGHTWEIGHT;
1060         OBD_ALLOC_PTR(uuid);
1061         if (uuid == NULL)
1062                 GOTO(out, rc = -ENOMEM);
1063
1064         if (strlen(osp->obd_name) > sizeof(uuid->uuid)) {
1065                 CERROR("%s: Too long osp name %s, max_size is %d\n",
1066                        osp->obd_name, osp->obd_name, (int)sizeof(uuid->uuid));
1067                 GOTO(out, rc = -EINVAL);
1068         }
1069         /* Use osp name as the uuid, so we find the export by
1070          * osp name later */
1071         memcpy(uuid->uuid, osp->obd_name, strlen(osp->obd_name));
1072         rc = obd_connect(&env, &exp, osp, uuid, data, NULL);
1073         if (rc != 0)
1074                 CERROR("%s: connect failed: rc = %d\n", osp->obd_name, rc);
1075         else
1076                 lustre_notify_osp_list(exp);
1077
1078 out:
1079         if (data != NULL)
1080                 OBD_FREE_PTR(data);
1081         if (uuid != NULL)
1082                 OBD_FREE_PTR(uuid);
1083
1084         lu_env_fini(&env);
1085         lu_context_exit(&session_ctx);
1086         lu_context_fini(&session_ctx);
1087
1088         RETURN(rc);
1089 }
1090
1091 /**
1092  * osp-on-ost is used by slaves (Non-MDT0 targets) to manage the connection
1093  * to MDT0.
1094  *
1095  * The OSTs will communicate with MDT0 by the connection established by the
1096  * osp-on-ost to get quota and fid sequence.
1097  *
1098  **/
1099 static int lustre_osp_setup(struct lustre_cfg *lcfg, struct lustre_sb_info *lsi)
1100 {
1101         struct obd_connect_data *data = NULL;
1102         struct obd_device       *obd;
1103         char                    *ospname = NULL;
1104         char                    *ospuuid = NULL;
1105         int                      rc;
1106         ENTRY;
1107
1108         rc = class_add_uuid(lustre_cfg_string(lcfg, 1),
1109                             lcfg->lcfg_nid);
1110         if (rc) {
1111                 CERROR("%s: Can't add uuid: rc =%d\n", lsi->lsi_svname, rc);
1112                 GOTO(out, rc);
1113         }
1114
1115         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1116         if (ospname == NULL)
1117                 GOTO(out, rc = -ENOMEM);
1118
1119         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1120         if (rc != 0) {
1121                 CERROR("%s change ospname error: rc %d\n",
1122                        lsi->lsi_svname, rc);
1123                 GOTO(out, rc);
1124         }
1125
1126         OBD_ALLOC(ospuuid, MTI_NAME_MAXLEN);
1127         if (ospuuid == NULL)
1128                 GOTO(out, rc = -ENOMEM);
1129
1130         sprintf(ospuuid, "%s_UUID", ospname);
1131         rc = lustre_start_simple(ospname, LUSTRE_OSP_NAME,
1132                                  ospuuid, lustre_cfg_string(lcfg, 1),
1133                                  0, 0, 0);
1134         if (rc) {
1135                 CERROR("%s: setup up failed: rc %d\n", ospname, rc);
1136                 GOTO(out, rc);
1137         }
1138
1139         obd = class_name2obd(ospname);
1140         LASSERT(obd != NULL);
1141
1142         rc = lustre_osp_connect(obd);
1143         if (rc != 0)
1144                 CERROR("%s: connect failed: rc = %d\n", ospname, rc);
1145 out:
1146         if (data != NULL)
1147                 OBD_FREE_PTR(data);
1148         if (ospname != NULL)
1149                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1150         if (ospuuid != NULL)
1151                 OBD_FREE(ospuuid, MTI_NAME_MAXLEN);
1152
1153         RETURN(rc);
1154 }
1155
1156 static int lustre_osp_add_conn(struct lustre_cfg *cfg,
1157                                struct lustre_sb_info *lsi)
1158 {
1159         struct lustre_cfg_bufs *bufs = NULL;
1160         struct lustre_cfg      *lcfg = NULL;
1161         char                   *ospname = NULL;
1162         struct obd_device      *osp;
1163         int                     rc;
1164         ENTRY;
1165
1166         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1167         if (ospname == NULL)
1168                 GOTO(out, rc = -ENOMEM);
1169
1170         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1171         if (rc != 0) {
1172                 CERROR("%s change ospname error: rc %d\n",
1173                        lsi->lsi_svname, rc);
1174                 GOTO(out, rc);
1175         }
1176
1177         OBD_ALLOC_PTR(bufs);
1178         if (bufs == NULL)
1179                 RETURN(-ENOMEM);
1180
1181         lustre_cfg_bufs_reset(bufs, ospname);
1182         lustre_cfg_bufs_set_string(bufs, 1,
1183                                    lustre_cfg_string(cfg, 1));
1184
1185         lcfg = lustre_cfg_new(LCFG_ADD_CONN, bufs);
1186
1187         osp = class_name2obd(ospname);
1188         if (osp == NULL) {
1189                 CERROR("Can not find %s\n", ospname);
1190                 GOTO(out, rc = -EINVAL);
1191         }
1192
1193         rc = class_add_conn(osp, lcfg);
1194         if (rc)
1195                 CERROR("%s: can't add conn: rc = %d\n", ospname, rc);
1196
1197 out:
1198         if (bufs != NULL)
1199                 OBD_FREE_PTR(bufs);
1200         if (lcfg != NULL)
1201                 lustre_cfg_free(lcfg);
1202         if (ospname != NULL)
1203                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1204
1205         RETURN(rc);
1206 }
1207
1208 /**
1209  * Retrieve MDT nids from the client log, then start the osp-on-ost device.
1210  * there are only two scenarios which would include mdt nid.
1211  * 1.
1212  * marker   5 (flags=0x01, v2.1.54.0) lustre-MDT0000  'add mdc' xxx-
1213  * add_uuid  nid=192.168.122.162@tcp(0x20000c0a87aa2)  0:  1:192.168.122.162@tcp
1214  * attach    0:lustre-MDT0000-mdc  1:mdc  2:lustre-clilmv_UUID
1215  * setup     0:lustre-MDT0000-mdc  1:lustre-MDT0000_UUID  2:192.168.122.162@tcp
1216  * add_uuid  nid=192.168.172.1@tcp(0x20000c0a8ac01)  0:  1:192.168.172.1@tcp
1217  * add_conn  0:lustre-MDT0000-mdc  1:192.168.172.1@tcp
1218  * modify_mdc_tgts add 0:lustre-clilmv  1:lustre-MDT0000_UUID xxxx
1219  * marker   5 (flags=0x02, v2.1.54.0) lustre-MDT0000  'add mdc' xxxx-
1220  * 2.
1221  * marker   7 (flags=0x01, v2.1.54.0) lustre-MDT0000  'add failnid' xxxx-
1222  * add_uuid  nid=192.168.122.2@tcp(0x20000c0a87a02)  0:  1:192.168.122.2@tcp
1223  * add_conn  0:lustre-MDT0000-mdc  1:192.168.122.2@tcp
1224  * marker   7 (flags=0x02, v2.1.54.0) lustre-MDT0000  'add failnid' xxxx-
1225 **/
1226 static int client_osp_config_process(const struct lu_env *env,
1227                                      struct llog_handle *handle,
1228                                      struct llog_rec_hdr *rec, void *data)
1229 {
1230         struct config_llog_instance *clli = data;
1231         int                          cfg_len = rec->lrh_len;
1232         char                        *cfg_buf = (char *) (rec + 1);
1233         struct lustre_cfg           *lcfg = NULL;
1234         struct lustre_sb_info       *lsi;
1235         int                          rc = 0, swab = 0;
1236         ENTRY;
1237
1238         if (rec->lrh_type != OBD_CFG_REC) {
1239                 CERROR("Unknown llog record type %#x encountered\n",
1240                        rec->lrh_type);
1241                 RETURN(-EINVAL);
1242         }
1243
1244         LASSERT(clli->cfg_sb != NULL);
1245         lsi = s2lsi(clli->cfg_sb);
1246
1247         lcfg = (struct lustre_cfg *)cfg_buf;
1248         if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION)) {
1249                 lustre_swab_lustre_cfg(lcfg);
1250                 swab = 1;
1251         }
1252
1253         rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
1254         if (rc)
1255                 GOTO(out, rc);
1256
1257         switch (lcfg->lcfg_command) {
1258         case LCFG_MARKER: {
1259                 struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
1260
1261                 lustre_swab_cfg_marker(marker, swab,
1262                                        LUSTRE_CFG_BUFLEN(lcfg, 1));
1263                 if (marker->cm_flags & CM_SKIP ||
1264                     marker->cm_flags & CM_EXCLUDE)
1265                         GOTO(out, rc = 0);
1266
1267                 if (!tgt_is_mdt0(marker->cm_tgtname))
1268                         GOTO(out, rc = 0);
1269
1270                 if(!strncmp(marker->cm_comment, "add mdc", 7) ||
1271                    !strncmp(marker->cm_comment, "add failnid", 11)) {
1272                         if (marker->cm_flags & CM_START) {
1273                                 clli->cfg_flags = CFG_F_MARKER;
1274                                 /* This hack is to differentiate the
1275                                  * ADD_UUID is come from "add mdc" record
1276                                  * or from "add failnid" record. */
1277                                 if (!strncmp(marker->cm_comment,
1278                                              "add failnid", 11))
1279                                         clli->cfg_flags |= CFG_F_SKIP;
1280                         } else if (marker->cm_flags & CM_END) {
1281                                 clli->cfg_flags = 0;
1282                         }
1283                 }
1284                 break;
1285         }
1286         case LCFG_ADD_UUID: {
1287                 if (clli->cfg_flags == CFG_F_MARKER) {
1288                         rc = lustre_osp_setup(lcfg, lsi);
1289                         /* XXX: process only the first nid as
1290                          * we don't need another instance of osp */
1291                         clli->cfg_flags |= CFG_F_SKIP;
1292                 } else if (clli->cfg_flags == (CFG_F_MARKER | CFG_F_SKIP)) {
1293                         rc = class_add_uuid(lustre_cfg_string(lcfg, 1),
1294                                         lcfg->lcfg_nid);
1295                         if (rc)
1296                                 CERROR("%s: Fail to add uuid, rc:%d\n",
1297                                        lsi->lsi_svname, rc);
1298                 }
1299                 break;
1300         }
1301         case LCFG_ADD_CONN: {
1302                 if (is_mdc_for_mdt0(lustre_cfg_string(lcfg, 0)))
1303                         rc = lustre_osp_add_conn(lcfg, lsi);
1304                 break;
1305         }
1306         default:
1307                 break;
1308         }
1309 out:
1310         RETURN(rc);
1311 }
1312
1313 static int lustre_disconnect_osp(struct super_block *sb)
1314 {
1315         struct lustre_sb_info           *lsi = s2lsi(sb);
1316         struct obd_device               *osp;
1317         char                            *ospname = NULL;
1318         char                            *logname = NULL;
1319         struct lustre_cfg               *lcfg = NULL;
1320         struct lustre_cfg_bufs          *bufs = NULL;
1321         struct config_llog_instance     *cfg = NULL;
1322         int                              rc;
1323         ENTRY;
1324
1325         LASSERT(IS_OST(lsi) || IS_MDT(lsi));
1326         OBD_ALLOC(logname, MTI_NAME_MAXLEN);
1327         if (logname == NULL)
1328                 RETURN(-ENOMEM);
1329
1330         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1331         if (ospname == NULL)
1332                 GOTO(out, rc = -ENOMEM);
1333
1334         rc = server_name2fsname(lsi->lsi_svname, ospname, NULL);
1335         if (rc != 0) {
1336                 CERROR("%s: get fsname error: %d\n",
1337                        lsi->lsi_svname, rc);
1338                 GOTO(out, rc);
1339         }
1340         sprintf(logname, "%s-client", ospname);
1341
1342         OBD_ALLOC_PTR(cfg);
1343         if (cfg == NULL)
1344                 GOTO(out, rc = -ENOMEM);
1345
1346         /* end log first */
1347         cfg->cfg_instance = sb;
1348         rc = lustre_end_log(sb, logname, cfg);
1349         if (rc != 0) {
1350                 CERROR("Can't end config log %s\n", ospname);
1351                 GOTO(out, rc);
1352         }
1353
1354         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1355         if (rc != 0) {
1356                 CERROR("%s: get osp name error: %d\n",
1357                        lsi->lsi_svname, rc);
1358                 GOTO(out, rc);
1359         }
1360
1361         osp = class_name2obd(ospname);
1362         if (osp == NULL) {
1363                 CERROR("Can't find osp-on-ost %s\n", ospname);
1364                 GOTO(out, rc = -ENOENT);
1365         }
1366
1367         OBD_ALLOC_PTR(bufs);
1368         if (bufs == NULL)
1369                 GOTO(out, rc = -ENOMEM);
1370
1371         lustre_cfg_bufs_reset(bufs, osp->obd_name);
1372         lustre_cfg_bufs_set_string(bufs, 1, NULL);
1373         lcfg = lustre_cfg_new(LCFG_CLEANUP, bufs);
1374         if (!lcfg)
1375                 GOTO(out, rc = -ENOMEM);
1376
1377         /* Disconnect import first. NULL is passed for the '@env', since
1378          * it will not be used for the 'osp-on-ost'. (see osp_shutdown()) */
1379         rc = osp->obd_lu_dev->ld_ops->ldo_process_config(NULL, osp->obd_lu_dev,
1380                                                          lcfg);
1381 out:
1382         if (lcfg)
1383                 lustre_cfg_free(lcfg);
1384         if (bufs)
1385                 OBD_FREE_PTR(bufs);
1386         if (cfg)
1387                 OBD_FREE_PTR(cfg);
1388         if (ospname)
1389                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1390         if (logname)
1391                 OBD_FREE(logname, MTI_NAME_MAXLEN);
1392         RETURN(rc);
1393 }
1394
1395 /**
1396  * Stop the osp(fsname-MDT0000-osp-OSTxxxx) for an OST target.
1397  **/
1398 static int lustre_stop_osp(struct super_block *sb)
1399 {
1400         struct lustre_sb_info   *lsi = s2lsi(sb);
1401         struct obd_device       *osp = NULL;
1402         char                    *ospname = NULL;
1403         int                      rc = 0;
1404         ENTRY;
1405
1406         LASSERT(IS_OST(lsi) || IS_MDT(lsi));
1407         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1408
1409         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1410         if (rc != 0) {
1411                 CERROR("%s get fsname error: rc %d\n",
1412                        lsi->lsi_svname, rc);
1413                 GOTO(cleanup, rc);
1414         }
1415
1416         osp = class_name2obd(ospname);
1417         if (osp == NULL) {
1418                 CERROR("Can not find osp-on-ost %s\n", ospname);
1419                 GOTO(cleanup, rc = -ENOENT);
1420         }
1421
1422         osp->obd_force = 1;
1423         rc = class_manual_cleanup(osp);
1424
1425 cleanup:
1426         if (ospname != NULL)
1427                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1428         RETURN(rc);
1429 }
1430
1431 CFS_DEFINE_MUTEX(server_start_lock);
1432
1433 /* Stop MDS/OSS if nobody is using them */
1434 static int server_stop_servers(int lsiflags)
1435 {
1436         struct obd_device *obd = NULL;
1437         struct obd_type *type = NULL;
1438         int rc = 0;
1439         ENTRY;
1440
1441         cfs_mutex_lock(&server_start_lock);
1442
1443         /* Either an MDT or an OST or neither  */
1444         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
1445         if ((lsiflags & LDD_F_SV_TYPE_MDT) &&
1446             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
1447                 /*FIXME pre-rename, should eventually be LUSTRE_MDT_NAME*/
1448                 type = class_search_type(LUSTRE_MDS_NAME);
1449         }
1450         /* if this was an OST, and there are no more OST's, clean up the OSS */
1451         if ((lsiflags & LDD_F_SV_TYPE_OST) &&
1452             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
1453                 type = class_search_type(LUSTRE_OST_NAME);
1454         }
1455
1456         if (obd && (!type || !type->typ_refcnt)) {
1457                 int err;
1458                 obd->obd_force = 1;
1459                 /* obd_fail doesn't mean much on a server obd */
1460                 err = class_manual_cleanup(obd);
1461                 if (!rc)
1462                         rc = err;
1463         }
1464
1465         cfs_mutex_unlock(&server_start_lock);
1466
1467         RETURN(rc);
1468 }
1469
1470 int server_mti_print(char *title, struct mgs_target_info *mti)
1471 {
1472         PRINT_CMD(PRINT_MASK, "mti %s\n", title);
1473         PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
1474         PRINT_CMD(PRINT_MASK, "fs:     %s\n", mti->mti_fsname);
1475         PRINT_CMD(PRINT_MASK, "uuid:   %s\n", mti->mti_uuid);
1476         PRINT_CMD(PRINT_MASK, "ver: %d  flags: %#x\n",
1477                   mti->mti_config_ver, mti->mti_flags);
1478         return(0);
1479 }
1480
1481 /**
1482  * Get service name (svname) from string
1483  * rc < 0 on error
1484  * if endptr isn't NULL it is set to end of fsname *
1485  */
1486 int server_name2svname(char *label, char *svname, char **endptr)
1487 {
1488         int rc;
1489         char *dash;
1490
1491         /* We use server_name2fsname() just for parsing */
1492         rc = server_name2fsname(label, NULL, &dash);
1493         if (rc != 0)
1494                 return rc;
1495
1496         if (*dash != '-')
1497                 return -1;
1498
1499         strncpy(svname, dash + 1, MTI_NAME_MAXLEN);
1500
1501         return 0;
1502 }
1503 EXPORT_SYMBOL(server_name2svname);
1504
1505
1506 /* Get the index from the obd name.
1507    rc = server type, or
1508    rc < 0  on error
1509    if endptr isn't NULL it is set to end of name */
1510 int server_name2index(char *svname, __u32 *idx, char **endptr)
1511 {
1512         unsigned long index;
1513         int rc;
1514         char *dash;
1515
1516         /* We use server_name2fsname() just for parsing */
1517         rc = server_name2fsname(svname, NULL, &dash);
1518         if (rc != 0)
1519                 return rc;
1520
1521         if (*dash != '-')
1522                 return -EINVAL;
1523
1524         dash++;
1525
1526         if (strncmp(dash, "MDT", 3) == 0)
1527                 rc = LDD_F_SV_TYPE_MDT;
1528         else if (strncmp(dash, "OST", 3) == 0)
1529                 rc = LDD_F_SV_TYPE_OST;
1530         else
1531                 return -EINVAL;
1532
1533         dash += 3;
1534
1535         if (strcmp(dash, "all") == 0)
1536                 return rc | LDD_F_SV_ALL;
1537
1538         index = simple_strtoul(dash, endptr, 16);
1539         *idx = index;
1540
1541         return rc;
1542 }
1543 EXPORT_SYMBOL(server_name2index);
1544
1545 /* Generate data for registration */
1546 static int server_lsi2mti(struct lustre_sb_info *lsi,
1547                           struct mgs_target_info *mti)
1548 {
1549         lnet_process_id_t id;
1550         int rc, i = 0;
1551         ENTRY;
1552
1553         if (!IS_SERVER(lsi))
1554                 RETURN(-EINVAL);
1555
1556         strncpy(mti->mti_svname, lsi->lsi_svname, sizeof(mti->mti_svname));
1557
1558         mti->mti_nid_count = 0;
1559         while (LNetGetId(i++, &id) != -ENOENT) {
1560                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
1561                         continue;
1562
1563                 /* server use --servicenode param, only allow specified
1564                  * nids be registered */
1565                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) != 0 &&
1566                     class_match_nid(lsi->lsi_lmd->lmd_params,
1567                                     PARAM_FAILNODE, id.nid) < 1)
1568                         continue;
1569
1570                 /* match specified network */
1571                 if (!class_match_net(lsi->lsi_lmd->lmd_params,
1572                                      PARAM_NETWORK, LNET_NIDNET(id.nid)))
1573                         continue;
1574
1575                 mti->mti_nids[mti->mti_nid_count] = id.nid;
1576                 mti->mti_nid_count++;
1577                 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
1578                         CWARN("Only using first %d nids for %s\n",
1579                               mti->mti_nid_count, mti->mti_svname);
1580                         break;
1581                 }
1582         }
1583
1584         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
1585         mti->mti_config_ver = 0;
1586
1587         rc = server_name2fsname(lsi->lsi_svname, mti->mti_fsname, NULL);
1588         if (rc != 0)
1589                 return rc;
1590
1591         rc = server_name2index(lsi->lsi_svname, &mti->mti_stripe_index, NULL);
1592         if (rc < 0)
1593                 return rc;
1594         /* Orion requires index to be set */
1595         LASSERT(!(rc & LDD_F_NEED_INDEX));
1596         /* keep only LDD flags */
1597         mti->mti_flags = lsi->lsi_flags & LDD_F_MASK;
1598         mti->mti_flags |= LDD_F_UPDATE;
1599         strncpy(mti->mti_params, lsi->lsi_lmd->lmd_params,
1600                 sizeof(mti->mti_params));
1601         return 0;
1602 }
1603
1604 /* Register an old or new target with the MGS. If needed MGS will construct
1605    startup logs and assign index */
1606 static int server_register_target(struct lustre_sb_info *lsi)
1607 {
1608         struct obd_device *mgc = lsi->lsi_mgc;
1609         struct mgs_target_info *mti = NULL;
1610         bool writeconf;
1611         int rc;
1612         ENTRY;
1613
1614         LASSERT(mgc);
1615
1616         if (!IS_SERVER(lsi))
1617                 RETURN(-EINVAL);
1618
1619         OBD_ALLOC_PTR(mti);
1620         if (!mti)
1621                 RETURN(-ENOMEM);
1622
1623         rc = server_lsi2mti(lsi, mti);
1624         if (rc)
1625                 GOTO(out, rc);
1626
1627         CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
1628                mti->mti_svname, mti->mti_fsname,
1629                libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
1630                mti->mti_flags);
1631
1632         /* if write_conf is true, the registration must succeed */
1633         writeconf = !!(lsi->lsi_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE));
1634         mti->mti_flags |= LDD_F_OPC_REG;
1635
1636         /* Register the target */
1637         /* FIXME use mgc_process_config instead */
1638         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1639                                 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1640                                 sizeof(*mti), mti, NULL);
1641         if (rc) {
1642                 if (mti->mti_flags & LDD_F_ERROR) {
1643                         LCONSOLE_ERROR_MSG(0x160,
1644                                 "The MGS is refusing to allow this "
1645                                 "server (%s) to start. Please see messages"
1646                                 " on the MGS node.\n", lsi->lsi_svname);
1647                 } else if (writeconf) {
1648                         LCONSOLE_ERROR_MSG(0x15f,
1649                                 "Communication to the MGS return error %d. "
1650                                 "Is the MGS running?\n", rc);
1651                 } else {
1652                         CERROR("Cannot talk to the MGS: %d, not fatal\n", rc);
1653                         /* reset the error code for non-fatal error. */
1654                         rc = 0;
1655                 }
1656                 GOTO(out, rc);
1657         }
1658
1659 out:
1660         if (mti)
1661                 OBD_FREE_PTR(mti);
1662         RETURN(rc);
1663 }
1664
1665 /**
1666  * Notify the MGS that this target is ready.
1667  * Used by IR - if the MGS receives this message, it will notify clients.
1668  */
1669 static int server_notify_target(struct super_block *sb, struct obd_device *obd)
1670 {
1671         struct lustre_sb_info *lsi = s2lsi(sb);
1672         struct obd_device *mgc = lsi->lsi_mgc;
1673         struct mgs_target_info *mti = NULL;
1674         int rc;
1675         ENTRY;
1676
1677         LASSERT(mgc);
1678
1679         if (!(IS_SERVER(lsi)))
1680                 RETURN(-EINVAL);
1681
1682         OBD_ALLOC_PTR(mti);
1683         if (!mti)
1684                 RETURN(-ENOMEM);
1685         rc = server_lsi2mti(lsi, mti);
1686         if (rc)
1687                 GOTO(out, rc);
1688
1689         mti->mti_instance = obd->u.obt.obt_instance;
1690         mti->mti_flags |= LDD_F_OPC_READY;
1691
1692         /* FIXME use mgc_process_config instead */
1693         rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1694                                 sizeof(KEY_REGISTER_TARGET),
1695                                 KEY_REGISTER_TARGET,
1696                                 sizeof(*mti), mti, NULL);
1697
1698         /* Imperative recovery: if the mgs informs us to use IR? */
1699         if (!rc && !(mti->mti_flags & LDD_F_ERROR) &&
1700             (mti->mti_flags & LDD_F_IR_CAPABLE))
1701                 lsi->lsi_flags |= LDD_F_IR_CAPABLE;
1702
1703 out:
1704         if (mti)
1705                 OBD_FREE_PTR(mti);
1706         RETURN(rc);
1707
1708 }
1709
1710 /**
1711  * Start the osp(fsname-MDT0000-osp-OSTxxxx) for an OST target,
1712  * which would be used to communicate with MDT0 for quota and FID.
1713  **/
1714 static int lustre_start_osp(struct super_block *sb)
1715 {
1716         struct lustre_sb_info       *lsi = s2lsi(sb);
1717         struct config_llog_instance *cfg = NULL;
1718         struct obd_device           *osp;
1719         char                        *ospname = NULL;
1720         char                        *logname = NULL;
1721         char                        *tgt;
1722         int                          rc;
1723         ENTRY;
1724
1725         LASSERT(IS_OST(lsi) || IS_MDT(lsi));
1726         OBD_ALLOC(ospname, MTI_NAME_MAXLEN);
1727         OBD_ALLOC(logname, MTI_NAME_MAXLEN);
1728         if (ospname == NULL || logname == NULL)
1729                 GOTO(cleanup, rc = -ENOMEM);
1730
1731         rc = server_name2fsname(lsi->lsi_svname, ospname, &tgt);
1732         if (rc != 0) {
1733                 CERROR("%s change fsname error: rc %d\n",
1734                        lsi->lsi_svname, rc);
1735                 GOTO(cleanup, rc);
1736         }
1737         sprintf(logname, "%s-client", ospname);
1738
1739         rc = tgt_name2ospname(lsi->lsi_svname, ospname);
1740         if (rc != 0) {
1741                 CERROR("%s change ospname error: rc %d\n",
1742                        lsi->lsi_svname, rc);
1743                 GOTO(cleanup, rc);
1744         }
1745
1746         osp = class_name2obd(ospname);
1747         if (osp != NULL)
1748                 GOTO(cleanup, rc = 0);
1749
1750         OBD_ALLOC_PTR(cfg);
1751         if (cfg == NULL)
1752                 GOTO(cleanup, rc = -ENOMEM);
1753
1754         cfg->cfg_callback = client_osp_config_process;
1755         cfg->cfg_instance = sb;
1756
1757         rc = lustre_process_log(sb, logname, cfg);
1758
1759 cleanup:
1760         if (ospname != NULL)
1761                 OBD_FREE(ospname, MTI_NAME_MAXLEN);
1762         if (logname != NULL)
1763                 OBD_FREE(logname, MTI_NAME_MAXLEN);
1764         if (cfg != NULL)
1765                 OBD_FREE_PTR(cfg);
1766
1767         RETURN(rc);
1768 }
1769
1770 /** Start server targets: MDTs and OSTs
1771  */
1772 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1773 {
1774         struct obd_device *obd;
1775         struct lustre_sb_info *lsi = s2lsi(sb);
1776         struct config_llog_instance cfg;
1777         struct lu_env env;
1778         struct lu_device *dev;
1779         int rc;
1780         ENTRY;
1781
1782         CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_svname);
1783
1784 #if 0
1785         /* If we're an MDT, make sure the global MDS is running */
1786         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_MDT) {
1787                 /* make sure the MDS is started */
1788                 cfs_mutex_lock(&server_start_lock);
1789                 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1790                 if (!obd) {
1791                         rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1792                     /* FIXME pre-rename, should eventually be LUSTRE_MDS_NAME */
1793                                                  LUSTRE_MDT_NAME,
1794                                                  LUSTRE_MDS_OBDNAME"_uuid",
1795                                                  0, 0);
1796                         if (rc) {
1797                                 cfs_mutex_unlock(&server_start_lock);
1798                                 CERROR("failed to start MDS: %d\n", rc);
1799                                 RETURN(rc);
1800                         }
1801                 }
1802                 cfs_mutex_unlock(&server_start_lock);
1803         }
1804 #endif
1805
1806         /* If we're an OST, make sure the global OSS is running */
1807         if (IS_OST(lsi)) {
1808                 /* make sure OSS is started */
1809                 cfs_mutex_lock(&server_start_lock);
1810                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1811                 if (!obd) {
1812                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1813                                                  LUSTRE_OSS_NAME,
1814                                                  LUSTRE_OSS_OBDNAME"_uuid",
1815                                                  0, 0, 0, 0);
1816                         if (rc) {
1817                                 cfs_mutex_unlock(&server_start_lock);
1818                                 CERROR("failed to start OSS: %d\n", rc);
1819                                 RETURN(rc);
1820                         }
1821                 }
1822                 cfs_mutex_unlock(&server_start_lock);
1823         }
1824
1825         /* Set the mgc fs to our server disk.  This allows the MGC to
1826          * read and write configs locally, in case it can't talk to the MGS. */
1827         if (lsi->lsi_srv_mnt) {
1828                 rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1829                 if (rc)
1830                         RETURN(rc);
1831         }
1832
1833         /* Register with MGS */
1834         rc = server_register_target(lsi);
1835         if (rc)
1836                 GOTO(out_mgc, rc);
1837
1838         /* Let the target look up the mount using the target's name
1839            (we can't pass the sb or mnt through class_process_config.) */
1840         rc = server_register_mount(lsi->lsi_svname, sb, mnt);
1841         if (rc)
1842                 GOTO(out_mgc, rc);
1843
1844         /* Start targets using the llog named for the target */
1845         memset(&cfg, 0, sizeof(cfg));
1846         cfg.cfg_callback = class_config_llog_handler;
1847         rc = lustre_process_log(sb, lsi->lsi_svname, &cfg);
1848         if (rc) {
1849                 CERROR("failed to start server %s: %d\n",
1850                        lsi->lsi_svname, rc);
1851                 /* Do NOT call server_deregister_mount() here. This makes it
1852                  * impossible to find mount later in cleanup time and leaves
1853                  * @lsi and othder stuff leaked. -umka */
1854                 GOTO(out_mgc, rc);
1855         }
1856
1857         obd = class_name2obd(lsi->lsi_svname);
1858         if (!obd) {
1859                 CERROR("no server named %s was started\n", lsi->lsi_svname);
1860                 GOTO(out_mgc, rc = -ENXIO);
1861         }
1862
1863         if (IS_OST(lsi) || IS_MDT(lsi)) {
1864                 rc = lustre_start_osp(sb);
1865                 if (rc) {
1866                         CERROR("%s: failed to start OSP: %d\n",
1867                                lsi->lsi_svname, rc);
1868                         GOTO(out_mgc, rc);
1869                 }
1870         }
1871
1872         server_notify_target(sb, obd);
1873
1874         /* calculate recovery timeout, do it after lustre_process_log */
1875         server_calc_timeout(lsi, obd);
1876
1877         /* log has been fully processed */
1878         obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1879
1880         /* log has been fully processed, let clients connect */
1881         dev = obd->obd_lu_dev;
1882         if (dev && dev->ld_ops->ldo_prepare) {
1883                 rc = lu_env_init(&env, dev->ld_type->ldt_ctx_tags);
1884                 if (rc == 0) {
1885                         struct lu_context  session_ctx;
1886
1887                         lu_context_init(&session_ctx, LCT_SESSION);
1888                         session_ctx.lc_thread = NULL;
1889                         lu_context_enter(&session_ctx);
1890                         env.le_ses = &session_ctx;
1891
1892                         dev->ld_ops->ldo_prepare(&env, NULL, dev);
1893
1894                         lu_env_fini(&env);
1895                         lu_context_exit(&session_ctx);
1896                         lu_context_fini(&session_ctx);
1897                 }
1898         }
1899
1900         /* abort recovery only on the complete stack:
1901          * many devices can be involved */
1902         if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1903             (OBP(obd, iocontrol))) {
1904                 obd_iocontrol(OBD_IOC_ABORT_RECOVERY, obd->obd_self_export, 0,
1905                               NULL, NULL);
1906         }
1907
1908 out_mgc:
1909         /* Release the mgc fs for others to use */
1910         if (lsi->lsi_srv_mnt)
1911                 server_mgc_clear_fs(lsi->lsi_mgc);
1912
1913         RETURN(rc);
1914 }
1915
1916 /***************** lustre superblock **************/
1917
1918 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1919 {
1920         struct lustre_sb_info *lsi;
1921         ENTRY;
1922
1923         OBD_ALLOC_PTR(lsi);
1924         if (!lsi)
1925                 RETURN(NULL);
1926         OBD_ALLOC_PTR(lsi->lsi_lmd);
1927         if (!lsi->lsi_lmd) {
1928                 OBD_FREE_PTR(lsi);
1929                 RETURN(NULL);
1930         }
1931
1932         lsi->lsi_lmd->lmd_exclude_count = 0;
1933         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
1934         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
1935         s2lsi_nocast(sb) = lsi;
1936         /* we take 1 extra ref for our setup */
1937         cfs_atomic_set(&lsi->lsi_mounts, 1);
1938
1939         /* Default umount style */
1940         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1941
1942         RETURN(lsi);
1943 }
1944
1945 static int lustre_free_lsi(struct super_block *sb)
1946 {
1947         struct lustre_sb_info *lsi = s2lsi(sb);
1948         ENTRY;
1949
1950         LASSERT(lsi != NULL);
1951         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
1952
1953         /* someone didn't call server_put_mount. */
1954         LASSERT(cfs_atomic_read(&lsi->lsi_mounts) == 0);
1955
1956         if (lsi->lsi_lmd != NULL) {
1957                 if (lsi->lsi_lmd->lmd_dev != NULL)
1958                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
1959                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
1960                 if (lsi->lsi_lmd->lmd_profile != NULL)
1961                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
1962                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
1963                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
1964                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
1965                                  strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
1966                 if (lsi->lsi_lmd->lmd_opts != NULL)
1967                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
1968                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
1969                 if (lsi->lsi_lmd->lmd_exclude_count)
1970                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1971                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1972                                  lsi->lsi_lmd->lmd_exclude_count);
1973                 if (lsi->lsi_lmd->lmd_mgs != NULL)
1974                         OBD_FREE(lsi->lsi_lmd->lmd_mgs,
1975                                  strlen(lsi->lsi_lmd->lmd_mgs) + 1);
1976                 if (lsi->lsi_lmd->lmd_osd_type != NULL)
1977                         OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
1978                                  strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
1979                 if (lsi->lsi_lmd->lmd_params != NULL)
1980                         OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
1981
1982                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1983         }
1984
1985         LASSERT(lsi->lsi_llsbi == NULL);
1986         OBD_FREE(lsi, sizeof(*lsi));
1987         s2lsi_nocast(sb) = NULL;
1988
1989         RETURN(0);
1990 }
1991
1992 /* The lsi has one reference for every server that is using the disk -
1993    e.g. MDT, MGS, and potentially MGC */
1994 static int lustre_put_lsi(struct super_block *sb)
1995 {
1996         struct lustre_sb_info *lsi = s2lsi(sb);
1997         ENTRY;
1998
1999         LASSERT(lsi != NULL);
2000
2001         CDEBUG(D_MOUNT, "put %p %d\n", sb, cfs_atomic_read(&lsi->lsi_mounts));
2002         if (cfs_atomic_dec_and_test(&lsi->lsi_mounts)) {
2003                 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
2004                         obd_disconnect(lsi->lsi_osd_exp);
2005                         /* wait till OSD is gone */
2006                         obd_zombie_barrier();
2007                 }
2008                 lustre_free_lsi(sb);
2009                 RETURN(1);
2010         }
2011         RETURN(0);
2012 }
2013
2014 static int lsi_prepare(struct lustre_sb_info *lsi)
2015 {
2016         __u32 index;
2017         int rc;
2018         ENTRY;
2019
2020         LASSERT(lsi);
2021         LASSERT(lsi->lsi_lmd);
2022
2023         /* The server name is given as a mount line option */
2024         if (lsi->lsi_lmd->lmd_profile == NULL) {
2025                 LCONSOLE_ERROR("Can't determine server name\n");
2026                 RETURN(-EINVAL);
2027         }
2028
2029         if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname))
2030                 RETURN(-ENAMETOOLONG);
2031
2032         strcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile);
2033
2034         /* Determine osd type */
2035         if (lsi->lsi_lmd->lmd_osd_type != NULL) {
2036                 if (strlen(lsi->lsi_lmd->lmd_osd_type) >=
2037                            sizeof(lsi->lsi_osd_type))
2038                         RETURN(-ENAMETOOLONG);
2039
2040                 strcpy(lsi->lsi_osd_type, lsi->lsi_lmd->lmd_osd_type);
2041         } else {
2042                 strcpy(lsi->lsi_osd_type, LUSTRE_OSD_LDISKFS_NAME);
2043         }
2044
2045         /* XXX: a temp. solution for components using fsfilt
2046          *      to be removed in one of the subsequent patches */
2047         if (!strcmp(lsi->lsi_lmd->lmd_osd_type, "osd-ldiskfs")) {
2048                 strcpy(lsi->lsi_fstype, "ldiskfs");
2049         } else {
2050                 strcpy(lsi->lsi_fstype, lsi->lsi_lmd->lmd_osd_type);
2051         }
2052
2053         /* Determine server type */
2054         rc = server_name2index(lsi->lsi_svname, &index, NULL);
2055         if (rc < 0) {
2056                 if (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) {
2057                         /* Assume we're a bare MGS */
2058                         rc = 0;
2059                         lsi->lsi_lmd->lmd_flags |= LMD_FLG_NOSVC;
2060                 } else {
2061                         LCONSOLE_ERROR("Can't determine server type of '%s'\n",
2062                                        lsi->lsi_svname);
2063                         RETURN(rc);
2064                 }
2065         }
2066         lsi->lsi_flags |= rc;
2067
2068         /* Add mount line flags that used to be in ldd:
2069          * writeconf, mgs, iam, anything else?
2070          */
2071         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_WRITECONF) ?
2072                 LDD_F_WRITECONF : 0;
2073         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_VIRGIN) ?
2074                 LDD_F_VIRGIN : 0;
2075         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) ?
2076                 LDD_F_SV_TYPE_MGS : 0;
2077         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_IAM) ?
2078                 LDD_F_IAM_DIR : 0;
2079         lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) ?
2080                 LDD_F_NO_PRIMNODE : 0;
2081
2082         RETURN(0);
2083 }
2084
2085 /*************** server mount ******************/
2086
2087 /** Start the shutdown of servers at umount.
2088  */
2089 static void server_put_super(struct super_block *sb)
2090 {
2091         struct lustre_sb_info *lsi = s2lsi(sb);
2092         struct obd_device     *obd;
2093         char *tmpname, *extraname = NULL;
2094         int tmpname_sz;
2095         int lsiflags = lsi->lsi_flags;
2096         ENTRY;
2097
2098         LASSERT(IS_SERVER(lsi));
2099
2100         tmpname_sz = strlen(lsi->lsi_svname) + 1;
2101         OBD_ALLOC(tmpname, tmpname_sz);
2102         memcpy(tmpname, lsi->lsi_svname, tmpname_sz);
2103         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
2104         if (IS_MDT(lsi) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
2105                 snprintf(tmpname, tmpname_sz, "MGS");
2106
2107         /* disconnect the osp-on-ost first to drain off the inflight request */
2108         if (IS_OST(lsi) || IS_MDT(lsi)) {
2109                 if (lustre_disconnect_osp(sb) < 0)
2110                         CERROR("%s: Fail to disconnect osp-on-ost!\n", tmpname);
2111         }
2112
2113         /* Stop the target */
2114         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
2115             (IS_MDT(lsi) || IS_OST(lsi))) {
2116                 struct lustre_profile *lprof = NULL;
2117
2118                 /* tell the mgc to drop the config log */
2119                 lustre_end_log(sb, lsi->lsi_svname, NULL);
2120
2121                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
2122                    If there are any setup/cleanup errors, save the lov
2123                    name for safety cleanup later. */
2124                 lprof = class_get_profile(lsi->lsi_svname);
2125                 if (lprof && lprof->lp_dt) {
2126                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
2127                         strcpy(extraname, lprof->lp_dt);
2128                 }
2129
2130                 obd = class_name2obd(lsi->lsi_svname);
2131                 if (obd) {
2132                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
2133                         if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
2134                                 obd->obd_fail = 1;
2135                         /* We can't seem to give an error return code
2136                          * to .put_super, so we better make sure we clean up! */
2137                         obd->obd_force = 1;
2138                         class_manual_cleanup(obd);
2139                 } else {
2140                         CERROR("no obd %s\n", lsi->lsi_svname);
2141                         server_deregister_mount(lsi->lsi_svname);
2142                 }
2143         }
2144
2145         /* If they wanted the mgs to stop separately from the mdt, they
2146            should have put it on a different device. */
2147         if (IS_MGS(lsi)) {
2148                 /* if MDS start with --nomgs, don't stop MGS then */
2149                 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
2150                         server_stop_mgs(sb);
2151         }
2152
2153         if (IS_OST(lsi) || IS_MDT(lsi)) {
2154                 if (lustre_stop_osp(sb) < 0)
2155                         CERROR("%s: Fail to stop osp-on-ost!\n", tmpname);
2156         }
2157
2158         /* Clean the mgc and sb */
2159         lustre_common_put_super(sb);
2160
2161         /* wait till all in-progress cleanups are done
2162          * specifically we're interested in ofd cleanup
2163          * as it pins OSS */
2164         obd_zombie_barrier();
2165
2166         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
2167            until the target is really gone so that our type refcount check
2168            is right. */
2169         server_stop_servers(lsiflags);
2170
2171         /* In case of startup or cleanup err, stop related obds */
2172         if (extraname) {
2173                 obd = class_name2obd(extraname);
2174                 if (obd) {
2175                         CWARN("Cleaning orphaned obd %s\n", extraname);
2176                         obd->obd_force = 1;
2177                         class_manual_cleanup(obd);
2178                 }
2179                 OBD_FREE(extraname, strlen(extraname) + 1);
2180         }
2181
2182         LCONSOLE_WARN("server umount %s complete\n", tmpname);
2183         OBD_FREE(tmpname, tmpname_sz);
2184         EXIT;
2185 }
2186
2187 /** Called only for 'umount -f'
2188  */
2189 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
2190 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
2191 {
2192         struct super_block *sb = vfsmnt->mnt_sb;
2193 #else
2194 static void server_umount_begin(struct super_block *sb)
2195 {
2196 #endif
2197         struct lustre_sb_info *lsi = s2lsi(sb);
2198         ENTRY;
2199
2200 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
2201         if (!(flags & MNT_FORCE)) {
2202                 EXIT;
2203                 return;
2204         }
2205 #endif
2206
2207         CDEBUG(D_MOUNT, "umount -f\n");
2208         /* umount = failover
2209            umount -f = force
2210            no third way to do non-force, non-failover */
2211         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
2212         EXIT;
2213 }
2214
2215 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
2216 {
2217         struct super_block *sb = dentry->d_sb;
2218         struct lustre_sb_info *lsi = s2lsi(sb);
2219         struct obd_statfs statfs;
2220         int rc;
2221         ENTRY;
2222
2223         if (lsi->lsi_dt_dev) {
2224                 rc = dt_statfs(NULL, lsi->lsi_dt_dev, &statfs);
2225                 if (rc == 0) {
2226                         statfs_unpack(buf, &statfs);
2227                         buf->f_type = sb->s_magic;
2228                         RETURN(0);
2229                 }
2230         }
2231
2232         /* just return 0 */
2233         buf->f_type = sb->s_magic;
2234         buf->f_bsize = sb->s_blocksize;
2235         buf->f_blocks = 1;
2236         buf->f_bfree = 0;
2237         buf->f_bavail = 0;
2238         buf->f_files = 1;
2239         buf->f_ffree = 0;
2240         buf->f_namelen = NAME_MAX;
2241         RETURN(0);
2242 }
2243
2244 /** The operations we support directly on the superblock:
2245  * mount, umount, and df.
2246  */
2247 static struct super_operations server_ops =
2248 {
2249         .put_super      = server_put_super,
2250         .umount_begin   = server_umount_begin, /* umount -f */
2251         .statfs         = server_statfs,
2252 };
2253
2254 #define log2(n) cfs_ffz(~(n))
2255 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
2256
2257 static int server_fill_super_common(struct super_block *sb)
2258 {
2259         struct inode *root = 0;
2260         ENTRY;
2261
2262         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
2263
2264         sb->s_blocksize = 4096;
2265         sb->s_blocksize_bits = log2(sb->s_blocksize);
2266         sb->s_magic = LUSTRE_SUPER_MAGIC;
2267         sb->s_maxbytes = 0; /* we don't allow file IO on server mountpoints */
2268         sb->s_flags |= MS_RDONLY;
2269         sb->s_op = &server_ops;
2270
2271         root = new_inode(sb);
2272         if (!root) {
2273                 CERROR("Can't make root inode\n");
2274                 RETURN(-EIO);
2275         }
2276
2277         /* returns -EIO for every operation */
2278         /* make_bad_inode(root); -- badness - can't umount */
2279         /* apparently we need to be a directory for the mount to finish */
2280         root->i_mode = S_IFDIR;
2281
2282         sb->s_root = d_alloc_root(root);
2283         if (!sb->s_root) {
2284                 CERROR("Can't make root dentry\n");
2285                 iput(root);
2286                 RETURN(-EIO);
2287         }
2288
2289         RETURN(0);
2290 }
2291
2292 static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags)
2293 {
2294         struct lustre_mount_data *lmd = lsi->lsi_lmd;
2295         struct obd_device        *obd;
2296         struct dt_device_param    p;
2297         char                      flagstr[16];
2298         int                       rc;
2299         ENTRY;
2300
2301         CDEBUG(D_MOUNT,
2302                "Attempting to start %s, type=%s, lsifl=%x, mountfl=%lx\n",
2303                lsi->lsi_svname, lsi->lsi_osd_type, lsi->lsi_flags, mflags);
2304
2305         sprintf(lsi->lsi_osd_obdname, "%s-osd", lsi->lsi_svname);
2306         strcpy(lsi->lsi_osd_uuid, lsi->lsi_osd_obdname);
2307         strcat(lsi->lsi_osd_uuid, "_UUID");
2308         sprintf(flagstr, "%lu:%lu", mflags, (unsigned long) lmd->lmd_flags);
2309
2310         obd = class_name2obd(lsi->lsi_osd_obdname);
2311         if (obd == NULL) {
2312                 rc = lustre_start_simple(lsi->lsi_osd_obdname,
2313                                 lsi->lsi_osd_type,
2314                                 lsi->lsi_osd_uuid, lmd->lmd_dev,
2315                                 flagstr, lsi->lsi_lmd->lmd_opts,
2316                                 lsi->lsi_svname);
2317                 if (rc)
2318                         GOTO(out, rc);
2319                 obd = class_name2obd(lsi->lsi_osd_obdname);
2320                 LASSERT(obd);
2321         }
2322
2323         rc = obd_connect(NULL, &lsi->lsi_osd_exp, obd, &obd->obd_uuid, NULL, NULL);
2324         if (rc) {
2325                 obd->obd_force = 1;
2326                 class_manual_cleanup(obd);
2327                 lsi->lsi_dt_dev = NULL;
2328         }
2329
2330         /* XXX: to keep support old components relying on lsi_srv_mnt
2331          *      we get this info from OSD just started */
2332         LASSERT(obd->obd_lu_dev);
2333         lsi->lsi_dt_dev = lu2dt_dev(obd->obd_lu_dev);
2334         LASSERT(lsi->lsi_dt_dev);
2335
2336         dt_conf_get(NULL, lsi->lsi_dt_dev, &p);
2337
2338         lsi->lsi_srv_mnt = p.ddp_mnt;
2339
2340 out:
2341         RETURN(rc);
2342 }
2343
2344 /** Fill in the superblock info for a Lustre server.
2345  * Mount the device with the correct options.
2346  * Read the on-disk config file.
2347  * Start the services.
2348  */
2349 static int server_fill_super(struct super_block *sb)
2350 {
2351         struct lustre_sb_info *lsi = s2lsi(sb);
2352         int rc;
2353         ENTRY;
2354
2355         rc = lsi_prepare(lsi);
2356         if (rc)
2357                 RETURN(rc);
2358
2359         /* Start low level OSD */
2360         rc = osd_start(lsi, sb->s_flags);
2361         if (rc) {
2362                 CERROR("Unable to start osd on %s: %d\n",
2363                        lsi->lsi_lmd->lmd_dev, rc);
2364                 lustre_put_lsi(sb);
2365                 RETURN(rc);
2366         }
2367
2368         CDEBUG(D_MOUNT, "Found service %s on device %s\n",
2369                lsi->lsi_svname, lsi->lsi_lmd->lmd_dev);
2370
2371         if (class_name2obd(lsi->lsi_svname)) {
2372                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
2373                                    "running. Double-mount may have compromised"
2374                                    " the disk journal.\n",
2375                                    lsi->lsi_svname);
2376                 lustre_put_lsi(sb);
2377                 RETURN(-EALREADY);
2378         }
2379
2380         /* Start MGS before MGC */
2381         if (IS_MGS(lsi) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
2382                 rc = server_start_mgs(sb);
2383                 if (rc)
2384                         GOTO(out_mnt, rc);
2385         }
2386
2387         /* Start MGC before servers */
2388         rc = lustre_start_mgc(sb);
2389         if (rc)
2390                 GOTO(out_mnt, rc);
2391
2392         /* Set up all obd devices for service */
2393         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
2394                         (IS_OST(lsi) || IS_MDT(lsi))) {
2395                 rc = server_start_targets(sb, lsi->lsi_srv_mnt);
2396                 if (rc < 0) {
2397                         CERROR("Unable to start targets: %d\n", rc);
2398                         GOTO(out_mnt, rc);
2399                 }
2400         /* FIXME overmount client here,
2401            or can we just start a client log and client_fill_super on this sb?
2402            We need to make sure server_put_super gets called too - ll_put_super
2403            calls lustre_common_put_super; check there for LSI_SERVER flag,
2404            call s_p_s if so.
2405            Probably should start client from new thread so we can return.
2406            Client will not finish until all servers are connected.
2407            Note - MGS-only server does NOT get a client, since there is no
2408            lustre fs associated - the MGS is for all lustre fs's */
2409         }
2410
2411         rc = server_fill_super_common(sb);
2412         if (rc)
2413                 GOTO(out_mnt, rc);
2414
2415         RETURN(0);
2416 out_mnt:
2417         /* We jump here in case of failure while starting targets or MGS.
2418          * In this case we can't just put @mnt and have to do real cleanup
2419          * with stoping targets, etc. */
2420         server_put_super(sb);
2421         return rc;
2422 }
2423
2424 /*
2425  * Calculate timeout value for a target.
2426  */
2427 void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
2428 {
2429         struct lustre_mount_data *lmd;
2430         int soft = 0;
2431         int hard = 0;
2432         int factor = 0;
2433         bool has_ir = !!(lsi->lsi_flags & LDD_F_IR_CAPABLE);
2434         int min = OBD_RECOVERY_TIME_MIN;
2435
2436         LASSERT(IS_SERVER(lsi));
2437
2438         lmd = lsi->lsi_lmd;
2439         if (lmd) {
2440                 soft   = lmd->lmd_recovery_time_soft;
2441                 hard   = lmd->lmd_recovery_time_hard;
2442                 has_ir = has_ir && !(lmd->lmd_flags & LMD_FLG_NOIR);
2443                 obd->obd_no_ir = !has_ir;
2444         }
2445
2446         if (soft == 0)
2447                 soft = OBD_RECOVERY_TIME_SOFT;
2448         if (hard == 0)
2449                 hard = OBD_RECOVERY_TIME_HARD;
2450
2451         /* target may have ir_factor configured. */
2452         factor = OBD_IR_FACTOR_DEFAULT;
2453         if (obd->obd_recovery_ir_factor)
2454                 factor = obd->obd_recovery_ir_factor;
2455
2456         if (has_ir) {
2457                 int new_soft = soft;
2458                 int new_hard = hard;
2459
2460                 /* adjust timeout value by imperative recovery */
2461
2462                 new_soft = (soft * factor) / OBD_IR_FACTOR_MAX;
2463                 new_hard = (hard * factor) / OBD_IR_FACTOR_MAX;
2464
2465                 /* make sure the timeout is not too short */
2466                 new_soft = max(min, new_soft);
2467                 new_hard = max(new_soft, new_hard);
2468
2469                 LCONSOLE_INFO("%s: Imperative Recovery enabled, recovery "
2470                               "window shrunk from %d-%d down to %d-%d\n",
2471                               obd->obd_name, soft, hard, new_soft, new_hard);
2472
2473                 soft = new_soft;
2474                 hard = new_hard;
2475         }
2476
2477         /* we're done */
2478         obd->obd_recovery_timeout   = max(obd->obd_recovery_timeout, soft);
2479         obd->obd_recovery_time_hard = hard;
2480         obd->obd_recovery_ir_factor = factor;
2481 }
2482 EXPORT_SYMBOL(server_calc_timeout);
2483
2484 /*************** mount common betweeen server and client ***************/
2485
2486 /* Common umount */
2487 int lustre_common_put_super(struct super_block *sb)
2488 {
2489         int rc;
2490         ENTRY;
2491
2492         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
2493
2494         /* Drop a ref to the MGC */
2495         rc = lustre_stop_mgc(sb);
2496         if (rc && (rc != -ENOENT)) {
2497                 if (rc != -EBUSY) {
2498                         CERROR("Can't stop MGC: %d\n", rc);
2499                         RETURN(rc);
2500                 }
2501                 /* BUSY just means that there's some other obd that
2502                    needs the mgc.  Let him clean it up. */
2503                 CDEBUG(D_MOUNT, "MGC still in use\n");
2504         }
2505         /* Drop a ref to the mounted disk */
2506         lustre_put_lsi(sb);
2507         lu_types_stop();
2508         RETURN(rc);
2509 }
2510 EXPORT_SYMBOL(lustre_common_put_super);
2511
2512 static void lmd_print(struct lustre_mount_data *lmd)
2513 {
2514         int i;
2515
2516         PRINT_CMD(PRINT_MASK, "  mount data:\n");
2517         if (lmd_is_client(lmd))
2518                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
2519         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
2520         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
2521
2522         if (lmd->lmd_opts)
2523                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
2524
2525         if (lmd->lmd_recovery_time_soft)
2526                 PRINT_CMD(PRINT_MASK, "recovery time soft: %d\n",
2527                           lmd->lmd_recovery_time_soft);
2528
2529         if (lmd->lmd_recovery_time_hard)
2530                 PRINT_CMD(PRINT_MASK, "recovery time hard: %d\n",
2531                           lmd->lmd_recovery_time_hard);
2532
2533         for (i = 0; i < lmd->lmd_exclude_count; i++) {
2534                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
2535                           lmd->lmd_exclude[i]);
2536         }
2537 }
2538
2539 /* Is this server on the exclusion list */
2540 int lustre_check_exclusion(struct super_block *sb, char *svname)
2541 {
2542         struct lustre_sb_info *lsi = s2lsi(sb);
2543         struct lustre_mount_data *lmd = lsi->lsi_lmd;
2544         __u32 index;
2545         int i, rc;
2546         ENTRY;
2547
2548         rc = server_name2index(svname, &index, NULL);
2549         if (rc != LDD_F_SV_TYPE_OST)
2550                 /* Only exclude OSTs */
2551                 RETURN(0);
2552
2553         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
2554                index, lmd->lmd_exclude_count, lmd->lmd_dev);
2555
2556         for(i = 0; i < lmd->lmd_exclude_count; i++) {
2557                 if (index == lmd->lmd_exclude[i]) {
2558                         CWARN("Excluding %s (on exclusion list)\n", svname);
2559                         RETURN(1);
2560                 }
2561         }
2562         RETURN(0);
2563 }
2564
2565 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
2566 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
2567 {
2568         char *s1 = ptr, *s2;
2569         __u32 index, *exclude_list;
2570         int rc = 0, devmax;
2571         ENTRY;
2572
2573         /* The shortest an ost name can be is 8 chars: -OST0000.
2574            We don't actually know the fsname at this time, so in fact
2575            a user could specify any fsname. */
2576         devmax = strlen(ptr) / 8 + 1;
2577
2578         /* temp storage until we figure out how many we have */
2579         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
2580         if (!exclude_list)
2581                 RETURN(-ENOMEM);
2582
2583         /* we enter this fn pointing at the '=' */
2584         while (*s1 && *s1 != ' ' && *s1 != ',') {
2585                 s1++;
2586                 rc = server_name2index(s1, &index, &s2);
2587                 if (rc < 0) {
2588                         CERROR("Can't parse server name '%s'\n", s1);
2589                         break;
2590                 }
2591                 if (rc == LDD_F_SV_TYPE_OST)
2592                         exclude_list[lmd->lmd_exclude_count++] = index;
2593                 else
2594                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
2595                 s1 = s2;
2596                 /* now we are pointing at ':' (next exclude)
2597                    or ',' (end of excludes) */
2598                 if (lmd->lmd_exclude_count >= devmax)
2599                         break;
2600         }
2601         if (rc >= 0) /* non-err */
2602                 rc = 0;
2603
2604         if (lmd->lmd_exclude_count) {
2605                 /* permanent, freed in lustre_free_lsi */
2606                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
2607                           lmd->lmd_exclude_count);
2608                 if (lmd->lmd_exclude) {
2609                         memcpy(lmd->lmd_exclude, exclude_list,
2610                                sizeof(index) * lmd->lmd_exclude_count);
2611                 } else {
2612                         rc = -ENOMEM;
2613                         lmd->lmd_exclude_count = 0;
2614                 }
2615         }
2616         OBD_FREE(exclude_list, sizeof(index) * devmax);
2617         RETURN(rc);
2618 }
2619
2620 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
2621 {
2622         char   *tail;
2623         int     length;
2624
2625         if (lmd->lmd_mgssec != NULL) {
2626                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
2627                 lmd->lmd_mgssec = NULL;
2628         }
2629
2630         tail = strchr(ptr, ',');
2631         if (tail == NULL)
2632                 length = strlen(ptr);
2633         else
2634                 length = tail - ptr;
2635
2636         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
2637         if (lmd->lmd_mgssec == NULL)
2638                 return -ENOMEM;
2639
2640         memcpy(lmd->lmd_mgssec, ptr, length);
2641         lmd->lmd_mgssec[length] = '\0';
2642         return 0;
2643 }
2644
2645 static int lmd_parse_string(char **handle, char *ptr)
2646 {
2647         char   *tail;
2648         int     length;
2649
2650         if ((handle == NULL) || (ptr == NULL))
2651                 return -EINVAL;
2652
2653         if (*handle != NULL) {
2654                 OBD_FREE(*handle, strlen(*handle) + 1);
2655                 *handle = NULL;
2656         }
2657
2658         tail = strchr(ptr, ',');
2659         if (tail == NULL)
2660                 length = strlen(ptr);
2661         else
2662                 length = tail - ptr;
2663
2664         OBD_ALLOC(*handle, length + 1);
2665         if (*handle == NULL)
2666                 return -ENOMEM;
2667
2668         memcpy(*handle, ptr, length);
2669         (*handle)[length] = '\0';
2670
2671         return 0;
2672 }
2673
2674 /* Collect multiple values for mgsnid specifiers */
2675 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
2676 {
2677         lnet_nid_t nid;
2678         char *tail = *ptr;
2679         char *mgsnid;
2680         int   length;
2681         int   oldlen = 0;
2682
2683         /* Find end of nidlist */
2684         while (class_parse_nid_quiet(tail, &nid, &tail) == 0) {}
2685         length = tail - *ptr;
2686         if (length == 0) {
2687                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
2688                 return -EINVAL;
2689         }
2690
2691         if (lmd->lmd_mgs != NULL)
2692                 oldlen = strlen(lmd->lmd_mgs) + 1;
2693
2694         OBD_ALLOC(mgsnid, oldlen + length + 1);
2695         if (mgsnid == NULL)
2696                 return -ENOMEM;
2697
2698         if (lmd->lmd_mgs != NULL) {
2699                 /* Multiple mgsnid= are taken to mean failover locations */
2700                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
2701                 mgsnid[oldlen - 1] = ':';
2702                 OBD_FREE(lmd->lmd_mgs, oldlen);
2703         }
2704         memcpy(mgsnid + oldlen, *ptr, length);
2705         mgsnid[oldlen + length] = '\0';
2706         lmd->lmd_mgs = mgsnid;
2707         *ptr = tail;
2708
2709         return 0;
2710 }
2711
2712 /** Parse mount line options
2713  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
2714  * dev is passed as device=uml1:/lustre by mount.lustre
2715  */
2716 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
2717 {
2718         char *s1, *s2, *devname = NULL;
2719         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
2720         int rc = 0;
2721         ENTRY;
2722
2723         LASSERT(lmd);
2724         if (!options) {
2725                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
2726                                    "/sbin/mount.lustre is installed.\n");
2727                 RETURN(-EINVAL);
2728         }
2729
2730         /* Options should be a string - try to detect old lmd data */
2731         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
2732                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
2733                                    "/sbin/mount.lustre.  Please install "
2734                                    "version %s\n", LUSTRE_VERSION_STRING);
2735                 RETURN(-EINVAL);
2736         }
2737         lmd->lmd_magic = LMD_MAGIC;
2738
2739         OBD_ALLOC(lmd->lmd_params, 4096);
2740         if (lmd->lmd_params == NULL)
2741                 RETURN(-ENOMEM);
2742         lmd->lmd_params[0] = '\0';
2743
2744         /* Set default flags here */
2745
2746         s1 = options;
2747         while (*s1) {
2748                 int clear = 0;
2749                 int time_min = OBD_RECOVERY_TIME_MIN;
2750
2751                 /* Skip whitespace and extra commas */
2752                 while (*s1 == ' ' || *s1 == ',')
2753                         s1++;
2754
2755                 /* Client options are parsed in ll_options: eg. flock,
2756                    user_xattr, acl */
2757
2758                 /* Parse non-ldiskfs options here. Rather than modifying
2759                    ldiskfs, we just zero these out here */
2760                 if (strncmp(s1, "abort_recov", 11) == 0) {
2761                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
2762                         clear++;
2763                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
2764                         lmd->lmd_recovery_time_soft = max_t(int,
2765                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2766                         clear++;
2767                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
2768                         lmd->lmd_recovery_time_hard = max_t(int,
2769                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
2770                         clear++;
2771                 } else if (strncmp(s1, "noir", 4) == 0) {
2772                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
2773                         clear++;
2774                 } else if (strncmp(s1, "nosvc", 5) == 0) {
2775                         lmd->lmd_flags |= LMD_FLG_NOSVC;
2776                         clear++;
2777                 } else if (strncmp(s1, "nomgs", 5) == 0) {
2778                         lmd->lmd_flags |= LMD_FLG_NOMGS;
2779                         clear++;
2780                 } else if (strncmp(s1, "noscrub", 7) == 0) {
2781                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
2782                         clear++;
2783                 } else if (strncmp(s1, PARAM_MGSNODE,
2784                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
2785                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
2786                         /* Assume the next mount opt is the first
2787                            invalid nid we get to. */
2788                         rc = lmd_parse_mgs(lmd, &s2);
2789                         if (rc)
2790                                 goto invalid;
2791                         clear++;
2792                 } else if (strncmp(s1, "writeconf", 9) == 0) {
2793                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
2794                         clear++;
2795                 } else if (strncmp(s1, "virgin", 6) == 0) {
2796                         lmd->lmd_flags |= LMD_FLG_VIRGIN;
2797                         clear++;
2798                 } else if (strncmp(s1, "noprimnode", 10) == 0) {
2799                         lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
2800                         clear++;
2801                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
2802                         rc = lmd_parse_mgssec(lmd, s1 + 7);
2803                         if (rc)
2804                                 goto invalid;
2805                         clear++;
2806                 /* ost exclusion list */
2807                 } else if (strncmp(s1, "exclude=", 8) == 0) {
2808                         rc = lmd_make_exclusion(lmd, s1 + 7);
2809                         if (rc)
2810                                 goto invalid;
2811                         clear++;
2812                 } else if (strncmp(s1, "mgs", 3) == 0) {
2813                         /* We are an MGS */
2814                         lmd->lmd_flags |= LMD_FLG_MGS;
2815                         clear++;
2816                 } else if (strncmp(s1, "svname=", 7) == 0) {
2817                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
2818                         if (rc)
2819                                 goto invalid;
2820                         clear++;
2821                 } else if (strncmp(s1, "param=", 6) == 0) {
2822                         int length;
2823                         char *tail = strchr(s1 + 6, ',');
2824                         if (tail == NULL)
2825                                 length = strlen(s1);
2826                         else
2827                                 length = tail - s1;
2828                         length -= 6;
2829                         strncat(lmd->lmd_params, s1 + 6, length);
2830                         strcat(lmd->lmd_params, " ");
2831                         clear++;
2832                 } else if (strncmp(s1, "osd=", 4) == 0) {
2833                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
2834                         if (rc)
2835                                 goto invalid;
2836                         clear++;
2837                 }
2838                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
2839                    end of the options. */
2840                 else if (strncmp(s1, "device=", 7) == 0) {
2841                         devname = s1 + 7;
2842                         /* terminate options right before device.  device
2843                            must be the last one. */
2844                         *s1 = '\0';
2845                         break;
2846                 }
2847
2848                 /* Find next opt */
2849                 s2 = strchr(s1, ',');
2850                 if (s2 == NULL) {
2851                         if (clear)
2852                                 *s1 = '\0';
2853                         break;
2854                 }
2855                 s2++;
2856                 if (clear)
2857                         memmove(s1, s2, strlen(s2) + 1);
2858                 else
2859                         s1 = s2;
2860         }
2861
2862         if (!devname) {
2863                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
2864                                    "(need mount option 'device=...')\n");
2865                 goto invalid;
2866         }
2867
2868         s1 = strstr(devname, ":/");
2869         if (s1) {
2870                 ++s1;
2871                 lmd->lmd_flags |= LMD_FLG_CLIENT;
2872                 /* Remove leading /s from fsname */
2873                 while (*++s1 == '/') ;
2874                 /* Freed in lustre_free_lsi */
2875                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
2876                 if (!lmd->lmd_profile)
2877                         RETURN(-ENOMEM);
2878                 sprintf(lmd->lmd_profile, "%s-client", s1);
2879         }
2880
2881         /* Freed in lustre_free_lsi */
2882         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
2883         if (!lmd->lmd_dev)
2884                 RETURN(-ENOMEM);
2885         strcpy(lmd->lmd_dev, devname);
2886
2887         /* Save mount options */
2888         s1 = options + strlen(options) - 1;
2889         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
2890                 *s1-- = 0;
2891         if (*options != 0) {
2892                 /* Freed in lustre_free_lsi */
2893                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
2894                 if (!lmd->lmd_opts)
2895                         RETURN(-ENOMEM);
2896                 strcpy(lmd->lmd_opts, options);
2897         }
2898
2899         lmd_print(lmd);
2900         lmd->lmd_magic = LMD_MAGIC;
2901
2902         RETURN(rc);
2903
2904 invalid:
2905         CERROR("Bad mount options %s\n", options);
2906         RETURN(-EINVAL);
2907 }
2908
2909 struct lustre_mount_data2 {
2910         void *lmd2_data;
2911         struct vfsmount *lmd2_mnt;
2912 };
2913
2914 /** This is the entry point for the mount call into Lustre.
2915  * This is called when a server or client is mounted,
2916  * and this is where we start setting things up.
2917  * @param data Mount options (e.g. -o flock,abort_recov)
2918  */
2919 int lustre_fill_super(struct super_block *sb, void *data, int silent)
2920 {
2921         struct lustre_mount_data *lmd;
2922         struct lustre_mount_data2 *lmd2 = data;
2923         struct lustre_sb_info *lsi;
2924         int rc;
2925         ENTRY;
2926
2927         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
2928
2929         lsi = lustre_init_lsi(sb);
2930         if (!lsi)
2931                 RETURN(-ENOMEM);
2932         lmd = lsi->lsi_lmd;
2933
2934         /*
2935          * Disable lockdep during mount, because mount locking patterns are
2936          * `special'.
2937          */
2938         cfs_lockdep_off();
2939
2940         /*
2941          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
2942          */
2943         obd_zombie_barrier();
2944
2945         /* Figure out the lmd from the mount options */
2946         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
2947                 lustre_put_lsi(sb);
2948                 GOTO(out, rc = -EINVAL);
2949         }
2950
2951         if (lmd_is_client(lmd)) {
2952                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
2953                 if (!client_fill_super) {
2954                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
2955                                            "client mount! Is the 'lustre' "
2956                                            "module loaded?\n");
2957                         lustre_put_lsi(sb);
2958                         rc = -ENODEV;
2959                 } else {
2960                         rc = lustre_start_mgc(sb);
2961                         if (rc) {
2962                                 lustre_put_lsi(sb);
2963                                 GOTO(out, rc);
2964                         }
2965                         /* Connect and start */
2966                         /* (should always be ll_fill_super) */
2967                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
2968                         /* c_f_s will call lustre_common_put_super on failure */
2969                 }
2970         } else {
2971                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
2972                 rc = server_fill_super(sb);
2973                 /* s_f_s calls lustre_start_mgc after the mount because we need
2974                    the MGS nids which are stored on disk.  Plus, we may
2975                    need to start the MGS first. */
2976                 /* s_f_s will call server_put_super on failure */
2977         }
2978
2979         /* If error happens in fill_super() call, @lsi will be killed there.
2980          * This is why we do not put it here. */
2981         GOTO(out, rc);
2982 out:
2983         if (rc) {
2984                 CERROR("Unable to mount %s (%d)\n",
2985                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
2986         } else {
2987                 CDEBUG(D_SUPER, "Mount %s complete\n",
2988                        lmd->lmd_dev);
2989         }
2990         cfs_lockdep_on();
2991         return rc;
2992 }
2993
2994
2995 /* We can't call ll_fill_super by name because it lives in a module that
2996    must be loaded after this one. */
2997 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
2998                                                   struct vfsmount *mnt))
2999 {
3000         client_fill_super = cfs;
3001 }
3002 EXPORT_SYMBOL(lustre_register_client_fill_super);
3003
3004 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
3005 {
3006         kill_super_cb = cfs;
3007 }
3008 EXPORT_SYMBOL(lustre_register_kill_super_cb);
3009
3010 /***************** FS registration ******************/
3011 #ifdef HAVE_FSTYPE_MOUNT
3012 struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
3013                                 const char *devname, void *data)
3014 {
3015         struct lustre_mount_data2 lmd2 = { data, NULL };
3016
3017         return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
3018 }
3019 #else
3020 int lustre_get_sb(struct file_system_type *fs_type, int flags,
3021                   const char *devname, void * data, struct vfsmount *mnt)
3022 {
3023         struct lustre_mount_data2 lmd2 = { data, mnt };
3024
3025         return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
3026 }
3027 #endif
3028
3029 void lustre_kill_super(struct super_block *sb)
3030 {
3031         struct lustre_sb_info *lsi = s2lsi(sb);
3032
3033         if (kill_super_cb && lsi && !IS_SERVER(lsi))
3034                 (*kill_super_cb)(sb);
3035
3036         kill_anon_super(sb);
3037 }
3038
3039 /** Register the "lustre" fs type
3040  */
3041 struct file_system_type lustre_fs_type = {
3042         .owner        = THIS_MODULE,
3043         .name         = "lustre",
3044 #ifdef HAVE_FSTYPE_MOUNT
3045         .mount        = lustre_mount,
3046 #else
3047         .get_sb       = lustre_get_sb,
3048 #endif
3049         .kill_sb      = lustre_kill_super,
3050         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
3051 #ifdef FS_HAS_FIEMAP
3052                         FS_HAS_FIEMAP |
3053 #endif
3054                         LL_RENAME_DOES_D_MOVE,
3055 };
3056
3057 int lustre_register_fs(void)
3058 {
3059         return register_filesystem(&lustre_fs_type);
3060 }
3061
3062 int lustre_unregister_fs(void)
3063 {
3064         return unregister_filesystem(&lustre_fs_type);
3065 }
3066
3067 EXPORT_SYMBOL(server_mti_print);