X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fosp%2Fosp_precreate.c;h=6eb22c718120a830847284d768d6a0704241ae02;hb=96c0696453f3aaf5c29a46fd7c6f0bdc25301d71;hp=67fc2bcaeebb2f2dfff12025e3aa907397b900d9;hpb=c8fd9c3c38a66ab3dd479c48e0168577a4ff960e;p=fs%2Flustre-release.git

diff --git a/lustre/osp/osp_precreate.c b/lustre/osp/osp_precreate.c
index 67fc2bc..6eb22c7 100644
--- a/lustre/osp/osp_precreate.c
+++ b/lustre/osp/osp_precreate.c
@@ -42,9 +42,6 @@
  * Author: Di Wang <di.wang@intel.com>
  */
 
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
 #define DEBUG_SUBSYSTEM S_MDS
 
 #include "osp_internal.h"
@@ -68,12 +65,29 @@ static inline int osp_statfs_need_update(struct osp_device *d)
 				d->opd_statfs_fresh_till);
 }
 
+/*
+ * OSP tries to maintain pool of available objects so that calls to create
+ * objects don't block most of time
+ *
+ * each time OSP gets connected to OST, we should start from precreation cleanup
+ */
+static inline bool osp_precreate_running(struct osp_device *d)
+{
+	return !!(d->opd_pre_thread.t_flags & SVC_RUNNING);
+}
+
+static inline bool osp_precreate_stopped(struct osp_device *d)
+{
+	return !!(d->opd_pre_thread.t_flags & SVC_STOPPED);
+}
+
 static void osp_statfs_timer_cb(unsigned long _d)
 {
 	struct osp_device *d = (struct osp_device *) _d;
 
 	LASSERT(d);
-	cfs_waitq_signal(&d->opd_pre_waitq);
+	if (d->opd_pre != NULL && osp_precreate_running(d))
+		wake_up(&d->opd_pre_waitq);
 }
 
 static int osp_statfs_interpret(const struct lu_env *env,
@@ -111,7 +125,9 @@ static int osp_statfs_interpret(const struct lu_env *env,
 	RETURN(0);
 out:
 	/* couldn't update statfs, try again as soon as possible */
-	cfs_waitq_signal(&d->opd_pre_waitq);
+	if (d->opd_pre != NULL && osp_precreate_running(d))
+		wake_up(&d->opd_pre_waitq);
+
 	if (req->rq_import_generation == imp->imp_generation)
 		CDEBUG(D_CACHE, "%s: couldn't update statfs: rc = %d\n",
 		       d->opd_obd->obd_name, rc);
@@ -177,27 +193,10 @@ void osp_statfs_need_now(struct osp_device *d)
 		 */
 		d->opd_statfs_fresh_till = cfs_time_shift(-1);
 		cfs_timer_disarm(&d->opd_statfs_timer);
-		cfs_waitq_signal(&d->opd_pre_waitq);
+		wake_up(&d->opd_pre_waitq);
 	}
 }
 
-
-/*
- * OSP tries to maintain pool of available objects so that calls to create
- * objects don't block most of time
- *
- * each time OSP gets connected to OST, we should start from precreation cleanup
- */
-static inline int osp_precreate_running(struct osp_device *d)
-{
-	return !!(d->opd_pre_thread.t_flags & SVC_RUNNING);
-}
-
-static inline int osp_precreate_stopped(struct osp_device *d)
-{
-	return !!(d->opd_pre_thread.t_flags & SVC_STOPPED);
-}
-
 static inline int osp_objs_precreated(const struct lu_env *env,
 				      struct osp_device *osp)
 {
@@ -289,12 +288,12 @@ int osp_write_last_oid_seq_files(struct lu_env *env, struct osp_device *osp,
 
 	th->th_sync |= sync;
 	rc = dt_declare_record_write(env, osp->opd_last_used_oid_file,
-				     lb_oid->lb_len, oid_off, th);
+				     lb_oid, oid_off, th);
 	if (rc != 0)
 		GOTO(out, rc);
 
 	rc = dt_declare_record_write(env, osp->opd_last_used_seq_file,
-				     lb_oseq->lb_len, oseq_off, th);
+				     lb_oseq, oseq_off, th);
 	if (rc != 0)
 		GOTO(out, rc);
 
@@ -462,7 +461,7 @@ static int osp_precreate_send(const struct lu_env *env, struct osp_device *d)
 			osp_pre_update_status(d, -ENOSPC);
 			rc = -ENOSPC;
 		}
-		cfs_waitq_signal(&d->opd_pre_waitq);
+		wake_up(&d->opd_pre_waitq);
 		GOTO(out_req, rc);
 	}
 
@@ -519,7 +518,7 @@ static int osp_precreate_send(const struct lu_env *env, struct osp_device *d)
 out_req:
 	/* now we can wakeup all users awaiting for objects */
 	osp_pre_update_status(d, rc);
-	cfs_waitq_signal(&d->opd_pre_user_waitq);
+	wake_up(&d->opd_pre_user_waitq);
 
 	ptlrpc_req_finished(req);
 	RETURN(rc);
@@ -542,24 +541,22 @@ static int osp_get_lastfid_from_ost(const struct lu_env *env,
 	if (req == NULL)
 		RETURN(-ENOMEM);
 
-	req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY, RCL_CLIENT,
+	req_capsule_set_size(&req->rq_pill, &RMF_GETINFO_KEY, RCL_CLIENT,
 			     sizeof(KEY_LAST_FID));
 
-	req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL, RCL_CLIENT,
-			     sizeof(struct lu_fid));
-
 	rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GET_INFO);
 	if (rc) {
 		ptlrpc_request_free(req);
 		RETURN(rc);
 	}
 
-	tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
+	tmp = req_capsule_client_get(&req->rq_pill, &RMF_GETINFO_KEY);
 	memcpy(tmp, KEY_LAST_FID, sizeof(KEY_LAST_FID));
 
 	req->rq_no_delay = req->rq_no_resend = 1;
-	tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
-	fid_cpu_to_le((struct lu_fid *)tmp, &d->opd_last_used_fid);
+	last_fid = req_capsule_client_get(&req->rq_pill, &RMF_FID);
+	fid_cpu_to_le(last_fid, &d->opd_last_used_fid);
+
 	ptlrpc_request_set_replen(req);
 
 	rc = ptlrpc_queue_wait(req);
@@ -724,7 +721,9 @@ out:
 	if (req)
 		ptlrpc_req_finished(req);
 
+	spin_lock(&d->opd_pre_lock);
 	d->opd_pre_recovering = 0;
+	spin_unlock(&d->opd_pre_lock);
 
 	/*
 	 * If rc is zero, the pre-creation window should have been emptied.
@@ -742,7 +741,7 @@ out:
 			 * this OSP isn't quite functional yet */
 			osp_pre_update_status(d, rc);
 		} else {
-			cfs_waitq_signal(&d->opd_pre_user_waitq);
+			wake_up(&d->opd_pre_user_waitq);
 		}
 	}
 
@@ -798,9 +797,11 @@ void osp_pre_update_status(struct osp_device *d, int rc)
 			       d->opd_syn_changes, d->opd_syn_rpc_in_progress);
 		} else if (old == -ENOSPC) {
 			d->opd_pre_status = 0;
+			spin_lock(&d->opd_pre_lock);
 			d->opd_pre_grow_slow = 0;
 			d->opd_pre_grow_count = OST_MIN_PRECREATE;
-			cfs_waitq_signal(&d->opd_pre_waitq);
+			spin_unlock(&d->opd_pre_lock);
+			wake_up(&d->opd_pre_waitq);
 			CDEBUG(D_INFO, "%s: no space: "LPU64" blocks, "LPU64
 			       " free, "LPU64" used, "LPU64" avail -> %d: "
 			       "rc = %d\n", d->opd_obd->obd_name,
@@ -810,10 +811,10 @@ void osp_pre_update_status(struct osp_device *d, int rc)
 	}
 
 out:
-	cfs_waitq_signal(&d->opd_pre_user_waitq);
+	wake_up(&d->opd_pre_user_waitq);
 }
 
-static int osp_init_pre_fid(struct osp_device *osp)
+int osp_init_pre_fid(struct osp_device *osp)
 {
 	struct lu_env		env;
 	struct osp_thread_info	*osi;
@@ -822,6 +823,8 @@ static int osp_init_pre_fid(struct osp_device *osp)
 	int			rc;
 	ENTRY;
 
+	LASSERT(osp->opd_pre != NULL);
+
 	/* Return if last_used fid has been initialized */
 	if (!fid_is_zero(&osp->opd_last_used_fid))
 		RETURN(0);
@@ -887,7 +890,7 @@ static int osp_precreate_thread(void *_arg)
 	spin_lock(&d->opd_pre_lock);
 	thread->t_flags = SVC_RUNNING;
 	spin_unlock(&d->opd_pre_lock);
-	cfs_waitq_signal(&thread->t_ctl_waitq);
+	wake_up(&thread->t_ctl_waitq);
 
 	while (osp_precreate_running(d)) {
 		/*
@@ -911,19 +914,18 @@ static int osp_precreate_thread(void *_arg)
 			break;
 
 		LASSERT(d->opd_obd->u.cli.cl_seq != NULL);
-		if (d->opd_obd->u.cli.cl_seq->lcs_exp == NULL) {
-			/* Get new sequence for client first */
-			LASSERT(d->opd_exp != NULL);
-			d->opd_obd->u.cli.cl_seq->lcs_exp =
-			class_export_get(d->opd_exp);
-			rc = osp_init_pre_fid(d);
-			if (rc != 0) {
-				class_export_put(d->opd_exp);
-				d->opd_obd->u.cli.cl_seq->lcs_exp = NULL;
-				CERROR("%s: init pre fid error: rc = %d\n",
-				       d->opd_obd->obd_name, rc);
-				continue;
-			}
+		/* Sigh, fid client is not ready yet */
+		if (d->opd_obd->u.cli.cl_seq->lcs_exp == NULL)
+			continue;
+
+		/* Init fid for osp_precreate if necessary */
+		rc = osp_init_pre_fid(d);
+		if (rc != 0) {
+			class_export_put(d->opd_exp);
+			d->opd_obd->u.cli.cl_seq->lcs_exp = NULL;
+			CERROR("%s: init pre fid error: rc = %d\n",
+			       d->opd_obd->obd_name, rc);
+			continue;
 		}
 
 		osp_statfs_update(d);
@@ -989,7 +991,7 @@ static int osp_precreate_thread(void *_arg)
 
 	thread->t_flags = SVC_STOPPED;
 	lu_env_fini(&env);
-	cfs_waitq_signal(&thread->t_ctl_waitq);
+	wake_up(&thread->t_ctl_waitq);
 
 	RETURN(0);
 }
@@ -1005,11 +1007,23 @@ static int osp_precreate_ready_condition(const struct lu_env *env,
 	if (d->opd_pre_reserved + 1 < osp_objs_precreated(env, d))
 		return 1;
 
-	/* ready if OST reported no space and no destoys in progress */
+	/* ready if OST reported no space and no destroys in progress */
 	if (d->opd_syn_changes + d->opd_syn_rpc_in_progress == 0 &&
 	    d->opd_pre_status == -ENOSPC)
 		return 1;
 
+	/* Bail out I/O fails to OST */
+	if (d->opd_pre_status != 0 &&
+	    d->opd_pre_status != -EAGAIN &&
+	    d->opd_pre_status != -ENODEV &&
+	    d->opd_pre_status != -ENOSPC) {
+		/* DEBUG LU-3230 */
+		if (d->opd_pre_status != -EIO)
+			CERROR("%s: precreate failed opd_pre_status %d\n",
+			       d->opd_obd->obd_name, d->opd_pre_status);
+		return 1;
+	}
+
 	return 0;
 }
 
@@ -1055,7 +1069,7 @@ int osp_precreate_reserve(const struct lu_env *env, struct osp_device *d)
 	 *  - OST can allocate fid sequence.
 	 */
 	while ((rc = d->opd_pre_status) == 0 || rc == -ENOSPC ||
-		rc == -ENODEV || rc == -EAGAIN) {
+		rc == -ENODEV || rc == -EAGAIN || rc == -ENOTCONN) {
 
 		/*
 		 * increase number of precreations
@@ -1081,7 +1095,7 @@ int osp_precreate_reserve(const struct lu_env *env, struct osp_device *d)
 			/* XXX: don't wake up if precreation is in progress */
 			if (osp_precreate_near_empty_nolock(env, d) &&
 			   !osp_precreate_end_seq_nolock(env, d))
-				cfs_waitq_signal(&d->opd_pre_waitq);
+				wake_up(&d->opd_pre_waitq);
 
 			break;
 		}
@@ -1110,7 +1124,7 @@ int osp_precreate_reserve(const struct lu_env *env, struct osp_device *d)
 		}
 
 		/* XXX: don't wake up if precreation is in progress */
-		cfs_waitq_signal(&d->opd_pre_waitq);
+		wake_up(&d->opd_pre_waitq);
 
 		lwi = LWI_TIMEOUT(expire - cfs_time_current(),
 				osp_precreate_timeout_condition, d);
@@ -1157,7 +1171,7 @@ int osp_precreate_get_fid(const struct lu_env *env, struct osp_device *d,
 	 * osp_precreate_thread() just before orphan cleanup
 	 */
 	if (unlikely(d->opd_pre_reserved == 0 && d->opd_pre_status))
-		cfs_waitq_signal(&d->opd_pre_waitq);
+		wake_up(&d->opd_pre_waitq);
 
 	return 0;
 }
@@ -1235,10 +1249,14 @@ out:
 int osp_init_precreate(struct osp_device *d)
 {
 	struct l_wait_info	 lwi = { 0 };
-	cfs_task_t		*task;
+	struct task_struct		*task;
 
 	ENTRY;
 
+	OBD_ALLOC_PTR(d->opd_pre);
+	if (d->opd_pre == NULL)
+		RETURN(-ENOMEM);
+
 	/* initially precreation isn't ready */
 	d->opd_pre_status = -EAGAIN;
 	fid_zero(&d->opd_pre_used_fid);
@@ -1253,9 +1271,9 @@ int osp_init_precreate(struct osp_device *d)
 	d->opd_pre_max_grow_count = OST_MAX_PRECREATE;
 
 	spin_lock_init(&d->opd_pre_lock);
-	cfs_waitq_init(&d->opd_pre_waitq);
-	cfs_waitq_init(&d->opd_pre_user_waitq);
-	cfs_waitq_init(&d->opd_pre_thread.t_ctl_waitq);
+	init_waitqueue_head(&d->opd_pre_waitq);
+	init_waitqueue_head(&d->opd_pre_user_waitq);
+	init_waitqueue_head(&d->opd_pre_thread.t_ctl_waitq);
 
 	/*
 	 * Initialize statfs-related things
@@ -1271,7 +1289,7 @@ int osp_init_precreate(struct osp_device *d)
 	 * start thread handling precreation and statfs updates
 	 */
 	task = kthread_run(osp_precreate_thread, d,
-			       "osp-pre-%u", d->opd_index);
+			   "osp-pre-%u-%u", d->opd_index, d->opd_group);
 	if (IS_ERR(task)) {
 		CERROR("can't start precreate thread %ld\n", PTR_ERR(task));
 		RETURN(PTR_ERR(task));
@@ -1286,16 +1304,24 @@ int osp_init_precreate(struct osp_device *d)
 
 void osp_precreate_fini(struct osp_device *d)
 {
-	struct ptlrpc_thread *thread = &d->opd_pre_thread;
+	struct ptlrpc_thread *thread;
 
 	ENTRY;
 
 	cfs_timer_disarm(&d->opd_statfs_timer);
 
+	if (d->opd_pre == NULL)
+		RETURN_EXIT;
+
+	thread = &d->opd_pre_thread;
+
 	thread->t_flags = SVC_STOPPING;
-	cfs_waitq_signal(&d->opd_pre_waitq);
+	wake_up(&d->opd_pre_waitq);
+
+	wait_event(thread->t_ctl_waitq, thread->t_flags & SVC_STOPPED);
 
-	cfs_wait_event(thread->t_ctl_waitq, thread->t_flags & SVC_STOPPED);
+	OBD_FREE_PTR(d->opd_pre);
+	d->opd_pre = NULL;
 
 	EXIT;
 }