X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fofd%2Fofd_dev.c;h=843abca369bcf40976ae12fd2260151c7ec74ea1;hp=7495453948aea2845b7dd4a7df5fd5c44e925d90;hb=3cce65712d94cffe8f1626545845b95b88aef672;hpb=711eff3a50003b5c617955bae50fba7bfcb9c43d

diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c
index 7495453..843abca 100644
--- a/lustre/ofd/ofd_dev.c
+++ b/lustre/ofd/ofd_dev.c
@@ -82,7 +82,6 @@
 
 /* Slab for OFD object allocation */
 static struct kmem_cache *ofd_object_kmem;
-
 static struct lu_kmem_descr ofd_caches[] = {
 	{
 		.ckd_cache = &ofd_object_kmem,
@@ -320,13 +319,7 @@ static bool match_symlink_param(char *param)
 		sval = strchr(param, '=');
 		if (sval != NULL) {
 			paramlen = sval - param;
-			if (strncmp(param, "writethrough_cache_enable",
-				    paramlen) == 0 ||
-			    strncmp(param, "readcache_max_filesize",
-				    paramlen) == 0 ||
-			    strncmp(param, "read_cache_enable",
-				    paramlen) == 0 ||
-			    strncmp(param, "brw_stats", paramlen) == 0)
+			if (strncmp(param, "brw_stats", paramlen) == 0)
 				return true;
 		}
 	}
@@ -359,11 +352,11 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d,
 
 	switch (cfg->lcfg_command) {
 	case LCFG_PARAM: {
-		struct obd_device	*obd = ofd_obd(m);
 		/* For interoperability */
-		struct cfg_interop_param   *ptr = NULL;
-		struct lustre_cfg	   *old_cfg = NULL;
-		char			   *param = NULL;
+		struct cfg_interop_param *ptr = NULL;
+		struct lustre_cfg *old_cfg = NULL;
+		char *param = NULL;
+		ssize_t count;
 
 		param = lustre_cfg_string(cfg, 1);
 		if (param == NULL) {
@@ -397,14 +390,16 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d,
 			break;
 		}
 
-		rc = class_process_proc_param(PARAM_OST, obd->obd_vars, cfg,
-					      d->ld_obd);
-		if (rc > 0 || rc == -ENOSYS) {
-			CDEBUG(D_CONFIG, "pass param %s down the stack.\n",
-			       param);
-			/* we don't understand; pass it on */
-			rc = next->ld_ops->ldo_process_config(env, next, cfg);
+		count = class_modify_config(cfg, PARAM_OST,
+					    &d->ld_obd->obd_kset.kobj);
+		if (count > 0) {
+			rc = 0;
+			break;
 		}
+		CDEBUG(D_CONFIG, "pass param %s down the stack.\n",
+		       param);
+		/* we don't understand; pass it on */
+		rc = next->ld_ops->ldo_process_config(env, next, cfg);
 		break;
 	}
 	case LCFG_SPTLRPC_CONF: {
@@ -638,6 +633,8 @@ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev,
 	LASSERTF(rc == 0, "register namespace failed: rc = %d\n", rc);
 
 	target_recovery_init(&ofd->ofd_lut, tgt_request_handle);
+	OBD_FAIL_TIMEOUT_ORSET(OBD_FAIL_OST_PREPARE_DELAY, OBD_FAIL_ONCE,
+			       (OBD_TIMEOUT_DEFAULT + 1) / 4);
 	LASSERT(obd->obd_no_conn);
 	spin_lock(&obd->obd_dev_lock);
 	obd->obd_no_conn = 0;
@@ -699,73 +696,7 @@ static struct lu_device_operations ofd_lu_ops = {
 	.ldo_prepare		= ofd_prepare,
 };
 
-LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);
-
-/**
- * Initialize all needed procfs entries for OFD device.
- *
- * \param[in] ofd	OFD device
- *
- * \retval		0 if successful
- * \retval		negative value on error
- */
-static int ofd_procfs_init(struct ofd_device *ofd)
-{
-	struct obd_device		*obd = ofd_obd(ofd);
-	struct proc_dir_entry		*entry;
-	int				 rc = 0;
-
-	ENTRY;
-
-	/* lprocfs must be setup before the ofd so state can be safely added
-	 * to /proc incrementally as the ofd is setup */
-	obd->obd_vars = lprocfs_ofd_obd_vars;
-	rc = lprocfs_obd_setup(obd, false);
-	if (rc) {
-		CERROR("%s: lprocfs_obd_setup failed: %d.\n",
-		       obd->obd_name, rc);
-		RETURN(rc);
-	}
-
-	rc = lprocfs_alloc_obd_stats(obd, LPROC_OFD_STATS_LAST);
-	if (rc) {
-		CERROR("%s: lprocfs_alloc_obd_stats failed: %d.\n",
-		       obd->obd_name, rc);
-		GOTO(obd_cleanup, rc);
-	}
-
-	entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL);
-	if (IS_ERR(entry)) {
-		rc = PTR_ERR(entry);
-		CERROR("%s: error %d setting up lprocfs for %s\n",
-		       obd->obd_name, rc, "exports");
-		GOTO(obd_cleanup, rc);
-	}
-	obd->obd_proc_exports_entry = entry;
-
-	entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
-				   obd, &lprocfs_nid_stats_clear_fops);
-	if (IS_ERR(entry)) {
-		rc = PTR_ERR(entry);
-		CERROR("%s: add proc entry 'clear' failed: %d.\n",
-		       obd->obd_name, rc);
-		GOTO(obd_cleanup, rc);
-	}
-
-	ofd_stats_counter_init(obd->obd_stats);
-
-	rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST,
-				    ofd_stats_counter_init);
-	if (rc)
-		GOTO(obd_cleanup, rc);
-	RETURN(0);
-obd_cleanup:
-	lprocfs_obd_cleanup(obd);
-	lprocfs_free_obd_stats(obd);
-
-	return rc;
-}
-
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0)
 /**
  * Expose OSD statistics to OFD layer.
  *
@@ -779,8 +710,31 @@ obd_cleanup:
  */
 static void ofd_procfs_add_brw_stats_symlink(struct ofd_device *ofd)
 {
-	struct obd_device	*obd = ofd_obd(ofd);
-	struct obd_device	*osd_obd = ofd->ofd_osd_exp->exp_obd;
+	struct obd_device *obd = ofd_obd(ofd);
+	struct obd_device *osd_obd = ofd->ofd_osd_exp->exp_obd;
+	struct kobj_type *osd_type;
+	int i;
+
+	osd_type = get_ktype(&ofd->ofd_osd->dd_kobj);
+	for (i = 0; osd_type->default_attrs[i]; i++) {
+		if (strcmp(osd_type->default_attrs[i]->name,
+			   "read_cache_enable") == 0) {
+			ofd->ofd_read_cache_enable =
+				osd_type->default_attrs[i];
+		}
+
+		if (strcmp(osd_type->default_attrs[i]->name,
+			   "readcache_max_filesize") == 0) {
+			ofd->ofd_read_cache_max_filesize =
+				osd_type->default_attrs[i];
+		}
+
+		if (strcmp(osd_type->default_attrs[i]->name,
+			   "writethrough_cache_enable") == 0) {
+			ofd->ofd_write_cache_enable =
+				osd_type->default_attrs[i];
+		}
+	}
 
 	if (obd->obd_proc_entry == NULL)
 		return;
@@ -788,21 +742,8 @@ static void ofd_procfs_add_brw_stats_symlink(struct ofd_device *ofd)
 	lprocfs_add_symlink("brw_stats", obd->obd_proc_entry,
 			    "../../%s/%s/brw_stats",
 			    osd_obd->obd_type->typ_name, obd->obd_name);
-
-	lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry,
-			    "../../%s/%s/read_cache_enable",
-			    osd_obd->obd_type->typ_name, obd->obd_name);
-
-	lprocfs_add_symlink("readcache_max_filesize",
-			    obd->obd_proc_entry,
-			    "../../%s/%s/readcache_max_filesize",
-			    osd_obd->obd_type->typ_name, obd->obd_name);
-
-	lprocfs_add_symlink("writethrough_cache_enable",
-			    obd->obd_proc_entry,
-			    "../../%s/%s/writethrough_cache_enable",
-			    osd_obd->obd_type->typ_name, obd->obd_name);
 }
+#endif
 
 /**
  * Cleanup all procfs entries in OFD.
@@ -813,6 +754,7 @@ static void ofd_procfs_fini(struct ofd_device *ofd)
 {
 	struct obd_device *obd = ofd_obd(ofd);
 
+	tgt_tunables_fini(&ofd->ofd_lut);
 	lprocfs_free_per_client_stats(obd);
 	lprocfs_obd_cleanup(obd);
 	lprocfs_free_obd_stats(obd);
@@ -852,18 +794,19 @@ int ofd_fid_fini(const struct lu_env *env, struct ofd_device *ofd)
  */
 int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd)
 {
-	struct seq_server_site	*ss = &ofd->ofd_seq_site;
-	struct lu_device	*lu = &ofd->ofd_dt_dev.dd_lu_dev;
-	char			*obd_name = ofd_name(ofd);
-	char			*name = NULL;
-	int			rc = 0;
+	struct seq_server_site *ss = &ofd->ofd_seq_site;
+	struct lu_device *lu = &ofd->ofd_dt_dev.dd_lu_dev;
+	char *obd_name = ofd_name(ofd);
+	char *name = NULL;
+	int len = strlen(obd_name) + 7;
+	int rc = 0;
 
 	ss = &ofd->ofd_seq_site;
 	lu->ld_site->ld_seq_site = ss;
 	ss->ss_lu = lu->ld_site;
 	ss->ss_node_id = ofd->ofd_lut.lut_lsd.lsd_osd_index;
 
-	OBD_ALLOC(name, sizeof(obd_name) * 2 + 10);
+	OBD_ALLOC(name, len);
 	if (name == NULL)
 		return -ENOMEM;
 
@@ -874,7 +817,7 @@ int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd)
 	rc = seq_server_init(env, ss->ss_server_seq, ofd->ofd_osd, obd_name,
 			     LUSTRE_SEQ_SERVER, ss);
 	if (rc) {
-		CERROR("%s : seq server init error %d\n", obd_name, rc);
+		CERROR("%s: seq server init error: rc = %d\n", obd_name, rc);
 		GOTO(out_server, rc);
 	}
 	ss->ss_server_seq->lss_space.lsr_index = ss->ss_node_id;
@@ -883,15 +826,11 @@ int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd)
 	if (ss->ss_client_seq == NULL)
 		GOTO(out_server, rc = -ENOMEM);
 
-	/*
-	 * It always printed as "%p", so that the name is unique in the kernel,
-	 * even if the filesystem is mounted twice. So sizeof(.) * 2 is enough.
-	 */
-	snprintf(name, sizeof(obd_name) * 2 + 7, "%p-super", obd_name);
+	snprintf(name, len, "%s-super", obd_name);
 	rc = seq_client_init(ss->ss_client_seq, NULL, LUSTRE_SEQ_DATA,
 			     name, NULL);
 	if (rc) {
-		CERROR("%s : seq client init error %d\n", obd_name, rc);
+		CERROR("%s: seq client init error: rc = %d\n", obd_name, rc);
 		GOTO(out_client, rc);
 	}
 
@@ -908,7 +847,7 @@ out_server:
 		ss->ss_server_seq = NULL;
 	}
 out_name:
-	OBD_FREE(name, sizeof(obd_name) * 2 + 10);
+	OBD_FREE(name, len);
 
 	return rc;
 }
@@ -1021,7 +960,8 @@ int ofd_fiemap_get(const struct lu_env *env, struct ofd_device *ofd,
 }
 
 
-static int ofd_lock_unlock_region(struct ldlm_namespace *ns,
+static int ofd_lock_unlock_region(const struct lu_env *env,
+				  struct ldlm_namespace *ns,
 				  struct ldlm_res_id *res_id,
 				  unsigned long long begin,
 				  unsigned long long end)
@@ -1032,7 +972,7 @@ static int ofd_lock_unlock_region(struct ldlm_namespace *ns,
 
 	LASSERT(begin <= end);
 
-	rc = tgt_extent_lock(ns, res_id, begin, end, &lh, LCK_PR, &flags);
+	rc = tgt_extent_lock(env, ns, res_id, begin, end, &lh, LCK_PR, &flags);
 	if (rc != 0)
 		return rc;
 
@@ -1060,7 +1000,8 @@ static int ofd_lock_unlock_region(struct ldlm_namespace *ns,
  * \retval		0 if successful
  * \retval		negative value on error
  */
-static int lock_zero_regions(struct ldlm_namespace *ns,
+static int lock_zero_regions(const struct lu_env *env,
+			     struct ldlm_namespace *ns,
 			     struct ldlm_res_id *res_id,
 			     struct fiemap *fiemap)
 {
@@ -1076,7 +1017,7 @@ static int lock_zero_regions(struct ldlm_namespace *ns,
 		if (fiemap_start[i].fe_logical > begin) {
 			CDEBUG(D_OTHER, "ost lock [%llu,%llu]\n",
 			       begin, fiemap_start[i].fe_logical);
-			rc = ofd_lock_unlock_region(ns, res_id, begin,
+			rc = ofd_lock_unlock_region(env, ns, res_id, begin,
 						    fiemap_start[i].fe_logical);
 			if (rc)
 				RETURN(rc);
@@ -1088,7 +1029,7 @@ static int lock_zero_regions(struct ldlm_namespace *ns,
 	if (begin < (fiemap->fm_start + fiemap->fm_length)) {
 		CDEBUG(D_OTHER, "ost lock [%llu,%llu]\n",
 		       begin, fiemap->fm_start + fiemap->fm_length);
-		rc = ofd_lock_unlock_region(ns, res_id, begin,
+		rc = ofd_lock_unlock_region(env, ns, res_id, begin,
 				fiemap->fm_start + fiemap->fm_length);
 	}
 
@@ -1189,7 +1130,7 @@ static int ofd_get_info_hdl(struct tgt_session_info *tsi)
 		if (fm_key->lfik_oa.o_valid & OBD_MD_FLFLAGS &&
 		    fm_key->lfik_oa.o_flags & OBD_FL_SRVLOCK) {
 			ost_fid_build_resid(fid, &fti->fti_resid);
-			rc = lock_zero_regions(ofd->ofd_namespace,
+			rc = lock_zero_regions(tsi->tsi_env, ofd->ofd_namespace,
 					       &fti->fti_resid, fiemap);
 			if (rc == 0)
 				rc = ofd_fiemap_get(tsi->tsi_env, ofd, fid,
@@ -1281,7 +1222,8 @@ static int ofd_getattr_hdl(struct tgt_session_info *tsi)
 		if (unlikely(tsi->tsi_ost_body->oa.o_flags & OBD_FL_FLUSH))
 			lock_mode = LCK_PW;
 
-		rc = tgt_extent_lock(tsi->tsi_tgt->lut_obd->obd_namespace,
+		rc = tgt_extent_lock(tsi->tsi_env,
+				     tsi->tsi_tgt->lut_obd->obd_namespace,
 				     &tsi->tsi_resid, 0, OBD_OBJECT_EOF, &lh,
 				     lock_mode, &flags);
 		if (rc != 0)
@@ -1600,8 +1542,9 @@ static int ofd_create_hdl(struct tgt_session_info *tsi)
 		oseq->os_destroys_in_progress = 1;
 		mutex_lock(&oseq->os_create_lock);
 		if (!oseq->os_destroys_in_progress) {
-			CERROR("%s:[%llu] destroys_in_progress already"
-			       " cleared\n", ofd_name(ofd), seq);
+			CDEBUG(D_HA,
+			       "%s:[%llu] destroys_in_progress already cleared\n",
+			       ofd_name(ofd), seq);
 			rc = ostid_set_id(&rep_oa->o_oi,
 					  ofd_seq_last_oid(oseq));
 			GOTO(out, rc);
@@ -1680,6 +1623,7 @@ static int ofd_create_hdl(struct tgt_session_info *tsi)
 		u64 next_id;
 		int created = 0;
 		int count;
+		int rc2;
 
 		if (!(oa->o_valid & OBD_MD_FLFLAGS) ||
 		    !(oa->o_flags & OBD_FL_DELORPHAN)) {
@@ -1767,11 +1711,14 @@ static int ofd_create_hdl(struct tgt_session_info *tsi)
 			granted = 0;
 		}
 
-		rc = ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq));
+		rc2 = ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq));
+		rc = rc ? : rc2;
 	}
 	EXIT;
 	ofd_counter_incr(exp, LPROC_OFD_STATS_CREATE,
 			 tsi->tsi_jobid, 1);
+	if (unlikely(!oseq->os_last_id_synced))
+		oseq->os_last_id_synced = 1;
 out:
 	mutex_unlock(&oseq->os_create_lock);
 out_nolock:
@@ -2037,8 +1984,8 @@ static int ofd_punch_hdl(struct tgt_session_info *tsi)
 		  oa->o_flags & OBD_FL_SRVLOCK;
 
 	if (srvlock) {
-		rc = tgt_extent_lock(ns, &tsi->tsi_resid, start, end, &lh,
-				     LCK_PW, &flags);
+		rc = tgt_extent_lock(tsi->tsi_env, ns, &tsi->tsi_resid, start,
+				     end, &lh, LCK_PW, &flags);
 		if (rc != 0)
 			RETURN(rc);
 	}
@@ -2248,7 +2195,7 @@ static int ofd_ladvise_hdl(struct tgt_session_info *tsi)
 
 			ioo.ioo_oid = body->oa.o_oi;
 			ioo.ioo_bufcnt = 1;
-			rc = tgt_extent_lock(exp->exp_obd->obd_namespace,
+			rc = tgt_extent_lock(env, exp->exp_obd->obd_namespace,
 					     &tsi->tsi_resid, start, end - 1,
 					     &lockh, LCK_PR, &flags);
 			if (rc != 0)
@@ -2764,26 +2711,25 @@ TGT_RPC_HANDLER(OST_FIRST_OPC,
 		0,			OST_SET_INFO,	ofd_set_info_hdl,
 		&RQF_OBD_SET_INFO, LUSTRE_OST_VERSION),
 TGT_OST_HDL(0,				OST_GET_INFO,	ofd_get_info_hdl),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO,	OST_GETATTR,	ofd_getattr_hdl),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_BODY | HAS_REPLY,	OST_GETATTR,	ofd_getattr_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE,
 					OST_SETATTR,	ofd_setattr_hdl),
-TGT_OST_HDL(0		| HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_REPLY | IS_MUTABLE,
 					OST_CREATE,	ofd_create_hdl),
-TGT_OST_HDL(0		| HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_REPLY | IS_MUTABLE,
 					OST_DESTROY,	ofd_destroy_hdl),
-TGT_OST_HDL(0		| HABEO_REFERO,	OST_STATFS,	ofd_statfs_hdl),
-TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO,
-					OST_BRW_READ,	tgt_brw_read,
+TGT_OST_HDL(HAS_REPLY,	OST_STATFS,	ofd_statfs_hdl),
+TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY,	OST_BRW_READ,	tgt_brw_read,
 							ofd_hp_brw),
 /* don't set CORPUS flag for brw_write because -ENOENT may be valid case */
-TGT_OST_HDL_HP(HABEO_CORPUS| MUTABOR,	OST_BRW_WRITE,	tgt_brw_write,
+TGT_OST_HDL_HP(HAS_BODY | IS_MUTABLE,	OST_BRW_WRITE,	tgt_brw_write,
 							ofd_hp_brw),
-TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO | MUTABOR,
+TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY | IS_MUTABLE,
 					OST_PUNCH,	ofd_punch_hdl,
 							ofd_hp_punch),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO,	OST_SYNC,	ofd_sync_hdl),
-TGT_OST_HDL(0		| HABEO_REFERO,	OST_QUOTACTL,	ofd_quotactl),
-TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO, OST_LADVISE,	ofd_ladvise_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY,	OST_SYNC,	ofd_sync_hdl),
+TGT_OST_HDL(HAS_REPLY,	OST_QUOTACTL,	ofd_quotactl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_LADVISE,	ofd_ladvise_hdl),
 };
 
 static struct tgt_opc_slice ofd_common_slice[] = {
@@ -2905,13 +2851,10 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m,
 	obt = &obd->u.obt;
 	obt->obt_magic = OBT_MAGIC;
 
-	m->ofd_fmd_max_num = OFD_FMD_MAX_NUM_DEFAULT;
-	m->ofd_fmd_max_age = OFD_FMD_MAX_AGE_DEFAULT;
-
 	spin_lock_init(&m->ofd_flags_lock);
 	m->ofd_raid_degraded = 0;
 	m->ofd_checksum_t10pi_enforce = 0;
-	m->ofd_syncjournal = 0;
+	m->ofd_sync_journal = 0;
 	ofd_slc_set(m);
 	m->ofd_soft_sync_limit = OFD_SOFT_SYNC_LIMIT_DEFAULT;
 
@@ -2928,12 +2871,6 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m,
 	/* set this lu_device to obd, because error handling need it */
 	obd->obd_lu_dev = &m->ofd_dt_dev.dd_lu_dev;
 
-	rc = ofd_procfs_init(m);
-	if (rc) {
-		CERROR("Can't init ofd lprocfs, rc %d\n", rc);
-		RETURN(rc);
-	}
-
 	/* No connection accepted until configurations will finish */
 	spin_lock(&obd->obd_dev_lock);
 	obd->obd_no_conn = 1;
@@ -2950,15 +2887,18 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m,
 
 	info = ofd_info_init(env, NULL);
 	if (info == NULL)
-		GOTO(err_fini_proc, rc = -EFAULT);
+		RETURN(-EFAULT);
 
 	rc = ofd_stack_init(env, m, cfg);
 	if (rc) {
-		CERROR("Can't init device stack, rc %d\n", rc);
-		GOTO(err_fini_proc, rc);
+		CERROR("%s: can't init device stack, rc %d\n",
+		       obd->obd_name, rc);
+		RETURN(rc);
 	}
 
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0)
 	ofd_procfs_add_brw_stats_symlink(m);
+#endif
 
 	snprintf(info->fti_u.name, sizeof(info->fti_u.name), "%s-%s",
 		 "filter"/*LUSTRE_OST_NAME*/, obd->obd_uuid.uuid);
@@ -2983,6 +2923,10 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m,
 	if (rc)
 		GOTO(err_free_ns, rc);
 
+	rc = ofd_tunables_init(m);
+	if (rc)
+		GOTO(err_fini_lut, rc);
+
 	tgd->tgd_reserved_pcnt = 0;
 
 	m->ofd_brw_size = m->ofd_lut.lut_dt_conf.ddp_brw_size;
@@ -2995,7 +2939,7 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m,
 
 	rc = ofd_fs_setup(env, m, obd);
 	if (rc)
-		GOTO(err_fini_lut, rc);
+		GOTO(err_fini_proc, rc);
 
 	fid.f_seq = FID_SEQ_LOCAL_NAME;
 	fid.f_oid = 1;
@@ -3031,6 +2975,8 @@ err_fini_los:
 	m->ofd_los = NULL;
 err_fini_fs:
 	ofd_fs_cleanup(env, m);
+err_fini_proc:
+	ofd_procfs_fini(m);
 err_fini_lut:
 	tgt_fini(env, &m->ofd_lut);
 err_free_ns:
@@ -3038,8 +2984,6 @@ err_free_ns:
 	obd->obd_namespace = m->ofd_namespace = NULL;
 err_fini_stack:
 	ofd_stack_fini(env, m, &m->ofd_osd->dd_lu_dev);
-err_fini_proc:
-	ofd_procfs_fini(m);
 	return rc;
 }
 
@@ -3070,6 +3014,7 @@ static void ofd_fini(const struct lu_env *env, struct ofd_device *m)
 	obd_exports_barrier(obd);
 	obd_zombie_barrier();
 
+	ofd_procfs_fini(m);
 	tgt_fini(env, &m->ofd_lut);
 	ofd_stop_inconsistency_verification_thread(m);
 	lfsck_degister(env, m->ofd_osd);
@@ -3083,7 +3028,7 @@ static void ofd_fini(const struct lu_env *env, struct ofd_device *m)
 	}
 
 	ofd_stack_fini(env, m, &m->ofd_dt_dev.dd_lu_dev);
-	ofd_procfs_fini(m);
+
 	LASSERT(atomic_read(&d->ld_ref) == 0);
 	server_put_mount(obd->obd_name, true);
 	EXIT;
@@ -3202,13 +3147,6 @@ static int __init ofd_init(void)
 	rc = lu_kmem_init(ofd_caches);
 	if (rc)
 		return rc;
-
-	rc = ofd_fmd_init();
-	if (rc) {
-		lu_kmem_fini(ofd_caches);
-		return(rc);
-	}
-
 	rc = class_register_type(&ofd_obd_ops, NULL, true, NULL,
 				 LUSTRE_OST_NAME, &ofd_device_type);
 	return rc;
@@ -3222,7 +3160,6 @@ static int __init ofd_init(void)
  */
 static void __exit ofd_exit(void)
 {
-	ofd_fmd_exit();
 	lu_kmem_fini(ofd_caches);
 	class_unregister_type(LUSTRE_OST_NAME);
 }