X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Fobd_mount.c;h=2ca91e9a6b5d5b7f1ecf6a1168be6f28b850db0a;hb=e3c85d27cb4b3fc59181ed52b5090e812a1ab0ae;hp=fc23461910a925aa6262cb0c5726f84e60ab58dc;hpb=8ee22413bbcab1ac89758ac2dedbcfd696e75205;p=fs%2Flustre-release.git

diff --git a/lustre/obdclass/obd_mount.c b/lustre/obdclass/obd_mount.c
index fc23461..2ca91e9 100644
--- a/lustre/obdclass/obd_mount.c
+++ b/lustre/obdclass/obd_mount.c
@@ -55,6 +55,9 @@
 #include <lustre_log.h>
 #include <lustre_disk.h>
 #include <lustre_param.h>
+#ifdef HAVE_KERNEL_LOCKED
+#include <linux/smp_lock.h>
+#endif
 
 static int (*client_fill_super)(struct super_block *sb,
                                 struct vfsmount *mnt) = NULL;
@@ -90,7 +93,6 @@ static int server_register_mount(const char *name, struct super_block *sb,
         char *name_cp;
         ENTRY;
 
-        LASSERT(mnt);
         LASSERT(sb);
 
         OBD_ALLOC(lmi, sizeof(*lmi));
@@ -119,8 +121,7 @@ static int server_register_mount(const char *name, struct super_block *sb,
 
         cfs_mutex_unlock(&lustre_mount_info_lock);
 
-        CDEBUG(D_MOUNT, "reg_mnt %p from %s, vfscount=%d\n",
-               lmi->lmi_mnt, name, mnt_get_count(lmi->lmi_mnt));
+	CDEBUG(D_MOUNT, "reg_mnt %p from %s\n", lmi->lmi_mnt, name);
 
         RETURN(0);
 }
@@ -139,8 +140,7 @@ static int server_deregister_mount(const char *name)
                 RETURN(-ENOENT);
         }
 
-        CDEBUG(D_MOUNT, "dereg_mnt %p from %s, vfscount=%d\n",
-               lmi->lmi_mnt, name, mnt_get_count(lmi->lmi_mnt));
+	CDEBUG(D_MOUNT, "dereg_mnt %p from %s\n", lmi->lmi_mnt, name);
 
         OBD_FREE(lmi->lmi_name, strlen(lmi->lmi_name) + 1);
         cfs_list_del(&lmi->lmi_list_chain);
@@ -167,15 +167,15 @@ struct lustre_mount_info *server_get_mount(const char *name)
                 RETURN(NULL);
         }
         lsi = s2lsi(lmi->lmi_sb);
-        mntget(lmi->lmi_mnt);
+
         cfs_atomic_inc(&lsi->lsi_mounts);
 
-        CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d, vfscount=%d\n",
-               lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts),
-               mnt_get_count(lmi->lmi_mnt));
+	CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d\n", lmi->lmi_mnt,
+	       name, cfs_atomic_read(&lsi->lsi_mounts));
 
         RETURN(lmi);
 }
+EXPORT_SYMBOL(server_get_mount);
 
 /*
  * Used by mdt to get mount_info from obdname.
@@ -195,20 +195,7 @@ struct lustre_mount_info *server_get_mount_2(const char *name)
 
         RETURN(lmi);
 }
-
-static void unlock_mntput(struct vfsmount *mnt)
-{
-#if HAVE_KERNEL_LOCKED
-	/* for kernel < 2.6.37 */
-	if (kernel_locked()) {
-		unlock_kernel();
-		mntput(mnt);
-		lock_kernel();
-	}
-#else
-	mntput(mnt);
-#endif
-}
+EXPORT_SYMBOL(server_get_mount_2);
 
 static int lustre_put_lsi(struct super_block *sb);
 
@@ -217,12 +204,8 @@ int server_put_mount(const char *name, struct vfsmount *mnt)
 {
         struct lustre_mount_info *lmi;
         struct lustre_sb_info *lsi;
-        int count = mnt_get_count(mnt) - 1;
         ENTRY;
 
-        /* This might be the last one, can't deref after this */
-        unlock_mntput(mnt);
-
         cfs_mutex_lock(&lustre_mount_info_lock);
         lmi = server_find_mount(name);
         cfs_mutex_unlock(&lustre_mount_info_lock);
@@ -231,24 +214,20 @@ int server_put_mount(const char *name, struct vfsmount *mnt)
                 RETURN(-ENOENT);
         }
         lsi = s2lsi(lmi->lmi_sb);
-        LASSERT(lmi->lmi_mnt == mnt);
 
-        CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d, vfscount=%d\n",
-               lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts), count);
+	CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d\n",
+	       lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts));
 
-        if (lustre_put_lsi(lmi->lmi_sb)) {
-                CDEBUG(D_MOUNT, "Last put of mnt %p from %s, vfscount=%d\n",
-                       lmi->lmi_mnt, name, count);
-                /* last mount is the One True Mount */
-                if (count > 1)
-                        CERROR("%s: mount busy, vfscount=%d!\n", name, count);
-        }
+	if (lustre_put_lsi(lmi->lmi_sb))
+		CDEBUG(D_MOUNT, "Last put of mnt %p from %s\n",
+		       lmi->lmi_mnt, name);
 
         /* this obd should never need the mount again */
         server_deregister_mount(name);
 
         RETURN(0);
 }
+EXPORT_SYMBOL(server_put_mount);
 
 /* Corresponding to server_get_mount_2 */
 int server_put_mount_2(const char *name, struct vfsmount *mnt)
@@ -256,128 +235,7 @@ int server_put_mount_2(const char *name, struct vfsmount *mnt)
         ENTRY;
         RETURN(0);
 }
-
-/******* mount helper utilities *********/
-
-#if 0
-static void ldd_print(struct lustre_disk_data *ldd)
-{
-        PRINT_CMD(PRINT_MASK, "  disk data:\n");
-        PRINT_CMD(PRINT_MASK, "server:  %s\n", ldd->ldd_svname);
-        PRINT_CMD(PRINT_MASK, "uuid:    %s\n", (char *)ldd->ldd_uuid);
-        PRINT_CMD(PRINT_MASK, "fs:      %s\n", ldd->ldd_fsname);
-        PRINT_CMD(PRINT_MASK, "index:   %04x\n", ldd->ldd_svindex);
-        PRINT_CMD(PRINT_MASK, "config:  %d\n", ldd->ldd_config_ver);
-        PRINT_CMD(PRINT_MASK, "flags:   %#x\n", ldd->ldd_flags);
-        PRINT_CMD(PRINT_MASK, "diskfs:  %s\n", MT_STR(ldd));
-        PRINT_CMD(PRINT_MASK, "options: %s\n", ldd->ldd_mount_opts);
-        PRINT_CMD(PRINT_MASK, "params:  %s\n", ldd->ldd_params);
-        PRINT_CMD(PRINT_MASK, "comment: %s\n", ldd->ldd_userdata);
-}
-#endif
-
-static int ldd_parse(struct lvfs_run_ctxt *mount_ctxt,
-                     struct lustre_disk_data *ldd)
-{
-        struct lvfs_run_ctxt saved;
-        struct file *file;
-        loff_t off = 0;
-        unsigned long len;
-        int rc;
-        ENTRY;
-
-        push_ctxt(&saved, mount_ctxt, NULL);
-
-        file = filp_open(MOUNT_DATA_FILE, O_RDONLY, 0644);
-        if (IS_ERR(file)) {
-                rc = PTR_ERR(file);
-                CERROR("cannot open %s: rc = %d\n", MOUNT_DATA_FILE, rc);
-                GOTO(out, rc);
-        }
-
-        len = i_size_read(file->f_dentry->d_inode);
-        CDEBUG(D_MOUNT, "Have %s, size %lu\n", MOUNT_DATA_FILE, len);
-        if (len != sizeof(*ldd)) {
-                CERROR("disk data size does not match: see %lu expect %u\n",
-                       len, (int)sizeof(*ldd));
-                GOTO(out_close, rc = -EINVAL);
-        }
-
-        rc = lustre_fread(file, ldd, len, &off);
-        if (rc != len) {
-                CERROR("error reading %s: read %d of %lu\n",
-                       MOUNT_DATA_FILE, rc, len);
-                GOTO(out_close, rc = -EINVAL);
-        }
-        rc = 0;
-
-        if (ldd->ldd_magic != LDD_MAGIC) {
-                /* FIXME add swabbing support */
-                CERROR("Bad magic in %s: %x!=%x\n", MOUNT_DATA_FILE,
-                       ldd->ldd_magic, LDD_MAGIC);
-                GOTO(out_close, rc = -EINVAL);
-        }
-
-        if (ldd->ldd_feature_incompat & ~LDD_INCOMPAT_SUPP) {
-                CERROR("%s: unsupported incompat filesystem feature(s) %x\n",
-                       ldd->ldd_svname,
-                       ldd->ldd_feature_incompat & ~LDD_INCOMPAT_SUPP);
-                GOTO(out_close, rc = -EINVAL);
-        }
-        if (ldd->ldd_feature_rocompat & ~LDD_ROCOMPAT_SUPP) {
-                CERROR("%s: unsupported read-only filesystem feature(s) %x\n",
-                       ldd->ldd_svname,
-                       ldd->ldd_feature_rocompat & ~LDD_ROCOMPAT_SUPP);
-                /* Do something like remount filesystem read-only */
-                GOTO(out_close, rc = -EINVAL);
-        }
-
-out_close:
-        filp_close(file, 0);
-out:
-        pop_ctxt(&saved, mount_ctxt, NULL);
-        RETURN(rc);
-}
-
-static int ldd_write(struct lvfs_run_ctxt *mount_ctxt,
-                     struct lustre_disk_data *ldd)
-{
-        struct lvfs_run_ctxt saved;
-        struct file *file;
-        loff_t off = 0;
-        unsigned long len = sizeof(struct lustre_disk_data);
-        int rc = 0;
-        ENTRY;
-
-        LASSERT(ldd->ldd_magic == LDD_MAGIC);
-
-        ldd->ldd_config_ver++;
-
-        push_ctxt(&saved, mount_ctxt, NULL);
-
-        file = filp_open(MOUNT_DATA_FILE, O_RDWR|O_SYNC, 0644);
-        if (IS_ERR(file)) {
-                rc = PTR_ERR(file);
-                CERROR("cannot open %s: rc = %d\n", MOUNT_DATA_FILE, rc);
-                GOTO(out, rc);
-        }
-
-        rc = lustre_fwrite(file, ldd, len, &off);
-        if (rc != len) {
-                CERROR("error writing %s: read %d of %lu\n",
-                       MOUNT_DATA_FILE, rc, len);
-                GOTO(out_close, rc = -EINVAL);
-        }
-
-        rc = 0;
-
-out_close:
-        filp_close(file, 0);
-out:
-        pop_ctxt(&saved, mount_ctxt, NULL);
-        RETURN(rc);
-}
-
+EXPORT_SYMBOL(server_put_mount_2);
 
 /**************** config llog ********************/
 
@@ -440,6 +298,7 @@ int lustre_process_log(struct super_block *sb, char *logname,
         /* class_obd_list(); */
         RETURN(rc);
 }
+EXPORT_SYMBOL(lustre_process_log);
 
 /* Stop watching this config log for updates */
 int lustre_end_log(struct super_block *sb, char *logname,
@@ -465,6 +324,7 @@ int lustre_end_log(struct super_block *sb, char *logname,
         lustre_cfg_free(lcfg);
         RETURN(rc);
 }
+EXPORT_SYMBOL(lustre_end_log);
 
 /**************** obd start *******************/
 
@@ -497,27 +357,28 @@ int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
         lustre_cfg_free(lcfg);
         return(rc);
 }
+EXPORT_SYMBOL(do_lcfg);
 
 /** Call class_attach and class_setup.  These methods in turn call
  * obd type-specific methods.
  */
 static int lustre_start_simple(char *obdname, char *type, char *uuid,
-                               char *s1, char *s2)
+			       char *s1, char *s2, char *s3, char *s4)
 {
-        int rc;
-        CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
+	int rc;
+	CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
 
-        rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, 0, 0);
-        if (rc) {
-                CERROR("%s attach error %d\n", obdname, rc);
-                return(rc);
-        }
-        rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, 0, 0);
-        if (rc) {
-                CERROR("%s setup error %d\n", obdname, rc);
-                do_lcfg(obdname, 0, LCFG_DETACH, 0, 0, 0, 0);
-        }
-        return rc;
+	rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, 0, 0);
+	if (rc) {
+		CERROR("%s attach error %d\n", obdname, rc);
+		return(rc);
+	}
+	rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, s3, s4);
+	if (rc) {
+		CERROR("%s setup error %d\n", obdname, rc);
+		do_lcfg(obdname, 0, LCFG_DETACH, 0, 0, 0, 0);
+	}
+	return rc;
 }
 
 /* Set up a MGS to serve startup logs */
@@ -528,7 +389,6 @@ static int server_start_mgs(struct super_block *sb)
         struct lustre_mount_info *lmi;
         int    rc = 0;
         ENTRY;
-        LASSERT(mnt);
 
         /* It is impossible to have more than 1 MGS per node, since
            MGC wouldn't know which to connect to */
@@ -536,8 +396,7 @@ static int server_start_mgs(struct super_block *sb)
         if (lmi) {
                 lsi = s2lsi(lmi->lmi_sb);
                 LCONSOLE_ERROR_MSG(0x15d, "The MGS service was already started"
-                                   " from server %s\n",
-                                   lsi->lsi_ldd->ldd_svname);
+				   " from server\n");
                 RETURN(-EALREADY);
         }
 
@@ -547,7 +406,8 @@ static int server_start_mgs(struct super_block *sb)
 
         if (!rc) {
                 rc = lustre_start_simple(LUSTRE_MGS_OBDNAME, LUSTRE_MGS_NAME,
-                                         LUSTRE_MGS_OBDNAME, 0, 0);
+					 LUSTRE_MGS_OBDNAME, 0, 0,
+					 lsi->lsi_osd_obdname, 0);
                 /* Do NOT call server_deregister_mount() here. This leads to
                  * inability cleanup cleanly and free lsi and other stuff when
                  * mgs calls server_put_mount() in error handling case. -umka */
@@ -607,13 +467,13 @@ static int lustre_start_mgc(struct super_block *sb)
         LASSERT(lsi->lsi_lmd);
 
         /* Find the first non-lo MGS nid for our MGC name */
-        if (lsi->lsi_flags & LSI_SERVER) {
-                ptr = lsi->lsi_ldd->ldd_params;
-                /* Use mgsnode= nids */
-                if ((class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0) &&
-                    (class_parse_nid(ptr, &nid, &ptr) == 0)) {
-                        i++;
-                } else if (IS_MGS(lsi->lsi_ldd)) {
+	if (IS_SERVER(lsi)) {
+		/* mount -o mgsnode=nid */
+		ptr = lsi->lsi_lmd->lmd_mgs;
+		if (lsi->lsi_lmd->lmd_mgs &&
+		    (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
+			i++;
+		} else if (IS_MGS(lsi)) {
                         lnet_process_id_t id;
                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
@@ -689,7 +549,7 @@ static int lustre_start_mgc(struct super_block *sb)
                 recov_bk = 0;
                 /* If we are restarting the MGS, don't try to keep the MGC's
                    old connection, or registration will fail. */
-                if ((lsi->lsi_flags & LSI_SERVER) && IS_MGS(lsi->lsi_ldd)) {
+		if (IS_MGS(lsi)) {
                         CDEBUG(D_MOUNT, "New MGS with live MGC\n");
                         recov_bk = 1;
                 }
@@ -712,9 +572,9 @@ static int lustre_start_mgc(struct super_block *sb)
         /* Add the primary nids for the MGS */
         i = 0;
         sprintf(niduuid, "%s_%x", mgcname, i);
-        if (lsi->lsi_flags & LSI_SERVER) {
-                ptr = lsi->lsi_ldd->ldd_params;
-                if (IS_MGS(lsi->lsi_ldd)) {
+	if (IS_SERVER(lsi)) {
+		ptr = lsi->lsi_lmd->lmd_mgs;
+		if (IS_MGS(lsi)) {
                         /* Use local nids (including LO) */
                         lnet_process_id_t id;
                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
@@ -723,7 +583,11 @@ static int lustre_start_mgc(struct super_block *sb)
                         }
                 } else {
                         /* Use mgsnode= nids */
-                        if (class_find_param(ptr, PARAM_MGSNODE, &ptr) != 0) {
+			/* mount -o mgsnode=nid */
+			if (lsi->lsi_lmd->lmd_mgs) {
+				ptr = lsi->lsi_lmd->lmd_mgs;
+			} else if (class_find_param(ptr, PARAM_MGSNODE,
+						    &ptr) != 0) {
                                 CERROR("No MGS nids given.\n");
                                 GOTO(out_free, rc = -EINVAL);
                         }
@@ -759,19 +623,19 @@ static int lustre_start_mgc(struct super_block *sb)
         /* Start the MGC */
         rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
                                  (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
-                                 niduuid);
+				 niduuid, 0, 0);
         OBD_FREE_PTR(uuid);
         if (rc)
                 GOTO(out_free, rc);
 
         /* Add any failover MGS nids */
         i = 1;
-        while ((*ptr == ':' ||
-                class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0)) {
+	while (ptr && ((*ptr == ':' ||
+	       class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0))) {
                 /* New failover node */
                 sprintf(niduuid, "%s_%x", mgcname, i);
                 j = 0;
-                while (class_parse_nid(ptr, &nid, &ptr) == 0) {
+		while (class_parse_nid_quiet(ptr, &nid, &ptr) == 0) {
                         j++;
                         rc = do_lcfg(mgcname, nid,
                                      LCFG_ADD_UUID, niduuid, 0,0,0);
@@ -814,10 +678,17 @@ static int lustre_start_mgc(struct super_block *sb)
         if (rc)
                 /* nonfatal */
                 CWARN("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
-        /* We connect to the MGS at setup, and don't disconnect until cleanup */
-        data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_FID |
-                                  OBD_CONNECT_AT | OBD_CONNECT_FULL20   |
-                                  OBD_CONNECT_IMP_RECOV;
+
+	/* We connect to the MGS at setup, and don't disconnect until cleanup */
+	data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
+				  OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV;
+
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 2, 50, 0)
+	data->ocd_connect_flags |= OBD_CONNECT_MNE_SWAB;
+#else
+#warning "LU-1644: Remove old OBD_CONNECT_MNE_SWAB fixup and imp_need_mne_swab"
+#endif
+
         if (lmd_is_client(lsi->lsi_lmd) &&
             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
@@ -954,7 +825,7 @@ static int server_mgc_clear_fs(struct obd_device *mgc)
 CFS_DEFINE_MUTEX(server_start_lock);
 
 /* Stop MDS/OSS if nobody is using them */
-static int server_stop_servers(int lddflags, int lsiflags)
+static int server_stop_servers(int lsiflags)
 {
         struct obd_device *obd = NULL;
         struct obd_type *type = NULL;
@@ -965,13 +836,13 @@ static int server_stop_servers(int lddflags, int lsiflags)
 
         /* Either an MDT or an OST or neither  */
         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
-        if ((lddflags & LDD_F_SV_TYPE_MDT) &&
+	if ((lsiflags & LDD_F_SV_TYPE_MDT) &&
             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
                 /*FIXME pre-rename, should eventually be LUSTRE_MDT_NAME*/
                 type = class_search_type(LUSTRE_MDS_NAME);
         }
         /* if this was an OST, and there are no more OST's, clean up the OSS */
-        if ((lddflags & LDD_F_SV_TYPE_OST) &&
+	if ((lsiflags & LDD_F_SV_TYPE_OST) &&
             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
                 type = class_search_type(LUSTRE_OST_NAME);
         }
@@ -1001,21 +872,110 @@ int server_mti_print(char *title, struct mgs_target_info *mti)
         return(0);
 }
 
-static int server_sb2mti(struct super_block *sb, struct mgs_target_info *mti)
+/** Get the fsname ("lustre") from the server name ("lustre-OST003F").
+ * @param [in] svname server name including type and index
+ * @param [out] fsname Buffer to copy filesystem name prefix into.
+ *  Must have at least 'strlen(fsname) + 1' chars.
+ * @param [out] endptr if endptr isn't NULL it is set to end of fsname
+ * rc < 0  on error
+ */
+static int server_name2fsname(char *svname, char *fsname, char **endptr)
 {
-        struct lustre_sb_info    *lsi = s2lsi(sb);
-        struct lustre_disk_data  *ldd = lsi->lsi_ldd;
-        lnet_process_id_t         id;
-        int                       i = 0;
+	char *p;
+
+	p = strstr(svname, "-OST");
+	if (p == NULL)
+		p = strstr(svname, "-MDT");
+	if (p == NULL)
+		return -1;
+
+	if (fsname) {
+		strncpy(fsname, svname, p - svname);
+		fsname[p - svname] = '\0';
+	}
+
+	if (endptr != NULL)
+		*endptr = p;
+
+	return 0;
+}
+
+/**
+ * Get service name (svname) from string
+ * rc < 0 on error
+ * if endptr isn't NULL it is set to end of fsname *
+ */
+int server_name2svname(char *label, char *svname, char **endptr)
+{
+	int rc;
+	char *dash;
+
+	/* We use server_name2fsname() just for parsing */
+	rc = server_name2fsname(label, NULL, &dash);
+	if (rc != 0)
+		return rc;
+
+	if (*dash != '-')
+		return -1;
+
+	strncpy(svname, dash + 1, MTI_NAME_MAXLEN);
+
+	return 0;
+}
+EXPORT_SYMBOL(server_name2svname);
+
+
+/* Get the index from the obd name.
+   rc = server type, or
+   rc < 0  on error
+   if endptr isn't NULL it is set to end of name */
+int server_name2index(char *svname, __u32 *idx, char **endptr)
+{
+	unsigned long index;
+	int rc;
+	char *dash;
+
+	/* We use server_name2fsname() just for parsing */
+	rc = server_name2fsname(svname, NULL, &dash);
+	if (rc != 0)
+		return rc;
+
+	if (*dash != '-')
+		return -EINVAL;
+
+	dash++;
+
+	if (strncmp(dash, "MDT", 3) == 0)
+		rc = LDD_F_SV_TYPE_MDT;
+	else if (strncmp(dash, "OST", 3) == 0)
+		rc = LDD_F_SV_TYPE_OST;
+	else
+		return -EINVAL;
+
+	dash += 3;
+
+	if (strcmp(dash, "all") == 0)
+		return rc | LDD_F_SV_ALL;
+
+	index = simple_strtoul(dash, endptr, 16);
+	*idx = index;
+
+	return rc;
+}
+EXPORT_SYMBOL(server_name2index);
+
+/* Generate data for registration */
+static int server_lsi2mti(struct lustre_sb_info *lsi,
+			  struct mgs_target_info *mti)
+{
+	lnet_process_id_t id;
+	int rc, i = 0;
         ENTRY;
 
-        if (!(lsi->lsi_flags & LSI_SERVER))
+	if (!IS_SERVER(lsi))
                 RETURN(-EINVAL);
 
-        strncpy(mti->mti_fsname, ldd->ldd_fsname,
-                sizeof(mti->mti_fsname));
-        strncpy(mti->mti_svname, ldd->ldd_svname,
-                sizeof(mti->mti_svname));
+	strncpy(mti->mti_svname, lsi->lsi_svname, sizeof(mti->mti_svname));
 
         mti->mti_nid_count = 0;
         while (LNetGetId(i++, &id) != -ENOENT) {
@@ -1024,13 +984,13 @@ static int server_sb2mti(struct super_block *sb, struct mgs_target_info *mti)
 
                 /* server use --servicenode param, only allow specified
                  * nids be registered */
-                if ((ldd->ldd_flags & LDD_F_NO_PRIMNODE) != 0 &&
-                    class_match_nid(ldd->ldd_params,
+		if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) != 0 &&
+		    class_match_nid(lsi->lsi_lmd->lmd_params,
                                     PARAM_FAILNODE, id.nid) < 1)
                         continue;
 
                 /* match specified network */
-                if (!class_match_net(ldd->ldd_params,
+		if (!class_match_net(lsi->lsi_lmd->lmd_params,
                                      PARAM_NETWORK, LNET_NIDNET(id.nid)))
                         continue;
 
@@ -1045,26 +1005,29 @@ static int server_sb2mti(struct super_block *sb, struct mgs_target_info *mti)
 
         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
         mti->mti_config_ver = 0;
-        if (lsi->lsi_lmd->lmd_flags & LMD_FLG_WRITECONF)
-                ldd->ldd_flags |= LDD_F_WRITECONF;
-        mti->mti_flags = ldd->ldd_flags;
-        mti->mti_stripe_index = ldd->ldd_svindex;
-        memcpy(mti->mti_uuid, ldd->ldd_uuid, sizeof(mti->mti_uuid));
-        if (strlen(ldd->ldd_params) > sizeof(mti->mti_params)) {
-                CERROR("params too big for mti\n");
-                RETURN(-ENOMEM);
-        }
-        memcpy(mti->mti_params, ldd->ldd_params, sizeof(mti->mti_params));
-        RETURN(0);
+
+	rc = server_name2fsname(lsi->lsi_svname, mti->mti_fsname, NULL);
+	if (rc != 0)
+		return rc;
+
+	rc = server_name2index(lsi->lsi_svname, &mti->mti_stripe_index, NULL);
+	if (rc < 0)
+		return rc;
+	/* Orion requires index to be set */
+	LASSERT(!(rc & LDD_F_NEED_INDEX));
+	/* keep only LDD flags */
+	mti->mti_flags = lsi->lsi_flags & LDD_F_MASK;
+	mti->mti_flags |= LDD_F_UPDATE;
+	strncpy(mti->mti_params, lsi->lsi_lmd->lmd_params,
+		sizeof(mti->mti_params));
+	return 0;
 }
 
 /* Register an old or new target with the MGS. If needed MGS will construct
    startup logs and assign index */
-int server_register_target(struct super_block *sb)
+static int server_register_target(struct lustre_sb_info *lsi)
 {
-        struct lustre_sb_info *lsi = s2lsi(sb);
         struct obd_device *mgc = lsi->lsi_mgc;
-        struct lustre_disk_data *ldd = lsi->lsi_ldd;
         struct mgs_target_info *mti = NULL;
         bool writeconf;
         int rc;
@@ -1072,13 +1035,14 @@ int server_register_target(struct super_block *sb)
 
         LASSERT(mgc);
 
-        if (!(lsi->lsi_flags & LSI_SERVER))
+	if (!IS_SERVER(lsi))
                 RETURN(-EINVAL);
 
         OBD_ALLOC_PTR(mti);
         if (!mti)
                 RETURN(-ENOMEM);
-        rc = server_sb2mti(sb, mti);
+
+	rc = server_lsi2mti(lsi, mti);
         if (rc)
                 GOTO(out, rc);
 
@@ -1088,7 +1052,7 @@ int server_register_target(struct super_block *sb)
                mti->mti_flags);
 
         /* if write_conf is true, the registration must succeed */
-        writeconf = !!(ldd->ldd_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE));
+	writeconf = !!(lsi->lsi_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE));
         mti->mti_flags |= LDD_F_OPC_REG;
 
         /* Register the target */
@@ -1101,7 +1065,7 @@ int server_register_target(struct super_block *sb)
                         LCONSOLE_ERROR_MSG(0x160,
                                 "The MGS is refusing to allow this "
                                 "server (%s) to start. Please see messages"
-                                " on the MGS node.\n", ldd->ldd_svname);
+				" on the MGS node.\n", lsi->lsi_svname);
                 } else if (writeconf) {
                         LCONSOLE_ERROR_MSG(0x15f,
                                 "Communication to the MGS return error %d. "
@@ -1114,34 +1078,6 @@ int server_register_target(struct super_block *sb)
                 GOTO(out, rc);
         }
 
-        /* Always update our flags */
-        ldd->ldd_flags = mti->mti_flags & LDD_F_ONDISK_MASK;
-
-        /* If this flag is set, it means the MGS wants us to change our
-           on-disk data. (So far this means just the index.) */
-        if (mti->mti_flags & LDD_F_REWRITE_LDD) {
-                char *label;
-                int err;
-                CDEBUG(D_MOUNT, "Changing on-disk index from %#x to %#x "
-                       "for %s\n", ldd->ldd_svindex, mti->mti_stripe_index,
-                       mti->mti_svname);
-                ldd->ldd_svindex = mti->mti_stripe_index;
-                strncpy(ldd->ldd_svname, mti->mti_svname,
-                        sizeof(ldd->ldd_svname));
-                /* or ldd_make_sv_name(ldd); */
-                ldd_write(&mgc->obd_lvfs_ctxt, ldd);
-                err = fsfilt_set_label(mgc, lsi->lsi_srv_mnt->mnt_sb,
-                                       mti->mti_svname);
-                if (err)
-                        CERROR("Label set error %d\n", err);
-                label = fsfilt_get_label(mgc, lsi->lsi_srv_mnt->mnt_sb);
-                if (label)
-                        CDEBUG(D_MOUNT, "Disk label changed to %s\n", label);
-
-                /* Flush the new ldd to disk */
-                fsfilt_sync(mgc, lsi->lsi_srv_mnt->mnt_sb);
-        }
-
 out:
         if (mti)
                 OBD_FREE_PTR(mti);
@@ -1162,13 +1098,13 @@ static int server_notify_target(struct super_block *sb, struct obd_device *obd)
 
         LASSERT(mgc);
 
-        if (!(lsi->lsi_flags & LSI_SERVER))
+	if (!(IS_SERVER(lsi)))
                 RETURN(-EINVAL);
 
         OBD_ALLOC_PTR(mti);
         if (!mti)
                 RETURN(-ENOMEM);
-        rc = server_sb2mti(sb, mti);
+	rc = server_lsi2mti(lsi, mti);
         if (rc)
                 GOTO(out, rc);
 
@@ -1184,7 +1120,7 @@ static int server_notify_target(struct super_block *sb, struct obd_device *obd)
         /* Imperative recovery: if the mgs informs us to use IR? */
         if (!rc && !(mti->mti_flags & LDD_F_ERROR) &&
             (mti->mti_flags & LDD_F_IR_CAPABLE))
-                lsi->lsi_flags |= LSI_IR_CAPABLE;
+		lsi->lsi_flags |= LDD_F_IR_CAPABLE;
 
 out:
         if (mti)
@@ -1200,10 +1136,12 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
         struct obd_device *obd;
         struct lustre_sb_info *lsi = s2lsi(sb);
         struct config_llog_instance cfg;
+	struct lu_env env;
+	struct lu_device *dev;
         int rc;
         ENTRY;
 
-        CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_ldd->ldd_svname);
+	CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_svname);
 
 #if 0
         /* If we're an MDT, make sure the global MDS is running */
@@ -1228,7 +1166,7 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
 #endif
 
         /* If we're an OST, make sure the global OSS is running */
-        if (IS_OST(lsi->lsi_ldd)) {
+	if (IS_OST(lsi)) {
                 /* make sure OSS is started */
                 cfs_mutex_lock(&server_start_lock);
                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
@@ -1236,7 +1174,7 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
                                                  LUSTRE_OSS_NAME,
                                                  LUSTRE_OSS_OBDNAME"_uuid",
-                                                 0, 0);
+						 0, 0, 0, 0);
                         if (rc) {
                                 cfs_mutex_unlock(&server_start_lock);
                                 CERROR("failed to start OSS: %d\n", rc);
@@ -1248,51 +1186,48 @@ static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
 
         /* Set the mgc fs to our server disk.  This allows the MGC to
          * read and write configs locally, in case it can't talk to the MGS. */
-        rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
-        if (rc)
-                RETURN(rc);
+	if (lsi->lsi_srv_mnt) {
+		rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
+		if (rc)
+			RETURN(rc);
+	}
 
         /* Register with MGS */
-        rc = server_register_target(sb);
+	rc = server_register_target(lsi);
         if (rc)
                 GOTO(out_mgc, rc);
 
         /* Let the target look up the mount using the target's name
            (we can't pass the sb or mnt through class_process_config.) */
-        rc = server_register_mount(lsi->lsi_ldd->ldd_svname, sb, mnt);
+	rc = server_register_mount(lsi->lsi_svname, sb, mnt);
         if (rc)
                 GOTO(out_mgc, rc);
 
-        /* Start targets using the llog named for the target */
-        memset(&cfg, 0, sizeof(cfg));
-        rc = lustre_process_log(sb, lsi->lsi_ldd->ldd_svname, &cfg);
-        if (rc) {
-                CERROR("failed to start server %s: %d\n",
-                       lsi->lsi_ldd->ldd_svname, rc);
-                /* Do NOT call server_deregister_mount() here. This makes it
-                 * impossible to find mount later in cleanup time and leaves
-                 * @lsi and othder stuff leaked. -umka */
-                GOTO(out_mgc, rc);
-        }
+	/* Start targets using the llog named for the target */
+	memset(&cfg, 0, sizeof(cfg));
+	rc = lustre_process_log(sb, lsi->lsi_svname, &cfg);
+	if (rc) {
+		CERROR("failed to start server %s: %d\n",
+		       lsi->lsi_svname, rc);
+		/* Do NOT call server_deregister_mount() here. This makes it
+		 * impossible to find mount later in cleanup time and leaves
+		 * @lsi and othder stuff leaked. -umka */
+		GOTO(out_mgc, rc);
+	}
 
 out_mgc:
         /* Release the mgc fs for others to use */
-        server_mgc_clear_fs(lsi->lsi_mgc);
+	if (lsi->lsi_srv_mnt)
+		server_mgc_clear_fs(lsi->lsi_mgc);
 
         if (!rc) {
-                obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
+		obd = class_name2obd(lsi->lsi_svname);
                 if (!obd) {
                         CERROR("no server named %s was started\n",
-                               lsi->lsi_ldd->ldd_svname);
+			       lsi->lsi_svname);
                         RETURN(-ENXIO);
                 }
 
-                if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
-                    (OBP(obd, iocontrol))) {
-                        obd_iocontrol(OBD_IOC_ABORT_RECOVERY,
-                                      obd->obd_self_export, 0, NULL, NULL);
-                }
-
                 server_notify_target(sb, obd);
 
                 /* calculate recovery timeout, do it after lustre_process_log */
@@ -1300,6 +1235,34 @@ out_mgc:
 
                 /* log has been fully processed */
                 obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
+
+		/* log has been fully processed, let clients connect */
+		dev = obd->obd_lu_dev;
+		if (dev && dev->ld_ops->ldo_prepare) {
+			rc = lu_env_init(&env, dev->ld_type->ldt_ctx_tags);
+			if (rc == 0) {
+				struct lu_context  session_ctx;
+
+				lu_context_init(&session_ctx, LCT_SESSION);
+				session_ctx.lc_thread = NULL;
+				lu_context_enter(&session_ctx);
+				env.le_ses = &session_ctx;
+
+				dev->ld_ops->ldo_prepare(&env, NULL, dev);
+
+				lu_env_fini(&env);
+				lu_context_exit(&session_ctx);
+				lu_context_fini(&session_ctx);
+			}
+		}
+
+		/* abort recovery only on the complete stack:
+		 * many devices can be involved */
+		if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
+		    (OBP(obd, iocontrol))) {
+			obd_iocontrol(OBD_IOC_ABORT_RECOVERY,
+				      obd->obd_self_export, 0, NULL, NULL);
+		}
         }
 
         RETURN(rc);
@@ -1345,9 +1308,6 @@ static int lustre_free_lsi(struct super_block *sb)
         /* someone didn't call server_put_mount. */
         LASSERT(cfs_atomic_read(&lsi->lsi_mounts) == 0);
 
-        if (lsi->lsi_ldd != NULL)
-                OBD_FREE(lsi->lsi_ldd, sizeof(*lsi->lsi_ldd));
-
         if (lsi->lsi_lmd != NULL) {
                 if (lsi->lsi_lmd->lmd_dev != NULL)
                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
@@ -1365,6 +1325,15 @@ static int lustre_free_lsi(struct super_block *sb)
                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
                                  lsi->lsi_lmd->lmd_exclude_count);
+		if (lsi->lsi_lmd->lmd_mgs != NULL)
+			OBD_FREE(lsi->lsi_lmd->lmd_mgs,
+				 strlen(lsi->lsi_lmd->lmd_mgs) + 1);
+		if (lsi->lsi_lmd->lmd_osd_type != NULL)
+			OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
+				 strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
+		if (lsi->lsi_lmd->lmd_params != NULL)
+			OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
+
                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
         }
 
@@ -1386,176 +1355,89 @@ static int lustre_put_lsi(struct super_block *sb)
 
         CDEBUG(D_MOUNT, "put %p %d\n", sb, cfs_atomic_read(&lsi->lsi_mounts));
         if (cfs_atomic_dec_and_test(&lsi->lsi_mounts)) {
+		if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
+			obd_disconnect(lsi->lsi_osd_exp);
+			/* wait till OSD is gone */
+			obd_zombie_barrier();
+		}
                 lustre_free_lsi(sb);
                 RETURN(1);
         }
         RETURN(0);
 }
 
-/*************** server mount ******************/
-
-/** Kernel mount using mount options in MOUNT_DATA_FILE.
- * Since this file lives on the disk, we pre-mount using a common
- * type, read the file, then re-mount using the type specified in the
- * file.
- */
-static struct vfsmount *server_kernel_mount(struct super_block *sb)
+static int lsi_prepare(struct lustre_sb_info *lsi)
 {
-        struct lvfs_run_ctxt mount_ctxt;
-        struct lustre_sb_info *lsi = s2lsi(sb);
-        struct lustre_disk_data *ldd;
-        struct lustre_mount_data *lmd = lsi->lsi_lmd;
-        struct vfsmount *mnt;
-        struct file_system_type *type;
-        char *options = NULL;
-        unsigned long page, s_flags;
-        struct page *__page;
-        int len;
-        int rc;
-        ENTRY;
-
-        OBD_ALLOC(ldd, sizeof(*ldd));
-        if (!ldd)
-                RETURN(ERR_PTR(-ENOMEM));
-
-        /* In the past, we have always used flags = 0.
-           Note ext3/ldiskfs can't be mounted ro. */
-        s_flags = sb->s_flags;
-
-        /* allocate memory for options */
-        OBD_PAGE_ALLOC(__page, CFS_ALLOC_STD);
-        if (!__page)
-                GOTO(out_free, rc = -ENOMEM);
-        page = (unsigned long)cfs_page_address(__page);
-        options = (char *)page;
-        memset(options, 0, CFS_PAGE_SIZE);
-
-        /* mount-line options must be added for pre-mount because it may
-         * contain mount options such as journal_dev which are required
-         * to mount successfuly the underlying filesystem */
-        if (lmd->lmd_opts && (*(lmd->lmd_opts) != 0))
-                strncat(options, lmd->lmd_opts, CFS_PAGE_SIZE - 1);
-
-        /* Pre-mount ldiskfs to read the MOUNT_DATA_FILE */
-        CDEBUG(D_MOUNT, "Pre-mount ldiskfs %s\n", lmd->lmd_dev);
-        type = get_fs_type("ldiskfs");
-        if (!type) {
-                CERROR("premount failed: cannot find ldiskfs module\n");
-                GOTO(out_free, rc = -ENODEV);
-        }
-        mnt = vfs_kern_mount(type, s_flags, lmd->lmd_dev, (void *)options);
-        cfs_module_put(type->owner);
-        if (IS_ERR(mnt)) {
-                rc = PTR_ERR(mnt);
-                CERROR("premount %s:%#lx ldiskfs failed: %d "
-                        "Is the ldiskfs module available?\n",
-                        lmd->lmd_dev, s_flags, rc );
-                GOTO(out_free, rc);
-        }
-
-        OBD_SET_CTXT_MAGIC(&mount_ctxt);
-        mount_ctxt.pwdmnt = mnt;
-        mount_ctxt.pwd = mnt->mnt_root;
-        mount_ctxt.fs = get_ds();
-
-        rc = ldd_parse(&mount_ctxt, ldd);
-        unlock_mntput(mnt);
-
-        if (rc) {
-                CERROR("premount parse options failed: rc = %d\n", rc);
-                GOTO(out_free, rc);
-        }
-
-        /* Done with our pre-mount, now do the real mount. */
+	__u32 index;
+	int rc;
+	ENTRY;
 
-        /* Glom up mount options */
-        memset(options, 0, CFS_PAGE_SIZE);
-        strncpy(options, ldd->ldd_mount_opts, CFS_PAGE_SIZE - 2);
+	LASSERT(lsi);
+	LASSERT(lsi->lsi_lmd);
 
-        len = CFS_PAGE_SIZE - strlen(options) - 2;
-        if (*options != 0)
-                strcat(options, ",");
-        strncat(options, "no_mbcache", len);
+	/* The server name is given as a mount line option */
+	if (lsi->lsi_lmd->lmd_profile == NULL) {
+		LCONSOLE_ERROR("Can't determine server name\n");
+		RETURN(-EINVAL);
+	}
 
-        /* Add in any mount-line options */
-        if (lmd->lmd_opts && (*(lmd->lmd_opts) != 0)) {
-                len = CFS_PAGE_SIZE - strlen(options) - 2;
-                strcat(options, ",");
-                strncat(options, lmd->lmd_opts, len);
-        }
+	if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname))
+		RETURN(-ENAMETOOLONG);
 
-        /* Special permanent mount flags */
-        if (IS_OST(ldd))
-            s_flags |= MS_NOATIME | MS_NODIRATIME;
+	strcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile);
 
-        CDEBUG(D_MOUNT, "kern_mount: %s %s %s\n",
-               MT_STR(ldd), lmd->lmd_dev, options);
-        type = get_fs_type(MT_STR(ldd));
-        if (!type) {
-                CERROR("get_fs_type failed\n");
-                GOTO(out_free, rc = -ENODEV);
-        }
-        mnt = vfs_kern_mount(type, s_flags, lmd->lmd_dev, (void *)options);
-        cfs_module_put(type->owner);
-        if (IS_ERR(mnt)) {
-                rc = PTR_ERR(mnt);
-                CERROR("vfs_kern_mount failed: rc = %d\n", rc);
-                GOTO(out_free, rc);
-        }
+	/* Determine osd type */
+	if (lsi->lsi_lmd->lmd_osd_type != NULL) {
+		if (strlen(lsi->lsi_lmd->lmd_osd_type) >=
+			   sizeof(lsi->lsi_osd_type))
+			RETURN(-ENAMETOOLONG);
 
-        if (lmd->lmd_flags & LMD_FLG_ABORT_RECOV)
-                simple_truncate(mnt->mnt_sb->s_root, mnt, LAST_RCVD,
-                                LR_CLIENT_START);
+		strcpy(lsi->lsi_osd_type, lsi->lsi_lmd->lmd_osd_type);
+	} else {
+		strcpy(lsi->lsi_osd_type, LUSTRE_OSD_LDISKFS_NAME);
+	}
 
-        OBD_PAGE_FREE(__page);
-        lsi->lsi_ldd = ldd;   /* freed at lsi cleanup */
-        CDEBUG(D_SUPER, "%s: mnt = %p\n", lmd->lmd_dev, mnt);
-        RETURN(mnt);
+	/* XXX: a temp. solution for components using fsfilt
+	 *      to be removed in one of the subsequent patches */
+	if (!strcmp(lsi->lsi_lmd->lmd_osd_type, "osd-ldiskfs")) {
+		strcpy(lsi->lsi_fstype, "ldiskfs");
+	} else {
+		strcpy(lsi->lsi_fstype, lsi->lsi_lmd->lmd_osd_type);
+	}
 
-out_free:
-        if (__page)
-                OBD_PAGE_FREE(__page);
-        OBD_FREE(ldd, sizeof(*ldd));
-        lsi->lsi_ldd = NULL;
-        RETURN(ERR_PTR(rc));
+	/* Determine server type */
+	rc = server_name2index(lsi->lsi_svname, &index, NULL);
+	if (rc < 0) {
+		if (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) {
+			/* Assume we're a bare MGS */
+			rc = 0;
+			lsi->lsi_lmd->lmd_flags |= LMD_FLG_NOSVC;
+		} else {
+			LCONSOLE_ERROR("Can't determine server type of '%s'\n",
+				       lsi->lsi_svname);
+			RETURN(rc);
+		}
+	}
+	lsi->lsi_flags |= rc;
+
+	/* Add mount line flags that used to be in ldd:
+	 * writeconf, mgs, iam, anything else?
+	 */
+	lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_WRITECONF) ?
+		LDD_F_WRITECONF : 0;
+	lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_VIRGIN) ?
+		LDD_F_VIRGIN : 0;
+	lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) ?
+		LDD_F_SV_TYPE_MGS : 0;
+	lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_IAM) ?
+		LDD_F_IAM_DIR : 0;
+	lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) ?
+		LDD_F_NO_PRIMNODE : 0;
+
+	RETURN(0);
 }
 
-/** Wait here forever until the mount refcount is 0 before completing umount,
- * else we risk dereferencing a null pointer.
- * LNET may take e.g. 165s before killing zombies.
- */
-static void server_wait_finished(struct vfsmount *mnt)
-{
-       cfs_waitq_t             waitq;
-       int                     rc, waited = 0;
-       cfs_sigset_t            blocked;
-
-       cfs_waitq_init(&waitq);
-
-       while (mnt_get_count(mnt) > 1) {
-               if (waited && (waited % 30 == 0))
-                       LCONSOLE_WARN("Mount still busy with %d refs after "
-                                      "%d secs.\n",
-                                      mnt_get_count(mnt),
-                                      waited);
-               /* Cannot use l_event_wait() for an interruptible sleep. */
-               waited += 3;
-               blocked = cfs_block_sigsinv(sigmask(SIGKILL));
-               cfs_waitq_wait_event_interruptible_timeout(
-                       waitq,
-                       (mnt_get_count(mnt) == 1),
-                       cfs_time_seconds(3),
-                       rc);
-               cfs_block_sigs(blocked);
-               if (rc < 0) {
-                       LCONSOLE_EMERG("Danger: interrupted umount %s with "
-                                      "%d refs!\n", mnt->mnt_devname,
-                                      mnt_get_count(mnt));
-                       break;
-               }
-
-       }
-}
+/*************** server mount ******************/
 
 /** Start the shutdown of servers at umount.
  */
@@ -1563,40 +1445,38 @@ static void server_put_super(struct super_block *sb)
 {
         struct lustre_sb_info *lsi = s2lsi(sb);
         struct obd_device     *obd;
-        struct vfsmount       *mnt = lsi->lsi_srv_mnt;
         char *tmpname, *extraname = NULL;
         int tmpname_sz;
-        int lddflags = lsi->lsi_ldd->ldd_flags;
         int lsiflags = lsi->lsi_flags;
         ENTRY;
 
-        LASSERT(lsiflags & LSI_SERVER);
+	LASSERT(IS_SERVER(lsi));
 
-        tmpname_sz = strlen(lsi->lsi_ldd->ldd_svname) + 1;
+	tmpname_sz = strlen(lsi->lsi_svname) + 1;
         OBD_ALLOC(tmpname, tmpname_sz);
-        memcpy(tmpname, lsi->lsi_ldd->ldd_svname, tmpname_sz);
+	memcpy(tmpname, lsi->lsi_svname, tmpname_sz);
         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
-        if (IS_MDT(lsi->lsi_ldd) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
+	if (IS_MDT(lsi) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
                 snprintf(tmpname, tmpname_sz, "MGS");
 
         /* Stop the target */
         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
-            (IS_MDT(lsi->lsi_ldd) || IS_OST(lsi->lsi_ldd))) {
+	    (IS_MDT(lsi) || IS_OST(lsi))) {
                 struct lustre_profile *lprof = NULL;
 
                 /* tell the mgc to drop the config log */
-                lustre_end_log(sb, lsi->lsi_ldd->ldd_svname, NULL);
+		lustre_end_log(sb, lsi->lsi_svname, NULL);
 
                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
                    If there are any setup/cleanup errors, save the lov
                    name for safety cleanup later. */
-                lprof = class_get_profile(lsi->lsi_ldd->ldd_svname);
+		lprof = class_get_profile(lsi->lsi_svname);
                 if (lprof && lprof->lp_dt) {
                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
                         strcpy(extraname, lprof->lp_dt);
                 }
 
-                obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
+		obd = class_name2obd(lsi->lsi_svname);
                 if (obd) {
                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
                         if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
@@ -1606,52 +1486,35 @@ static void server_put_super(struct super_block *sb)
                         obd->obd_force = 1;
                         class_manual_cleanup(obd);
                 } else {
-                        CERROR("no obd %s\n", lsi->lsi_ldd->ldd_svname);
-                        server_deregister_mount(lsi->lsi_ldd->ldd_svname);
+			CERROR("no obd %s\n", lsi->lsi_svname);
+			server_deregister_mount(lsi->lsi_svname);
                 }
         }
 
         /* If they wanted the mgs to stop separately from the mdt, they
            should have put it on a different device. */
-        if (IS_MGS(lsi->lsi_ldd)) {
+	if (IS_MGS(lsi)) {
                 /* if MDS start with --nomgs, don't stop MGS then */
-                if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)) {
-                        char *logname;
-
-                        OBD_ALLOC(logname, MGS_PARAM_MAXLEN);
-                        if (!logname) {
-                                LCONSOLE_WARN("Stopping mgs failed %d, please "
-                                              "try again.", -ENOMEM);
-                                return;
-                        }
-                        strcpy(logname, lsi->lsi_ldd->ldd_fsname);
-                        strcat(logname, "-params");
-                        /* tell the mgc to drop parameter config log */
-                        lustre_end_log(sb, logname, NULL);
-                        OBD_FREE(logname, MGS_PARAM_MAXLEN);
-
+                if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
                         server_stop_mgs(sb);
-                }
         }
 
         /* Clean the mgc and sb */
         lustre_common_put_super(sb);
 
-        /* Wait for the targets to really clean up - can't exit (and let the
-           sb get destroyed) while the mount is still in use */
-        server_wait_finished(mnt);
+	/* wait till all in-progress cleanups are done
+	 * specifically we're interested in ofd cleanup
+	 * as it pins OSS */
+	obd_zombie_barrier();
 
-        /* drop the One True Mount */
-        unlock_mntput(mnt);
+	/* Stop the servers (MDS, OSS) if no longer needed.  We must wait
+	   until the target is really gone so that our type refcount check
+	   is right. */
+	server_stop_servers(lsiflags);
 
-        /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
-           until the target is really gone so that our type refcount check
-           is right. */
-        server_stop_servers(lddflags, lsiflags);
-
-        /* In case of startup or cleanup err, stop related obds */
-        if (extraname) {
-                obd = class_name2obd(extraname);
+	/* In case of startup or cleanup err, stop related obds */
+	if (extraname) {
+		obd = class_name2obd(extraname);
                 if (obd) {
                         CWARN("Cleaning orphaned obd %s\n", extraname);
                         obd->obd_force = 1;
@@ -1690,43 +1553,36 @@ static void server_umount_begin(struct super_block *sb)
            umount -f = force
            no third way to do non-force, non-failover */
         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
-        lsi->lsi_flags |= LSI_UMOUNT_FORCE;
         EXIT;
 }
 
-#ifndef HAVE_STATFS_DENTRY_PARAM
-static int server_statfs (struct super_block *sb, cfs_kstatfs_t *buf)
-{
-#else
 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
 {
-        struct super_block *sb = dentry->d_sb;
-#endif
-        struct vfsmount *mnt = s2lsi(sb)->lsi_srv_mnt;
-        ENTRY;
-
-        if (mnt && mnt->mnt_sb && mnt->mnt_sb->s_op->statfs) {
-#ifdef HAVE_STATFS_DENTRY_PARAM
-                int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_root, buf);
-#else
-                int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_sb, buf);
-#endif
-                if (!rc) {
-                        buf->f_type = sb->s_magic;
-                        RETURN(0);
-                }
-        }
+	struct super_block *sb = dentry->d_sb;
+	struct lustre_sb_info *lsi = s2lsi(sb);
+	struct obd_statfs statfs;
+	int rc;
+	ENTRY;
+
+	if (lsi->lsi_dt_dev) {
+		rc = dt_statfs(NULL, lsi->lsi_dt_dev, &statfs);
+		if (rc == 0) {
+			statfs_unpack(buf, &statfs);
+			buf->f_type = sb->s_magic;
+			RETURN(0);
+		}
+	}
 
-        /* just return 0 */
-        buf->f_type = sb->s_magic;
-        buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = 1;
-        buf->f_bfree = 0;
-        buf->f_bavail = 0;
-        buf->f_files = 1;
-        buf->f_ffree = 0;
-        buf->f_namelen = NAME_MAX;
-        RETURN(0);
+	/* just return 0 */
+	buf->f_type = sb->s_magic;
+	buf->f_bsize = sb->s_blocksize;
+	buf->f_blocks = 1;
+	buf->f_bfree = 0;
+	buf->f_bavail = 0;
+	buf->f_files = 1;
+	buf->f_ffree = 0;
+	buf->f_namelen = NAME_MAX;
+	RETURN(0);
 }
 
 /** The operations we support directly on the superblock:
@@ -1777,6 +1633,58 @@ static int server_fill_super_common(struct super_block *sb)
         RETURN(0);
 }
 
+static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags)
+{
+	struct lustre_mount_data *lmd = lsi->lsi_lmd;
+	struct obd_device	 *obd;
+	struct dt_device_param    p;
+	char			  flagstr[16];
+	int			  rc;
+	ENTRY;
+
+	CDEBUG(D_MOUNT,
+	       "Attempting to start %s, type=%s, lsifl=%x, mountfl=%lx\n",
+	       lsi->lsi_svname, lsi->lsi_osd_type, lsi->lsi_flags, mflags);
+
+	sprintf(lsi->lsi_osd_obdname, "%s-osd", lsi->lsi_svname);
+	strcpy(lsi->lsi_osd_uuid, lsi->lsi_osd_obdname);
+	strcat(lsi->lsi_osd_uuid, "_UUID");
+	sprintf(flagstr, "%lu:%lu", mflags, (unsigned long) lmd->lmd_flags);
+
+	obd = class_name2obd(lsi->lsi_osd_obdname);
+	if (obd == NULL) {
+		rc = lustre_start_simple(lsi->lsi_osd_obdname,
+				lsi->lsi_osd_type,
+				lsi->lsi_osd_uuid, lmd->lmd_dev,
+				flagstr, lsi->lsi_lmd->lmd_opts,
+				lsi->lsi_svname);
+		if (rc)
+			GOTO(out, rc);
+		obd = class_name2obd(lsi->lsi_osd_obdname);
+		LASSERT(obd);
+	}
+
+	rc = obd_connect(NULL, &lsi->lsi_osd_exp, obd, &obd->obd_uuid, NULL, NULL);
+	if (rc) {
+		obd->obd_force = 1;
+		class_manual_cleanup(obd);
+		lsi->lsi_dt_dev = NULL;
+	}
+
+	/* XXX: to keep support old components relying on lsi_srv_mnt
+	 *	we get this info from OSD just started */
+	LASSERT(obd->obd_lu_dev);
+	lsi->lsi_dt_dev = lu2dt_dev(obd->obd_lu_dev);
+	LASSERT(lsi->lsi_dt_dev);
+
+	dt_conf_get(NULL, lsi->lsi_dt_dev, &p);
+
+	lsi->lsi_srv_mnt = p.ddp_mnt;
+
+out:
+	RETURN(rc);
+}
+
 /** Fill in the superblock info for a Lustre server.
  * Mount the device with the correct options.
  * Read the on-disk config file.
@@ -1785,38 +1693,36 @@ static int server_fill_super_common(struct super_block *sb)
 static int server_fill_super(struct super_block *sb)
 {
         struct lustre_sb_info *lsi = s2lsi(sb);
-        struct vfsmount *mnt;
         int rc;
         ENTRY;
 
-        /* the One True Mount */
-        mnt = server_kernel_mount(sb);
-        if (IS_ERR(mnt)) {
-                rc = PTR_ERR(mnt);
-                CERROR("Unable to mount device %s: %d\n",
-                       lsi->lsi_lmd->lmd_dev, rc);
+	rc = lsi_prepare(lsi);
+	if (rc)
+		RETURN(rc);
+
+	/* Start low level OSD */
+	rc = osd_start(lsi, sb->s_flags);
+	if (rc) {
+		CERROR("Unable to start osd on %s: %d\n",
+		       lsi->lsi_lmd->lmd_dev, rc);
                 lustre_put_lsi(sb);
                 RETURN(rc);
-        }
-        lsi->lsi_srv_mnt = mnt;
+	}
 
-        LASSERT(lsi->lsi_ldd);
-        CDEBUG(D_MOUNT, "Found service %s for fs '%s' on device %s\n",
-               lsi->lsi_ldd->ldd_svname, lsi->lsi_ldd->ldd_fsname,
-               lsi->lsi_lmd->lmd_dev);
+	CDEBUG(D_MOUNT, "Found service %s on device %s\n",
+	       lsi->lsi_svname, lsi->lsi_lmd->lmd_dev);
 
-        if (class_name2obd(lsi->lsi_ldd->ldd_svname)) {
+	if (class_name2obd(lsi->lsi_svname)) {
                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
                                    "running. Double-mount may have compromised"
                                    " the disk journal.\n",
-                                   lsi->lsi_ldd->ldd_svname);
+				   lsi->lsi_svname);
                 lustre_put_lsi(sb);
-                unlock_mntput(mnt);
                 RETURN(-EALREADY);
         }
 
         /* Start MGS before MGC */
-        if (IS_MGS(lsi->lsi_ldd) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
+	if (IS_MGS(lsi) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
                 rc = server_start_mgs(sb);
                 if (rc)
                         GOTO(out_mnt, rc);
@@ -1829,8 +1735,8 @@ static int server_fill_super(struct super_block *sb)
 
         /* Set up all obd devices for service */
         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
-                (IS_OST(lsi->lsi_ldd) || IS_MDT(lsi->lsi_ldd))) {
-                rc = server_start_targets(sb, mnt);
+			(IS_OST(lsi) || IS_MDT(lsi))) {
+		rc = server_start_targets(sb, lsi->lsi_srv_mnt);
                 if (rc < 0) {
                         CERROR("Unable to start targets: %d\n", rc);
                         GOTO(out_mnt, rc);
@@ -1844,25 +1750,6 @@ static int server_fill_super(struct super_block *sb)
            Client will not finish until all servers are connected.
            Note - MGS-only server does NOT get a client, since there is no
            lustre fs associated - the MGS is for all lustre fs's */
-        } else if (IS_MGS(lsi->lsi_ldd) &&
-                   !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
-                struct config_llog_instance cfg;
-                char *logname;
-
-                OBD_ALLOC(logname, MGS_PARAM_MAXLEN);
-                if (logname == NULL)
-                        GOTO(out_mnt, rc = -ENOMEM);
-                strcpy(logname, lsi->lsi_ldd->ldd_fsname);
-                strcat(logname, "-params");
-
-                memset(&cfg, 0, sizeof(cfg));
-                rc = lustre_process_log(sb, logname, &cfg);
-                OBD_FREE(logname, MGS_PARAM_MAXLEN);
-                if (rc) {
-                        CERROR("failed to process parameters %s: %d\n",
-                               logname, rc);
-                        GOTO(out_mnt, rc);
-                }
         }
 
         rc = server_fill_super_common(sb);
@@ -1878,41 +1765,6 @@ out_mnt:
         return rc;
 }
 
-/* Get the index from the obd name.
-   rc = server type, or
-   rc < 0  on error
-   if endptr isn't NULL it is set to end of name */
-int server_name2index(char *svname, __u32 *idx, char **endptr)
-{
-        unsigned long index;
-        int rc;
-        char *dash = strrchr(svname, '-');
-        if (!dash)
-                return(-EINVAL);
-
-        /* intepret <fsname>-MDTXXXXX-mdc as mdt, the better way is to pass
-         * in the fsname, then determine the server index */
-        if (!strcmp(LUSTRE_MDC_NAME, dash + 1)) {
-                dash--;
-                for (; dash > svname && *dash != '-'; dash--);
-                if (dash == svname)
-                        return(-EINVAL);
-        }
-
-        if (strncmp(dash + 1, "MDT", 3) == 0)
-                rc = LDD_F_SV_TYPE_MDT;
-        else if (strncmp(dash + 1, "OST", 3) == 0)
-                rc = LDD_F_SV_TYPE_OST;
-        else
-                return(-EINVAL);
-        if (strcmp(dash + 4, "all") == 0)
-                return rc | LDD_F_SV_ALL;
-
-        index = simple_strtoul(dash + 4, endptr, 16);
-        *idx = index;
-        return rc;
-}
-
 /*
  * Calculate timeout value for a target.
  */
@@ -1922,10 +1774,10 @@ void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
         int soft = 0;
         int hard = 0;
         int factor = 0;
-        bool has_ir = !!(lsi->lsi_flags & LSI_IR_CAPABLE);
+	bool has_ir = !!(lsi->lsi_flags & LDD_F_IR_CAPABLE);
         int min = OBD_RECOVERY_TIME_MIN;
 
-        LASSERT(lsi->lsi_flags & LSI_SERVER);
+	LASSERT(IS_SERVER(lsi));
 
         lmd = lsi->lsi_lmd;
         if (lmd) {
@@ -1999,6 +1851,7 @@ int lustre_common_put_super(struct super_block *sb)
         lu_types_stop();
         RETURN(rc);
 }
+EXPORT_SYMBOL(lustre_common_put_super);
 
 static void lmd_print(struct lustre_mount_data *lmd)
 {
@@ -2133,6 +1986,73 @@ static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
         return 0;
 }
 
+static int lmd_parse_string(char **handle, char *ptr)
+{
+	char   *tail;
+	int     length;
+
+	if ((handle == NULL) || (ptr == NULL))
+		return -EINVAL;
+
+	if (*handle != NULL) {
+		OBD_FREE(*handle, strlen(*handle) + 1);
+		*handle = NULL;
+	}
+
+	tail = strchr(ptr, ',');
+	if (tail == NULL)
+		length = strlen(ptr);
+	else
+		length = tail - ptr;
+
+	OBD_ALLOC(*handle, length + 1);
+	if (*handle == NULL)
+		return -ENOMEM;
+
+	memcpy(*handle, ptr, length);
+	(*handle)[length] = '\0';
+
+	return 0;
+}
+
+/* Collect multiple values for mgsnid specifiers */
+static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
+{
+	lnet_nid_t nid;
+	char *tail = *ptr;
+	char *mgsnid;
+	int   length;
+	int   oldlen = 0;
+
+	/* Find end of nidlist */
+	while (class_parse_nid_quiet(tail, &nid, &tail) == 0) {}
+	length = tail - *ptr;
+	if (length == 0) {
+		LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
+		return -EINVAL;
+	}
+
+	if (lmd->lmd_mgs != NULL)
+		oldlen = strlen(lmd->lmd_mgs) + 1;
+
+	OBD_ALLOC(mgsnid, oldlen + length + 1);
+	if (mgsnid == NULL)
+		return -ENOMEM;
+
+	if (lmd->lmd_mgs != NULL) {
+		/* Multiple mgsnid= are taken to mean failover locations */
+		memcpy(mgsnid, lmd->lmd_mgs, oldlen);
+		mgsnid[oldlen - 1] = ':';
+		OBD_FREE(lmd->lmd_mgs, oldlen);
+	}
+	memcpy(mgsnid + oldlen, *ptr, length);
+	mgsnid[oldlen + length] = '\0';
+	lmd->lmd_mgs = mgsnid;
+	*ptr = tail;
+
+	return 0;
+}
+
 /** Parse mount line options
  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
  * dev is passed as device=uml1:/lustre by mount.lustre
@@ -2160,6 +2080,11 @@ static int lmd_parse(char *options, struct lustre_mount_data *lmd)
         }
         lmd->lmd_magic = LMD_MAGIC;
 
+	OBD_ALLOC(lmd->lmd_params, 4096);
+	if (lmd->lmd_params == NULL)
+		RETURN(-ENOMEM);
+	lmd->lmd_params[0] = '\0';
+
         /* Set default flags here */
 
         s1 = options;
@@ -2196,9 +2121,27 @@ static int lmd_parse(char *options, struct lustre_mount_data *lmd)
                 } else if (strncmp(s1, "nomgs", 5) == 0) {
                         lmd->lmd_flags |= LMD_FLG_NOMGS;
                         clear++;
+		} else if (strncmp(s1, "noscrub", 7) == 0) {
+			lmd->lmd_flags |= LMD_FLG_NOSCRUB;
+			clear++;
+		} else if (strncmp(s1, PARAM_MGSNODE,
+				   sizeof(PARAM_MGSNODE) - 1) == 0) {
+			s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
+			/* Assume the next mount opt is the first
+			   invalid nid we get to. */
+			rc = lmd_parse_mgs(lmd, &s2);
+			if (rc)
+				goto invalid;
+			clear++;
                 } else if (strncmp(s1, "writeconf", 9) == 0) {
                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
                         clear++;
+		} else if (strncmp(s1, "virgin", 6) == 0) {
+			lmd->lmd_flags |= LMD_FLG_VIRGIN;
+			clear++;
+		} else if (strncmp(s1, "noprimnode", 10) == 0) {
+			lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
+			clear++;
                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
                         rc = lmd_parse_mgssec(lmd, s1 + 7);
                         if (rc)
@@ -2210,6 +2153,31 @@ static int lmd_parse(char *options, struct lustre_mount_data *lmd)
                         if (rc)
                                 goto invalid;
                         clear++;
+		} else if (strncmp(s1, "mgs", 3) == 0) {
+			/* We are an MGS */
+			lmd->lmd_flags |= LMD_FLG_MGS;
+			clear++;
+		} else if (strncmp(s1, "svname=", 7) == 0) {
+			rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
+			if (rc)
+				goto invalid;
+			clear++;
+		} else if (strncmp(s1, "param=", 6) == 0) {
+			int length;
+			char *tail = strchr(s1 + 6, ',');
+			if (tail == NULL)
+				length = strlen(s1);
+			else
+				length = tail - s1;
+			length -= 6;
+			strncat(lmd->lmd_params, s1 + 6, length);
+			strcat(lmd->lmd_params, " ");
+			clear++;
+		} else if (strncmp(s1, "osd=", 4) == 0) {
+			rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
+			if (rc)
+				goto invalid;
+			clear++;
                 }
                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
                    end of the options. */
@@ -2345,7 +2313,6 @@ int lustre_fill_super(struct super_block *sb, void *data, int silent)
                 }
         } else {
                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
-                lsi->lsi_flags |= LSI_SERVER;
                 rc = server_fill_super(sb);
                 /* s_f_s calls lustre_start_mgc after the mount because we need
                    the MGS nids which are stored on disk.  Plus, we may
@@ -2376,27 +2343,30 @@ void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
 {
         client_fill_super = cfs;
 }
+EXPORT_SYMBOL(lustre_register_client_fill_super);
 
 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
 {
         kill_super_cb = cfs;
 }
+EXPORT_SYMBOL(lustre_register_kill_super_cb);
 
 /***************** FS registration ******************/
-
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
-struct super_block * lustre_get_sb(struct file_system_type *fs_type, int flags,
-                                   const char *devname, void * data)
+#ifdef HAVE_FSTYPE_MOUNT
+struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
+				const char *devname, void *data)
 {
-        return get_sb_nodev(fs_type, flags, data, lustre_fill_super);
+	struct lustre_mount_data2 lmd2 = { data, NULL };
+
+	return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
 }
 #else
 int lustre_get_sb(struct file_system_type *fs_type, int flags,
                   const char *devname, void * data, struct vfsmount *mnt)
 {
-        struct lustre_mount_data2 lmd2 = {data, mnt};
+	struct lustre_mount_data2 lmd2 = { data, mnt };
 
-        return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
+	return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
 }
 #endif
 
@@ -2404,7 +2374,7 @@ void lustre_kill_super(struct super_block *sb)
 {
         struct lustre_sb_info *lsi = s2lsi(sb);
 
-        if (kill_super_cb && lsi && !(lsi->lsi_flags & LSI_SERVER))
+	if (kill_super_cb && lsi && !IS_SERVER(lsi))
                 (*kill_super_cb)(sb);
 
         kill_anon_super(sb);
@@ -2415,7 +2385,11 @@ void lustre_kill_super(struct super_block *sb)
 struct file_system_type lustre_fs_type = {
         .owner        = THIS_MODULE,
         .name         = "lustre",
+#ifdef HAVE_FSTYPE_MOUNT
+	.mount        = lustre_mount,
+#else
         .get_sb       = lustre_get_sb,
+#endif
         .kill_sb      = lustre_kill_super,
         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
 #ifdef FS_HAS_FIEMAP
@@ -2434,16 +2408,4 @@ int lustre_unregister_fs(void)
         return unregister_filesystem(&lustre_fs_type);
 }
 
-EXPORT_SYMBOL(lustre_register_client_fill_super);
-EXPORT_SYMBOL(lustre_register_kill_super_cb);
-EXPORT_SYMBOL(lustre_common_put_super);
-EXPORT_SYMBOL(lustre_process_log);
-EXPORT_SYMBOL(lustre_end_log);
-EXPORT_SYMBOL(server_get_mount);
-EXPORT_SYMBOL(server_get_mount_2);
-EXPORT_SYMBOL(server_put_mount);
-EXPORT_SYMBOL(server_put_mount_2);
-EXPORT_SYMBOL(server_register_target);
-EXPORT_SYMBOL(server_name2index);
 EXPORT_SYMBOL(server_mti_print);
-EXPORT_SYMBOL(do_lcfg);