X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Flod%2Flod_dev.c;h=170fff35be9a4391eeb4cfebb4e59271c6d3fd60;hp=8d9c1ef2e0e3a6ce2604a52953d5fb142e43b871;hb=3b0094779b58c162e5dc553f6d7cdff1910d0c3b;hpb=63e90bdb42a9fedd368726877fd4edfaf8e328c7

diff --git a/lustre/lod/lod_dev.c b/lustre/lod/lod_dev.c
index 8d9c1ef..170fff3 100644
--- a/lustre/lod/lod_dev.c
+++ b/lustre/lod/lod_dev.c
@@ -244,27 +244,21 @@ static int lod_sub_process_config(const struct lu_env *env,
 				 struct lod_tgt_descs *ltd,
 				 struct lustre_cfg *lcfg)
 {
-	struct lu_device  *next;
+	struct lu_device *next;
+	struct lu_tgt_desc *tgt;
 	int rc = 0;
-	unsigned int i;
 
 	lod_getref(ltd);
-	if (ltd->ltd_tgts_size <= 0) {
-		lod_putref(lod, ltd);
-		return 0;
-	}
-	cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-		struct lod_tgt_desc *tgt;
+	ltd_foreach_tgt(ltd, tgt) {
 		int rc1;
 
-		tgt = LTD_TGT(ltd, i);
 		LASSERT(tgt && tgt->ltd_tgt);
 		next = &tgt->ltd_tgt->dd_lu_dev;
 		rc1 = next->ld_ops->ldo_process_config(env, next, lcfg);
 		if (rc1) {
 			CERROR("%s: error cleaning up LOD index %u: cmd %#x : rc = %d\n",
-			       lod2obd(lod)->obd_name, i, lcfg->lcfg_command,
-			       rc1);
+			       lod2obd(lod)->obd_name, tgt->ltd_index,
+			       lcfg->lcfg_command, rc1);
 			rc = rc1;
 		}
 	}
@@ -275,8 +269,10 @@ static int lod_sub_process_config(const struct lu_env *env,
 struct lod_recovery_data {
 	struct lod_device	*lrd_lod;
 	struct lod_tgt_desc	*lrd_ltd;
-	struct ptlrpc_thread	*lrd_thread;
+	struct task_struct	**lrd_task;
 	u32			lrd_idx;
+	struct lu_env		lrd_env;
+	struct completion	*lrd_started;
 };
 
 
@@ -360,30 +356,16 @@ static int lod_sub_recovery_thread(void *arg)
 	struct lod_recovery_data *lrd = arg;
 	struct lod_device *lod = lrd->lrd_lod;
 	struct dt_device *dt;
-	struct ptlrpc_thread *thread = lrd->lrd_thread;
 	struct llog_ctxt *ctxt = NULL;
-	struct lu_env env;
+	struct lu_env *env = &lrd->lrd_env;
 	struct lu_target *lut;
-	struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
-	struct lod_tgt_desc *tgt = NULL;
+	struct lu_tgt_desc *mdt = NULL;
 	time64_t start;
 	int retries = 0;
-	int i;
 	int rc;
 
 	ENTRY;
 
-	thread->t_flags = SVC_RUNNING;
-	wake_up(&thread->t_ctl_waitq);
-
-	rc = lu_env_init(&env, LCT_LOCAL | LCT_MD_THREAD);
-	if (rc != 0) {
-		OBD_FREE_PTR(lrd);
-		CERROR("%s: can't initialize env: rc = %d\n",
-		       lod2obd(lod)->obd_name, rc);
-		RETURN(rc);
-	}
-
 	lut = lod2lu_dev(lod)->ld_site->ls_tgt;
 	atomic_inc(&lut->lut_tdtd->tdtd_recovery_threads_count);
 	if (!lrd->lrd_ltd)
@@ -392,9 +374,17 @@ static int lod_sub_recovery_thread(void *arg)
 		dt = lrd->lrd_ltd->ltd_tgt;
 
 	start = ktime_get_real_seconds();
+	complete(lrd->lrd_started);
 
 again:
-	rc = lod_sub_prep_llog(&env, lod, dt, lrd->lrd_idx);
+
+	if (unlikely(OBD_FAIL_PRECHECK(OBD_FAIL_TGT_RECOVERY_CONNECT)) &&
+	    lrd->lrd_ltd) {
+		OBD_FAIL_TIMEOUT(OBD_FAIL_TGT_RECOVERY_CONNECT, cfs_fail_val);
+		rc = -EIO;
+	} else {
+		rc = lod_sub_prep_llog(env, lod, dt, lrd->lrd_idx);
+	}
 	if (!rc && !lod->lod_child->dd_rdonly) {
 		/* Process the recovery record */
 		ctxt = llog_get_context(dt->dd_lu_dev.ld_obd,
@@ -402,7 +392,7 @@ again:
 		LASSERT(ctxt != NULL);
 		LASSERT(ctxt->loc_handle != NULL);
 
-		rc = llog_cat_process(&env, ctxt->loc_handle,
+		rc = llog_cat_process(env, ctxt->loc_handle,
 				      lod_process_recovery_updates, lrd, 0, 0);
 	}
 
@@ -420,7 +410,7 @@ again:
 		    !top_device->ld_obd->obd_stopping) {
 			if (ctxt) {
 				if (ctxt->loc_handle)
-					llog_cat_close(&env,
+					llog_cat_close(env,
 						       ctxt->loc_handle);
 				llog_ctxt_put(ctxt);
 			}
@@ -459,9 +449,8 @@ again:
 		GOTO(out, rc = 0);
 	}
 
-	cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-		tgt = LTD_TGT(ltd, i);
-		if (!tgt->ltd_got_update_log) {
+	lod_foreach_mdt(lod, mdt) {
+		if (!mdt->ltd_got_update_log) {
 			spin_unlock(&lod->lod_lock);
 			GOTO(out, rc = 0);
 		}
@@ -475,13 +464,16 @@ again:
 	EXIT;
 
 out:
-	OBD_FREE_PTR(lrd);
-	thread->t_flags = SVC_STOPPED;
 	atomic_dec(&lut->lut_tdtd->tdtd_recovery_threads_count);
 	wake_up(&lut->lut_tdtd->tdtd_recovery_threads_waitq);
-	wake_up(&thread->t_ctl_waitq);
-	lu_env_fini(&env);
-	return rc;
+	if (xchg(lrd->lrd_task, NULL) == NULL)
+		/* Someone is waiting for us to finish, need
+		 * to synchronize cleanly.
+		 */
+		wait_var_event(lrd, kthread_should_stop());
+	lu_env_fini(env);
+	OBD_FREE_PTR(lrd);
+	return 0;
 }
 
 /**
@@ -495,21 +487,21 @@ out:
  * \param[in] thread   recovery thread on this sub device
  */
 void lod_sub_fini_llog(const struct lu_env *env,
-		       struct dt_device *dt, struct ptlrpc_thread *thread)
+		       struct dt_device *dt, struct task_struct **thread)
 {
 	struct obd_device *obd;
 	struct llog_ctxt *ctxt;
+	struct task_struct *task = NULL;
 
 	ENTRY;
 
 	obd = dt->dd_lu_dev.ld_obd;
 	CDEBUG(D_INFO, "%s: finish sub llog\n", obd->obd_name);
-	/* Stop recovery thread first */
-	if (thread && thread->t_flags & SVC_RUNNING) {
-		thread->t_flags = SVC_STOPPING;
-		wake_up(&thread->t_ctl_waitq);
-		wait_event(thread->t_ctl_waitq, thread->t_flags & SVC_STOPPED);
-	}
+	/* Wait for recovery thread to complete */
+	if (thread)
+		task = xchg(thread, NULL);
+	if (task)
+		kthread_stop(task);
 
 	ctxt = llog_get_context(obd, LLOG_UPDATELOG_ORIG_CTXT);
 	if (!ctxt)
@@ -537,8 +529,8 @@ void lod_sub_fini_llog(const struct lu_env *env,
  */
 int lodname2mdt_index(char *lodname, u32 *mdt_index)
 {
-	unsigned long index;
-	char *ptr, *tmp;
+	u32 index;
+	const char *ptr, *tmp;
 	int rc;
 
 	/* 1.8 configs don't have "-MDT0000" at the end */
@@ -573,8 +565,8 @@ int lodname2mdt_index(char *lodname, u32 *mdt_index)
 		return rc;
 	}
 
-	index = simple_strtol(ptr - 4, &tmp, 16);
-	if (*tmp != '-' || index > INT_MAX) {
+	rc = target_name2index(ptr - 7, &index, &tmp);
+	if (rc < 0 || rc & LDD_F_SV_ALL || *tmp != '-') {
 		rc = -EINVAL;
 		CERROR("invalid MDT index in '%s': rc = %d\n", lodname, rc);
 		return rc;
@@ -602,10 +594,10 @@ int lod_sub_init_llog(const struct lu_env *env, struct lod_device *lod,
 {
 	struct obd_device *obd;
 	struct lod_recovery_data *lrd = NULL;
-	struct ptlrpc_thread *thread;
+	DECLARE_COMPLETION_ONSTACK(started);
+	struct task_struct **taskp;
 	struct task_struct *task;
-	struct l_wait_info lwi = { 0 };
-	struct lod_tgt_desc *sub_ltd = NULL;
+	struct lod_tgt_desc *subtgt = NULL;
 	u32 index;
 	u32 master_index;
 	int rc;
@@ -621,36 +613,29 @@ int lod_sub_init_llog(const struct lu_env *env, struct lod_device *lod,
 		RETURN(-ENOMEM);
 
 	if (lod->lod_child == dt) {
-		thread = &lod->lod_child_recovery_thread;
+		taskp = &lod->lod_child_recovery_task;
 		index = master_index;
 	} else {
-		struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
-		struct lod_tgt_desc *tgt = NULL;
-		unsigned int i;
-
-		cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-			tgt = LTD_TGT(ltd, i);
-			if (tgt->ltd_tgt == dt) {
-				index = tgt->ltd_index;
-				sub_ltd = tgt;
+		struct lu_tgt_desc *mdt;
+
+		lod_foreach_mdt(lod, mdt) {
+			if (mdt->ltd_tgt == dt) {
+				index = mdt->ltd_index;
+				subtgt = mdt;
 				break;
 			}
 		}
-		LASSERT(sub_ltd != NULL);
-		OBD_ALLOC_PTR(sub_ltd->ltd_recovery_thread);
-		if (!sub_ltd->ltd_recovery_thread)
-			GOTO(free_lrd, rc = -ENOMEM);
-
-		thread = sub_ltd->ltd_recovery_thread;
+		LASSERT(subtgt != NULL);
+		taskp = &subtgt->ltd_recovery_task;
 	}
 
 	CDEBUG(D_INFO, "%s init sub log %s\n", lod2obd(lod)->obd_name,
 	       dt->dd_lu_dev.ld_obd->obd_name);
 	lrd->lrd_lod = lod;
-	lrd->lrd_ltd = sub_ltd;
-	lrd->lrd_thread = thread;
+	lrd->lrd_ltd = subtgt;
+	lrd->lrd_task = taskp;
 	lrd->lrd_idx = index;
-	init_waitqueue_head(&thread->t_ctl_waitq);
+	lrd->lrd_started = &started;
 
 	obd = dt->dd_lu_dev.ld_obd;
 	obd->obd_lvfs_ctxt.dt = dt;
@@ -659,30 +644,33 @@ int lod_sub_init_llog(const struct lu_env *env, struct lod_device *lod,
 	if (rc < 0) {
 		CERROR("%s: cannot setup updatelog llog: rc = %d\n",
 		       obd->obd_name, rc);
-		GOTO(free_thread, rc);
+		GOTO(free_lrd, rc);
+	}
+
+	rc = lu_env_init(&lrd->lrd_env, LCT_LOCAL | LCT_MD_THREAD);
+	if (rc != 0) {
+		CERROR("%s: can't initialize env: rc = %d\n",
+		       lod2obd(lod)->obd_name, rc);
+		GOTO(free_lrd, rc);
 	}
 
 	/* Start the recovery thread */
-	task = kthread_run(lod_sub_recovery_thread, lrd, "lod%04x_rec%04x",
-			   master_index, index);
+	task = kthread_create(lod_sub_recovery_thread, lrd, "lod%04x_rec%04x",
+			      master_index, index);
 	if (IS_ERR(task)) {
 		rc = PTR_ERR(task);
 		CERROR("%s: cannot start recovery thread: rc = %d\n",
 		       obd->obd_name, rc);
+		lu_env_fini(&lrd->lrd_env);
 		GOTO(out_llog, rc);
 	}
-
-	l_wait_event(thread->t_ctl_waitq, thread->t_flags & SVC_RUNNING ||
-					  thread->t_flags & SVC_STOPPED, &lwi);
+	*taskp = task;
+	wake_up_process(task);
+	wait_for_completion(&started);
 
 	RETURN(0);
 out_llog:
-	lod_sub_fini_llog(env, dt, thread);
-free_thread:
-	if (lod->lod_child != dt) {
-		OBD_FREE_PTR(sub_ltd->ltd_recovery_thread);
-		sub_ltd->ltd_recovery_thread = NULL;
-	}
+	lod_sub_fini_llog(env, dt, taskp);
 free_lrd:
 	OBD_FREE_PTR(lrd);
 	RETURN(rc);
@@ -699,39 +687,24 @@ free_lrd:
 static void lod_sub_stop_recovery_threads(const struct lu_env *env,
 					  struct lod_device *lod)
 {
-	struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
-	struct ptlrpc_thread *thread;
-	unsigned int i;
+	struct task_struct *task;
+	struct lu_tgt_desc *mdt;
 
 	/*
 	 * Stop the update log commit cancel threads and finish master
 	 * llog ctxt
 	 */
-	thread = &lod->lod_child_recovery_thread;
-	/* Stop recovery thread first */
-	if (thread && thread->t_flags & SVC_RUNNING) {
-		thread->t_flags = SVC_STOPPING;
-		wake_up(&thread->t_ctl_waitq);
-		wait_event(thread->t_ctl_waitq, thread->t_flags & SVC_STOPPED);
-	}
+	task = xchg(&lod->lod_child_recovery_task, NULL);
+	if (task)
+		kthread_stop(task);
 
-	lod_getref(ltd);
-	cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-		struct lod_tgt_desc	*tgt;
-
-		tgt = LTD_TGT(ltd, i);
-		thread = tgt->ltd_recovery_thread;
-		if (thread && thread->t_flags & SVC_RUNNING) {
-			thread->t_flags = SVC_STOPPING;
-			wake_up(&thread->t_ctl_waitq);
-			wait_event(thread->t_ctl_waitq,
-				   thread->t_flags & SVC_STOPPED);
-			OBD_FREE_PTR(tgt->ltd_recovery_thread);
-			tgt->ltd_recovery_thread = NULL;
-		}
+	lod_getref(&lod->lod_mdt_descs);
+	lod_foreach_mdt(lod, mdt) {
+		task = xchg(&mdt->ltd_recovery_task, NULL);
+		if (task)
+			kthread_stop(task);
 	}
-
-	lod_putref(lod, ltd);
+	lod_putref(lod, &lod->lod_mdt_descs);
 }
 
 /**
@@ -745,33 +718,26 @@ static void lod_sub_stop_recovery_threads(const struct lu_env *env,
 static void lod_sub_fini_all_llogs(const struct lu_env *env,
 				   struct lod_device *lod)
 {
-	struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
-	unsigned int i;
+	struct lu_tgt_desc *mdt;
 
 	/*
 	 * Stop the update log commit cancel threads and finish master
 	 * llog ctxt
 	 */
 	lod_sub_fini_llog(env, lod->lod_child,
-			  &lod->lod_child_recovery_thread);
-	lod_getref(ltd);
-	cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-		struct lod_tgt_desc *tgt;
-
-		tgt = LTD_TGT(ltd, i);
-		lod_sub_fini_llog(env, tgt->ltd_tgt,
-				  tgt->ltd_recovery_thread);
-	}
-
-	lod_putref(lod, ltd);
+			  &lod->lod_child_recovery_task);
+	lod_getref(&lod->lod_mdt_descs);
+	lod_foreach_mdt(lod, mdt)
+		lod_sub_fini_llog(env, mdt->ltd_tgt,
+				  &mdt->ltd_recovery_task);
+	lod_putref(lod, &lod->lod_mdt_descs);
 }
 
 static char *lod_show_update_logs_retrievers(void *data, int *size, int *count)
 {
 	struct lod_device *lod = (struct lod_device *)data;
 	struct lu_target *lut = lod2lu_dev(lod)->ld_site->ls_tgt;
-	struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
-	struct lod_tgt_desc *tgt = NULL;
+	struct lu_tgt_desc *mdt = NULL;
 	char *buf;
 	int len = 0;
 	int rc;
@@ -795,17 +761,17 @@ static char *lod_show_update_logs_retrievers(void *data, int *size, int *count)
 		rc = lodname2mdt_index(lod2obd(lod)->obd_name, &i);
 		LASSERTF(rc == 0, "Fail to parse target index: rc = %d\n", rc);
 
-		rc = snprintf(buf + len, *size - len, " %04x", i);
+		rc = scnprintf(buf + len, *size - len, " %04x", i);
 		LASSERT(rc > 0);
 
 		len += rc;
 		(*count)++;
 	}
 
-	cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-		tgt = LTD_TGT(ltd, i);
-		if (!tgt->ltd_got_update_log) {
-			rc = snprintf(buf + len, *size - len, " %04x", i);
+	lod_foreach_mdt(lod, mdt) {
+		if (!mdt->ltd_got_update_log) {
+			rc = scnprintf(buf + len, *size - len, " %04x",
+				       mdt->ltd_index);
 			if (unlikely(rc <= 0))
 				break;
 
@@ -973,9 +939,8 @@ static int lod_process_config(const struct lu_env *env,
 			rc = lod_add_device(env, lod, arg1, index, gen,
 					    mdt_index, LUSTRE_OSC_NAME, 0);
 		} else {
-			rc = lod_del_device(env, lod,
-					    &lod->lod_ost_descs,
-					    arg1, index, gen, true);
+			rc = lod_del_device(env, lod, &lod->lod_ost_descs,
+					    arg1, index, gen);
 		}
 
 		break;
@@ -992,11 +957,10 @@ static int lod_process_config(const struct lu_env *env,
 		 */
 		param = lustre_cfg_buf(lcfg, 1);
 		if (strstr(param, "osp") && strstr(param, ".active=")) {
-			struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
 			struct lod_tgt_desc *sub_tgt = NULL;
+			struct lu_tgt_desc *mdt;
 			char *ptr;
 			char *tmp;
-			int i;
 
 			ptr = strstr(param, ".");
 			*ptr = '\0';
@@ -1008,12 +972,9 @@ static int lod_process_config(const struct lu_env *env,
 				GOTO(out, rc);
 			}
 
-			cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-				struct lod_tgt_desc *tgt;
-
-				tgt = LTD_TGT(ltd, i);
-				if (tgt->ltd_tgt->dd_lu_dev.ld_obd == obd) {
-					sub_tgt = tgt;
+			lod_foreach_mdt(lod, mdt) {
+				if (mdt->ltd_tgt->dd_lu_dev.ld_obd == obd) {
+					sub_tgt = mdt;
 					break;
 				}
 			}
@@ -1069,6 +1030,7 @@ static int lod_process_config(const struct lu_env *env,
 	case LCFG_PRE_CLEANUP: {
 		lod_sub_process_config(env, lod, &lod->lod_mdt_descs, lcfg);
 		lod_sub_process_config(env, lod, &lod->lod_ost_descs, lcfg);
+		OBD_FAIL_TIMEOUT(OBD_FAIL_TGT_RECOVERY_CONNECT, cfs_fail_val * 2);
 		next = &lod->lod_child->dd_lu_dev;
 		rc = next->ld_ops->ldo_process_config(env, next, lcfg);
 		if (rc != 0)
@@ -1129,7 +1091,7 @@ static int lod_recovery_complete(const struct lu_env *env,
 {
 	struct lod_device *lod = lu2lod_dev(dev);
 	struct lu_device *next = &lod->lod_child->dd_lu_dev;
-	unsigned int i;
+	struct lod_tgt_desc *tgt;
 	int rc;
 
 	ENTRY;
@@ -1140,17 +1102,15 @@ static int lod_recovery_complete(const struct lu_env *env,
 	rc = next->ld_ops->ldo_recovery_complete(env, next);
 
 	lod_getref(&lod->lod_ost_descs);
-	if (lod->lod_osts_size > 0) {
-		cfs_foreach_bit(lod->lod_ost_bitmap, i) {
-			struct lod_tgt_desc *tgt;
-
-			tgt = OST_TGT(lod, i);
+	if (lod->lod_ost_descs.ltd_tgts_size > 0) {
+		lod_foreach_ost(lod, tgt) {
 			LASSERT(tgt && tgt->ltd_tgt);
-			next = &tgt->ltd_ost->dd_lu_dev;
+			next = &tgt->ltd_tgt->dd_lu_dev;
 			rc = next->ld_ops->ldo_recovery_complete(env, next);
 			if (rc)
 				CERROR("%s: can't complete recovery on #%d: rc = %d\n",
-				       lod2obd(lod)->obd_name, i, rc);
+				       lod2obd(lod)->obd_name, tgt->ltd_index,
+				       rc);
 		}
 	}
 	lod_putref(lod, &lod->lod_ost_descs);
@@ -1171,9 +1131,8 @@ static int lod_recovery_complete(const struct lu_env *env,
  */
 static int lod_sub_init_llogs(const struct lu_env *env, struct lod_device *lod)
 {
-	struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
+	struct lu_tgt_desc *mdt;
 	int rc;
-	unsigned int i;
 
 	ENTRY;
 
@@ -1188,11 +1147,8 @@ static int lod_sub_init_llogs(const struct lu_env *env, struct lod_device *lod)
 	if (rc < 0)
 		RETURN(rc);
 
-	cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-		struct lod_tgt_desc *tgt;
-
-		tgt = LTD_TGT(ltd, i);
-		rc = lod_sub_init_llog(env, lod, tgt->ltd_tgt);
+	lod_foreach_mdt(lod, mdt) {
+		rc = lod_sub_init_llog(env, lod, mdt->ltd_tgt);
 		if (rc != 0)
 			break;
 	}
@@ -1324,12 +1280,11 @@ static int lod_statfs(const struct lu_env *env, struct dt_device *dev,
 		      struct obd_statfs *sfs, struct obd_statfs_info *info)
 {
 	struct lod_device *lod = dt2lod_dev(dev);
-	struct lod_ost_desc *ost;
-	struct lod_mdt_desc *mdt;
+	struct lu_tgt_desc *tgt;
 	struct obd_statfs ost_sfs;
 	u64 ost_files = 0;
 	u64 ost_ffree = 0;
-	int i, rc, bs;
+	int rc, bs;
 
 	rc = dt_statfs(env, dt2lod_dev(dev)->lod_child, sfs);
 	if (rc)
@@ -1343,10 +1298,8 @@ static int lod_statfs(const struct lu_env *env, struct dt_device *dev,
 	sfs->os_granted = 0;
 
 	lod_getref(&lod->lod_mdt_descs);
-	lod_foreach_mdt(lod, i) {
-		mdt = MDT_TGT(lod, i);
-		LASSERT(mdt && mdt->ltd_mdt);
-		rc = dt_statfs(env, mdt->ltd_mdt, &ost_sfs);
+	lod_foreach_mdt(lod, tgt) {
+		rc = dt_statfs(env, tgt->ltd_tgt, &ost_sfs);
 		/* ignore errors */
 		if (rc)
 			continue;
@@ -1362,10 +1315,8 @@ static int lod_statfs(const struct lu_env *env, struct dt_device *dev,
 	 * just fallback to pre-DoM policy if any OST is alive
 	 */
 	lod_getref(&lod->lod_ost_descs);
-	lod_foreach_ost(lod, i) {
-		ost = OST_TGT(lod, i);
-		LASSERT(ost && ost->ltd_ost);
-		rc = dt_statfs(env, ost->ltd_ost, &ost_sfs);
+	lod_foreach_ost(lod, tgt) {
+		rc = dt_statfs(env, tgt->ltd_tgt, &ost_sfs);
 		/* ignore errors */
 		if (rc || ost_sfs.os_bsize == 0)
 			continue;
@@ -1531,24 +1482,21 @@ static void lod_conf_get(const struct lu_env *env,
 static int lod_sync(const struct lu_env *env, struct dt_device *dev)
 {
 	struct lod_device *lod = dt2lod_dev(dev);
-	struct lod_ost_desc *ost;
-	struct lod_mdt_desc *mdt;
-	unsigned int i;
+	struct lu_tgt_desc *tgt;
 	int rc = 0;
 
 	ENTRY;
 
 	lod_getref(&lod->lod_ost_descs);
-	lod_foreach_ost(lod, i) {
-		ost = OST_TGT(lod, i);
-		LASSERT(ost && ost->ltd_ost);
-		if (!ost->ltd_active)
+	lod_foreach_ost(lod, tgt) {
+		if (!tgt->ltd_active)
 			continue;
-		rc = dt_sync(env, ost->ltd_ost);
+		rc = dt_sync(env, tgt->ltd_tgt);
 		if (rc) {
 			if (rc != -ENOTCONN) {
 				CERROR("%s: can't sync ost %u: rc = %d\n",
-				       lod2obd(lod)->obd_name, i, rc);
+				       lod2obd(lod)->obd_name, tgt->ltd_index,
+				       rc);
 				break;
 			}
 			rc = 0;
@@ -1560,16 +1508,15 @@ static int lod_sync(const struct lu_env *env, struct dt_device *dev)
 		RETURN(rc);
 
 	lod_getref(&lod->lod_mdt_descs);
-	lod_foreach_mdt(lod, i) {
-		mdt = MDT_TGT(lod, i);
-		LASSERT(mdt && mdt->ltd_mdt);
-		if (!mdt->ltd_active)
+	lod_foreach_mdt(lod, tgt) {
+		if (!tgt->ltd_active)
 			continue;
-		rc = dt_sync(env, mdt->ltd_mdt);
+		rc = dt_sync(env, tgt->ltd_tgt);
 		if (rc) {
 			if (rc != -ENOTCONN) {
 				CERROR("%s: can't sync mdt %u: rc = %d\n",
-				       lod2obd(lod)->obd_name, i, rc);
+				       lod2obd(lod)->obd_name, tgt->ltd_index,
+				       rc);
 				break;
 			}
 			rc = 0;
@@ -1724,38 +1671,6 @@ out:
 }
 
 /**
- * Allocate and initialize target table.
- *
- * A helper function to initialize the target table and allocate
- * a bitmap of the available targets.
- *
- * \param[in] ltd		target's table to initialize
- *
- * \retval 0			on success
- * \retval negative		negated errno on error
- **/
-static int lod_tgt_desc_init(struct lod_tgt_descs *ltd)
-{
-	mutex_init(&ltd->ltd_mutex);
-	init_rwsem(&ltd->ltd_rw_sem);
-
-	/*
-	 * the OST array and bitmap are allocated/grown dynamically as OSTs are
-	 * added to the LOD, see lod_add_device()
-	 */
-	ltd->ltd_tgt_bitmap = CFS_ALLOCATE_BITMAP(32);
-	if (!ltd->ltd_tgt_bitmap)
-		RETURN(-ENOMEM);
-
-	ltd->ltd_tgts_size  = 32;
-	ltd->ltd_tgtnr      = 0;
-
-	ltd->ltd_death_row = 0;
-	ltd->ltd_refcount  = 0;
-	return 0;
-}
-
-/**
  * Initialize LOD device at setup.
  *
  * Initializes the given LOD device using the original configuration command.
@@ -1811,8 +1726,8 @@ static int lod_init0(const struct lu_env *env, struct lod_device *lod,
 
 	spin_lock_init(&lod->lod_lock);
 	spin_lock_init(&lod->lod_connects_lock);
-	lod_tgt_desc_init(&lod->lod_mdt_descs);
-	lod_tgt_desc_init(&lod->lod_ost_descs);
+	lu_tgt_descs_init(&lod->lod_mdt_descs, true);
+	lu_tgt_descs_init(&lod->lod_ost_descs, false);
 
 	RETURN(0);
 
@@ -1909,12 +1824,12 @@ static struct lu_device *lod_device_fini(const struct lu_env *env,
 
 	lod_procfs_fini(lod);
 
-	rc = lod_fini_tgt(env, lod, &lod->lod_ost_descs, true);
+	rc = lod_fini_tgt(env, lod, &lod->lod_ost_descs);
 	if (rc)
 		CERROR("%s: can not fini ost descriptors: rc =  %d\n",
 			lod2obd(lod)->obd_name, rc);
 
-	rc = lod_fini_tgt(env, lod, &lod->lod_mdt_descs, false);
+	rc = lod_fini_tgt(env, lod, &lod->lod_mdt_descs);
 	if (rc)
 		CERROR("%s: can not fini mdt descriptors: rc =  %d\n",
 			lod2obd(lod)->obd_name, rc);
@@ -2096,7 +2011,6 @@ static int lod_obd_get_info(const struct lu_env *env, struct obd_export *exp,
 		struct obd_device *obd = exp->exp_obd;
 		struct lod_device *d;
 		struct lod_tgt_desc *tgt;
-		unsigned int i;
 		int rc = 1;
 
 		if (!obd->obd_set_up || obd->obd_stopping)
@@ -2104,9 +2018,7 @@ static int lod_obd_get_info(const struct lu_env *env, struct obd_export *exp,
 
 		d = lu2lod_dev(obd->obd_lu_dev);
 		lod_getref(&d->lod_ost_descs);
-		lod_foreach_ost(d, i) {
-			tgt = OST_TGT(d, i);
-			LASSERT(tgt && tgt->ltd_tgt);
+		lod_foreach_ost(d, tgt) {
 			rc = obd_get_info(env, tgt->ltd_exp, keylen, key,
 					  vallen, val);
 			/* one healthy device is enough */
@@ -2116,12 +2028,9 @@ static int lod_obd_get_info(const struct lu_env *env, struct obd_export *exp,
 		lod_putref(d, &d->lod_ost_descs);
 
 		lod_getref(&d->lod_mdt_descs);
-		lod_foreach_mdt(d, i) {
+		lod_foreach_mdt(d, tgt) {
 			struct llog_ctxt *ctxt;
 
-			tgt = MDT_TGT(d, i);
-			LASSERT(tgt != NULL);
-			LASSERT(tgt->ltd_tgt != NULL);
 			if (!tgt->ltd_active)
 				continue;
 
@@ -2162,7 +2071,7 @@ static int lod_obd_set_info_async(const struct lu_env *env,
 	struct lod_device *d;
 	struct lod_tgt_desc *tgt;
 	int no_set = 0;
-	int i, rc = 0, rc2;
+	int rc = 0, rc2;
 
 	ENTRY;
 
@@ -2175,9 +2084,7 @@ static int lod_obd_set_info_async(const struct lu_env *env,
 
 	d = lu2lod_dev(obd->obd_lu_dev);
 	lod_getref(&d->lod_ost_descs);
-	lod_foreach_ost(d, i) {
-		tgt = OST_TGT(d, i);
-		LASSERT(tgt && tgt->ltd_tgt);
+	lod_foreach_ost(d, tgt) {
 		if (!tgt->ltd_active)
 			continue;
 
@@ -2189,9 +2096,7 @@ static int lod_obd_set_info_async(const struct lu_env *env,
 	lod_putref(d, &d->lod_ost_descs);
 
 	lod_getref(&d->lod_mdt_descs);
-	lod_foreach_mdt(d, i) {
-		tgt = MDT_TGT(d, i);
-		LASSERT(tgt && tgt->ltd_tgt);
+	lod_foreach_mdt(d, tgt) {
 		if (!tgt->ltd_active)
 			continue;
 		rc2 = obd_set_info_async(env, tgt->ltd_exp, keylen, key,
@@ -2211,7 +2116,7 @@ static int lod_obd_set_info_async(const struct lu_env *env,
 	RETURN(rc);
 }
 
-static struct obd_ops lod_obd_device_ops = {
+static const struct obd_ops lod_obd_device_ops = {
 	.o_owner        = THIS_MODULE,
 	.o_connect      = lod_obd_connect,
 	.o_disconnect   = lod_obd_disconnect,
@@ -2223,10 +2128,9 @@ static struct obd_ops lod_obd_device_ops = {
 	.o_pool_del     = lod_pool_del,
 };
 
-static struct obd_type *sym;
-
 static int __init lod_init(void)
 {
+	struct obd_type *sym;
 	int rc;
 
 	rc = lu_kmem_init(lod_caches);
@@ -2254,8 +2158,18 @@ static int __init lod_init(void)
 
 static void __exit lod_exit(void)
 {
-	if (!IS_ERR_OR_NULL(sym))
+	struct obd_type *sym = class_search_type(LUSTRE_LOV_NAME);
+
+	/* if this was never fully initialized by the lov layer
+	 * then we are responsible for freeing this obd_type
+	 */
+	if (sym) {
+		/* final put if we manage this obd type */
+		if (sym->typ_sym_filter)
+			kobject_put(&sym->typ_kobj);
+		/* put reference taken by class_search_type */
 		kobject_put(&sym->typ_kobj);
+	}
 
 	class_unregister_type(LUSTRE_LOD_NAME);
 	lu_kmem_fini(lod_caches);