[lustre-devel] [PATCH 02/16] staging: lustre: replace simple cases of l_wait_event() with wait_event().

[Patrick Farrell <paf@cray.com>]

Ah, finally we?ve got that NOLOAD flag!  This will clear up several nasty
bugs around ptrace and sigkill that come when waiting with signals blocked
in TASK_INTERRUPTIBLE.  I see it was added in 2015?  The joys of working
with vendor kernels.

Thanks for these, Neil.  I?ll try to take a careful look.

Given the description of the commit that added TASK_NOLOAD, I?m kind of
shocked to see it has almost no users in the kernel yet.  Just a few
callers of schedule_timeout_idle, it looks like.  Even so, why not put
those macros in sched.h to begin with?

- Patrick

On 12/18/17, 1:17 AM, "lustre-devel on behalf of NeilBrown"
<lustre-devel-bounces at lists.lustre.org on behalf of neilb@suse.com> wrote:

>When the lwi arg is full of zeros, l_wait_event() behaves almost
>identically to the standard wait_event() interface, so use that
>instead.
>
>The only difference in behavior is that l_wait_event() blocks all
>signals and uses an TASK_INTERRUPTIBLE wait, while wait_event()
>does not block signals, but waits in state TASK_UNINTERRUPTIBLE.
>This means that processes blocked in wait_event() will contribute
>to the load average.  This behavior is (arguably) more correct - in
>most cases.
>
>In some cases, the wait is in a service thread waiting for work to
>do.  In these case we should wait TASK_NOLOAD order with
>TASK_UNINTERRUPTIBLE.  To facilitate this, add a "wait_event_noload()"
>macro.  This should eventually be moved into include/linux/wait.h.
>
>There is one case where wait_event_exclusive_noload() is needed.
>So we add a macro for that too.
>
>Signed-off-by: NeilBrown <neilb@suse.com>
>---
> drivers/staging/lustre/lustre/include/lustre_lib.h |   47
>++++++++++++++++---
> drivers/staging/lustre/lustre/ldlm/ldlm_lock.c     |    4 --
> drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c    |    8 +--
> drivers/staging/lustre/lustre/ldlm/ldlm_pool.c     |    5 +-
> drivers/staging/lustre/lustre/llite/statahead.c    |   50
>++++++++------------
> drivers/staging/lustre/lustre/lov/lov_object.c     |    6 +-
> drivers/staging/lustre/lustre/mgc/mgc_request.c    |    4 --
> drivers/staging/lustre/lustre/obdclass/cl_io.c     |    6 +-
> drivers/staging/lustre/lustre/obdclass/genops.c    |   15 ++----
> drivers/staging/lustre/lustre/osc/osc_cache.c      |    5 +-
> drivers/staging/lustre/lustre/osc/osc_object.c     |    4 --
> drivers/staging/lustre/lustre/ptlrpc/pinger.c      |   10 ++--
> drivers/staging/lustre/lustre/ptlrpc/sec_gc.c      |   11 ++--
> drivers/staging/lustre/lustre/ptlrpc/service.c     |   13 ++---
> 14 files changed, 93 insertions(+), 95 deletions(-)
>
>diff --git a/drivers/staging/lustre/lustre/include/lustre_lib.h
>b/drivers/staging/lustre/lustre/include/lustre_lib.h
>index ca1dce15337e..08bdd618ea7d 100644
>--- a/drivers/staging/lustre/lustre/include/lustre_lib.h
>+++ b/drivers/staging/lustre/lustre/include/lustre_lib.h
>@@ -333,12 +333,6 @@ do {									   \
> 	__ret;						  \
> })
> 
>-#define l_wait_condition(wq, condition)			 \
>-({							      \
>-	struct l_wait_info lwi = { 0 };			 \
>-	l_wait_event(wq, condition, &lwi);		      \
>-})
>-
> #define l_wait_condition_exclusive(wq, condition)	       \
> ({							      \
> 	struct l_wait_info lwi = { 0 };			 \
>@@ -353,4 +347,45 @@ do {									   \
> 
> /** @} lib */
> 
>+#define __wait_event_noload(wq_head, condition)					\
>+	(void)___wait_event(wq_head, condition, (TASK_UNINTERRUPTIBLE |
>TASK_NOLOAD), 0, 0, \
>+			    schedule())
>+
>+/**
>+ * wait_event_noload - sleep, without registering load, until a
>condition gets true
>+ * @wq_head: the waitqueue to wait on
>+ * @condition: a C expression for the event to wait for
>+ *
>+ * The process is put to sleep (TASK_UNINTERRUPTIBLE|TASK_NOLOAD) until
>the
>+ * @condition evaluates to true. The @condition is checked each time
>+ * the waitqueue @wq_head is woken up.
>+ *
>+ * wake_up() has to be called after changing any variable that could
>+ * change the result of the wait condition.
>+ *
>+ * This can be used instead of wait_event() when the event
>+ * being waited for is does not imply load on the system, but
>+ * when responding to signals is no appropriate, such as in
>+ * a kernel service thread.
>+ */
>+#define wait_event_noload(wq_head, condition)					\
>+do {										\
>+	might_sleep();								\
>+	if (condition)								\
>+		break;								\
>+	__wait_event_noload(wq_head, condition);				\
>+} while (0)
>+
>+/*
>+ * Just like wait_event_noload(), except it sets exclusive flag
>+ */
>+#define wait_event_exclusive_noload(wq_head, condition)				\
>+do {										\
>+	if (condition)								\
>+		break;								\
>+	(void)___wait_event(wq_head, condition,					\
>+			    (TASK_UNINTERRUPTIBLE | TASK_NOLOAD), 1, 0,		\
>+			    schedule());					\
>+} while (0)
>+
> #endif /* _LUSTRE_LIB_H */
>diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
>b/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
>index 7cbc6a06afec..975fabc73148 100644
>--- a/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
>+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
>@@ -1913,14 +1913,12 @@ void ldlm_cancel_callback(struct ldlm_lock *lock)
> 		ldlm_set_bl_done(lock);
> 		wake_up_all(&lock->l_waitq);
> 	} else if (!ldlm_is_bl_done(lock)) {
>-		struct l_wait_info lwi = { 0 };
>-
> 		/*
> 		 * The lock is guaranteed to have been canceled once
> 		 * returning from this function.
> 		 */
> 		unlock_res_and_lock(lock);
>-		l_wait_event(lock->l_waitq, is_bl_done(lock), &lwi);
>+		wait_event(lock->l_waitq, is_bl_done(lock));
> 		lock_res_and_lock(lock);
> 	}
> }
>diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c
>b/drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c
>index 5f6e7c933b81..d9835418d340 100644
>--- a/drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c
>+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c
>@@ -833,17 +833,15 @@ static int ldlm_bl_thread_main(void *arg)
> 	/* cannot use bltd after this, it is only on caller's stack */
> 
> 	while (1) {
>-		struct l_wait_info lwi = { 0 };
> 		struct ldlm_bl_work_item *blwi = NULL;
> 		struct obd_export *exp = NULL;
> 		int rc;
> 
> 		rc = ldlm_bl_get_work(blp, &blwi, &exp);
> 		if (!rc)
>-			l_wait_event_exclusive(blp->blp_waitq,
>-					       ldlm_bl_get_work(blp, &blwi,
>-								&exp),
>-					       &lwi);
>+			wait_event_exclusive_noload(blp->blp_waitq,
>+						    ldlm_bl_get_work(blp, &blwi,
>+								     &exp));
> 		atomic_inc(&blp->blp_busy_threads);
> 
> 		if (ldlm_bl_thread_need_create(blp, blwi))
>diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
>b/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
>index 8563bd32befa..d562f90cee97 100644
>--- a/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
>+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
>@@ -1031,7 +1031,6 @@ static int ldlm_pools_thread_main(void *arg)
> 
> static int ldlm_pools_thread_start(void)
> {
>-	struct l_wait_info lwi = { 0 };
> 	struct task_struct *task;
> 
> 	if (ldlm_pools_thread)
>@@ -1052,8 +1051,8 @@ static int ldlm_pools_thread_start(void)
> 		ldlm_pools_thread = NULL;
> 		return PTR_ERR(task);
> 	}
>-	l_wait_event(ldlm_pools_thread->t_ctl_waitq,
>-		     thread_is_running(ldlm_pools_thread), &lwi);
>+	wait_event(ldlm_pools_thread->t_ctl_waitq,
>+		   thread_is_running(ldlm_pools_thread));
> 	return 0;
> }
> 
>diff --git a/drivers/staging/lustre/lustre/llite/statahead.c
>b/drivers/staging/lustre/lustre/llite/statahead.c
>index 90c7324575e4..39040916a043 100644
>--- a/drivers/staging/lustre/lustre/llite/statahead.c
>+++ b/drivers/staging/lustre/lustre/llite/statahead.c
>@@ -864,7 +864,6 @@ static int ll_agl_thread(void *arg)
> 	struct ll_sb_info	*sbi    = ll_i2sbi(dir);
> 	struct ll_statahead_info *sai;
> 	struct ptlrpc_thread *thread;
>-	struct l_wait_info	lwi    = { 0 };
> 
> 	sai = ll_sai_get(dir);
> 	thread = &sai->sai_agl_thread;
>@@ -885,10 +884,9 @@ static int ll_agl_thread(void *arg)
> 	wake_up(&thread->t_ctl_waitq);
> 
> 	while (1) {
>-		l_wait_event(thread->t_ctl_waitq,
>-			     !list_empty(&sai->sai_agls) ||
>-			     !thread_is_running(thread),
>-			     &lwi);
>+		wait_event_noload(thread->t_ctl_waitq,
>+				  !list_empty(&sai->sai_agls) ||
>+				  !thread_is_running(thread));
> 
> 		if (!thread_is_running(thread))
> 			break;
>@@ -932,7 +930,6 @@ static int ll_agl_thread(void *arg)
> static void ll_start_agl(struct dentry *parent, struct ll_statahead_info
>*sai)
> {
> 	struct ptlrpc_thread *thread = &sai->sai_agl_thread;
>-	struct l_wait_info    lwi    = { 0 };
> 	struct ll_inode_info  *plli;
> 	struct task_struct *task;
> 
>@@ -948,9 +945,8 @@ static void ll_start_agl(struct dentry *parent,
>struct ll_statahead_info *sai)
> 		return;
> 	}
> 
>-	l_wait_event(thread->t_ctl_waitq,
>-		     thread_is_running(thread) || thread_is_stopped(thread),
>-		     &lwi);
>+	wait_event(thread->t_ctl_waitq,
>+		   thread_is_running(thread) || thread_is_stopped(thread));
> }
> 
> /* statahead thread main function */
>@@ -968,7 +964,6 @@ static int ll_statahead_thread(void *arg)
> 	int		       first  = 0;
> 	int		       rc     = 0;
> 	struct md_op_data *op_data;
>-	struct l_wait_info	lwi    = { 0 };
> 
> 	sai = ll_sai_get(dir);
> 	sa_thread = &sai->sai_thread;
>@@ -1069,12 +1064,11 @@ static int ll_statahead_thread(void *arg)
> 
> 			/* wait for spare statahead window */
> 			do {
>-				l_wait_event(sa_thread->t_ctl_waitq,
>-					     !sa_sent_full(sai) ||
>-					     sa_has_callback(sai) ||
>-					     !list_empty(&sai->sai_agls) ||
>-					     !thread_is_running(sa_thread),
>-					     &lwi);
>+				wait_event(sa_thread->t_ctl_waitq,
>+					   !sa_sent_full(sai) ||
>+					   sa_has_callback(sai) ||
>+					   !list_empty(&sai->sai_agls) ||
>+					   !thread_is_running(sa_thread));
> 				sa_handle_callback(sai);
> 
> 				spin_lock(&lli->lli_agl_lock);
>@@ -1128,11 +1122,10 @@ static int ll_statahead_thread(void *arg)
> 	 * for file release to stop me.
> 	 */
> 	while (thread_is_running(sa_thread)) {
>-		l_wait_event(sa_thread->t_ctl_waitq,
>-			     sa_has_callback(sai) ||
>-			     !agl_list_empty(sai) ||
>-			     !thread_is_running(sa_thread),
>-			     &lwi);
>+		wait_event(sa_thread->t_ctl_waitq,
>+			   sa_has_callback(sai) ||
>+			   !agl_list_empty(sai) ||
>+			   !thread_is_running(sa_thread));
> 
> 		sa_handle_callback(sai);
> 	}
>@@ -1145,9 +1138,8 @@ static int ll_statahead_thread(void *arg)
> 
> 		CDEBUG(D_READA, "stop agl thread: sai %p pid %u\n",
> 		       sai, (unsigned int)agl_thread->t_pid);
>-		l_wait_event(agl_thread->t_ctl_waitq,
>-			     thread_is_stopped(agl_thread),
>-			     &lwi);
>+		wait_event(agl_thread->t_ctl_waitq,
>+			   thread_is_stopped(agl_thread));
> 	} else {
> 		/* Set agl_thread flags anyway. */
> 		thread_set_flags(agl_thread, SVC_STOPPED);
>@@ -1159,8 +1151,8 @@ static int ll_statahead_thread(void *arg)
> 	 */
> 	while (sai->sai_sent != sai->sai_replied) {
> 		/* in case we're not woken up, timeout wait */
>-		lwi = LWI_TIMEOUT(msecs_to_jiffies(MSEC_PER_SEC >> 3),
>-				  NULL, NULL);
>+		struct l_wait_info lwi = LWI_TIMEOUT(msecs_to_jiffies(MSEC_PER_SEC >>
>3),
>+						     NULL, NULL);
> 		l_wait_event(sa_thread->t_ctl_waitq,
> 			     sai->sai_sent == sai->sai_replied, &lwi);
> 	}
>@@ -1520,7 +1512,6 @@ static int start_statahead_thread(struct inode
>*dir, struct dentry *dentry)
> {
> 	struct ll_inode_info *lli = ll_i2info(dir);
> 	struct ll_statahead_info *sai = NULL;
>-	struct l_wait_info lwi = { 0 };
> 	struct ptlrpc_thread *thread;
> 	struct task_struct *task;
> 	struct dentry *parent = dentry->d_parent;
>@@ -1570,9 +1561,8 @@ static int start_statahead_thread(struct inode
>*dir, struct dentry *dentry)
> 		goto out;
> 	}
> 
>-	l_wait_event(thread->t_ctl_waitq,
>-		     thread_is_running(thread) || thread_is_stopped(thread),
>-		     &lwi);
>+	wait_event(thread->t_ctl_waitq,
>+		   thread_is_running(thread) || thread_is_stopped(thread));
> 	ll_sai_put(sai);
> 
> 	/*
>diff --git a/drivers/staging/lustre/lustre/lov/lov_object.c
>b/drivers/staging/lustre/lustre/lov/lov_object.c
>index 897cf2cd4a24..aa82f2ed40ae 100644
>--- a/drivers/staging/lustre/lustre/lov/lov_object.c
>+++ b/drivers/staging/lustre/lustre/lov/lov_object.c
>@@ -723,15 +723,13 @@ static void lov_conf_unlock(struct lov_object *lov)
> 
> static int lov_layout_wait(const struct lu_env *env, struct lov_object
>*lov)
> {
>-	struct l_wait_info lwi = { 0 };
>-
> 	while (atomic_read(&lov->lo_active_ios) > 0) {
> 		CDEBUG(D_INODE, "file:" DFID " wait for active IO, now: %d.\n",
> 		       PFID(lu_object_fid(lov2lu(lov))),
> 		       atomic_read(&lov->lo_active_ios));
> 
>-		l_wait_event(lov->lo_waitq,
>-			     atomic_read(&lov->lo_active_ios) == 0, &lwi);
>+		wait_event(lov->lo_waitq,
>+			   atomic_read(&lov->lo_active_ios) == 0);
> 	}
> 	return 0;
> }
>diff --git a/drivers/staging/lustre/lustre/mgc/mgc_request.c
>b/drivers/staging/lustre/lustre/mgc/mgc_request.c
>index 79ff85feab64..81b101941eec 100644
>--- a/drivers/staging/lustre/lustre/mgc/mgc_request.c
>+++ b/drivers/staging/lustre/lustre/mgc/mgc_request.c
>@@ -601,9 +601,7 @@ static int mgc_requeue_thread(void *data)
> 			config_log_put(cld_prev);
> 
> 		/* Wait a bit to see if anyone else needs a requeue */
>-		lwi = (struct l_wait_info) { 0 };
>-		l_wait_event(rq_waitq, rq_state & (RQ_NOW | RQ_STOP),
>-			     &lwi);
>+		wait_event(rq_waitq, rq_state & (RQ_NOW | RQ_STOP));
> 		spin_lock(&config_list_lock);
> 	}
> 
>diff --git a/drivers/staging/lustre/lustre/obdclass/cl_io.c
>b/drivers/staging/lustre/lustre/obdclass/cl_io.c
>index 6ec5218a18c1..a3fb2bbde70f 100644
>--- a/drivers/staging/lustre/lustre/obdclass/cl_io.c
>+++ b/drivers/staging/lustre/lustre/obdclass/cl_io.c
>@@ -1110,10 +1110,8 @@ int cl_sync_io_wait(const struct lu_env *env,
>struct cl_sync_io *anchor,
> 		CERROR("IO failed: %d, still wait for %d remaining entries\n",
> 		       rc, atomic_read(&anchor->csi_sync_nr));
> 
>-		lwi = (struct l_wait_info) { 0 };
>-		(void)l_wait_event(anchor->csi_waitq,
>-				   atomic_read(&anchor->csi_sync_nr) == 0,
>-				   &lwi);
>+		wait_event(anchor->csi_waitq,
>+			   atomic_read(&anchor->csi_sync_nr) == 0);
> 	} else {
> 		rc = anchor->csi_sync_rc;
> 	}
>diff --git a/drivers/staging/lustre/lustre/obdclass/genops.c
>b/drivers/staging/lustre/lustre/obdclass/genops.c
>index b1d6ba4a3190..78f0fa1dff45 100644
>--- a/drivers/staging/lustre/lustre/obdclass/genops.c
>+++ b/drivers/staging/lustre/lustre/obdclass/genops.c
>@@ -1237,12 +1237,10 @@ static int obd_zombie_is_idle(void)
>  */
> void obd_zombie_barrier(void)
> {
>-	struct l_wait_info lwi = { 0 };
>-
> 	if (obd_zombie_pid == current_pid())
> 		/* don't wait for myself */
> 		return;
>-	l_wait_event(obd_zombie_waitq, obd_zombie_is_idle(), &lwi);
>+	wait_event(obd_zombie_waitq, obd_zombie_is_idle());
> }
> EXPORT_SYMBOL(obd_zombie_barrier);
> 
>@@ -1257,10 +1255,8 @@ static int obd_zombie_impexp_thread(void *unused)
> 	obd_zombie_pid = current_pid();
> 
> 	while (!test_bit(OBD_ZOMBIE_STOP, &obd_zombie_flags)) {
>-		struct l_wait_info lwi = { 0 };
>-
>-		l_wait_event(obd_zombie_waitq,
>-			     !obd_zombie_impexp_check(NULL), &lwi);
>+		wait_event_noload(obd_zombie_waitq,
>+				  !obd_zombie_impexp_check(NULL));
> 		obd_zombie_impexp_cull();
> 
> 		/*
>@@ -1593,7 +1589,6 @@ static inline bool obd_mod_rpc_slot_avail(struct
>client_obd *cli,
> u16 obd_get_mod_rpc_slot(struct client_obd *cli, __u32 opc,
> 			 struct lookup_intent *it)
> {
>-	struct l_wait_info lwi = LWI_INTR(NULL, NULL);
> 	bool close_req = false;
> 	u16 i, max;
> 
>@@ -1631,8 +1626,8 @@ u16 obd_get_mod_rpc_slot(struct client_obd *cli,
>__u32 opc,
> 		CDEBUG(D_RPCTRACE, "%s: sleeping for a modify RPC slot opc %u, max
>%hu\n",
> 		       cli->cl_import->imp_obd->obd_name, opc, max);
> 
>-		l_wait_event(cli->cl_mod_rpcs_waitq,
>-			     obd_mod_rpc_slot_avail(cli, close_req), &lwi);
>+		wait_event(cli->cl_mod_rpcs_waitq,
>+			   obd_mod_rpc_slot_avail(cli, close_req));
> 	} while (true);
> }
> EXPORT_SYMBOL(obd_get_mod_rpc_slot);
>diff --git a/drivers/staging/lustre/lustre/osc/osc_cache.c
>b/drivers/staging/lustre/lustre/osc/osc_cache.c
>index 5767ac2a7d16..d58a25a2a5b4 100644
>--- a/drivers/staging/lustre/lustre/osc/osc_cache.c
>+++ b/drivers/staging/lustre/lustre/osc/osc_cache.c
>@@ -964,9 +964,8 @@ static int osc_extent_wait(const struct lu_env *env,
>struct osc_extent *ext,
> 				"%s: wait ext to %u timedout, recovery in progress?\n",
> 				cli_name(osc_cli(obj)), state);
> 
>-		lwi = LWI_INTR(NULL, NULL);
>-		rc = l_wait_event(ext->oe_waitq, extent_wait_cb(ext, state),
>-				  &lwi);
>+		wait_event(ext->oe_waitq, extent_wait_cb(ext, state));
>+		rc = 0;
> 	}
> 	if (rc == 0 && ext->oe_rc < 0)
> 		rc = ext->oe_rc;
>diff --git a/drivers/staging/lustre/lustre/osc/osc_object.c
>b/drivers/staging/lustre/lustre/osc/osc_object.c
>index f82c87a77550..1de25496a7d9 100644
>--- a/drivers/staging/lustre/lustre/osc/osc_object.c
>+++ b/drivers/staging/lustre/lustre/osc/osc_object.c
>@@ -454,12 +454,10 @@ struct lu_object *osc_object_alloc(const struct
>lu_env *env,
> 
> int osc_object_invalidate(const struct lu_env *env, struct osc_object
>*osc)
> {
>-	struct l_wait_info lwi = { 0 };
>-
> 	CDEBUG(D_INODE, "Invalidate osc object: %p, # of active IOs: %d\n",
> 	       osc, atomic_read(&osc->oo_nr_ios));
> 
>-	l_wait_event(osc->oo_io_waitq, !atomic_read(&osc->oo_nr_ios), &lwi);
>+	wait_event(osc->oo_io_waitq, !atomic_read(&osc->oo_nr_ios));
> 
> 	/* Discard all dirty pages of this object. */
> 	osc_cache_truncate_start(env, osc, 0, NULL);
>diff --git a/drivers/staging/lustre/lustre/ptlrpc/pinger.c
>b/drivers/staging/lustre/lustre/ptlrpc/pinger.c
>index fe6b47bfe8be..4148a6661dcf 100644
>--- a/drivers/staging/lustre/lustre/ptlrpc/pinger.c
>+++ b/drivers/staging/lustre/lustre/ptlrpc/pinger.c
>@@ -291,7 +291,6 @@ static struct ptlrpc_thread pinger_thread;
> 
> int ptlrpc_start_pinger(void)
> {
>-	struct l_wait_info lwi = { 0 };
> 	struct task_struct *task;
> 	int rc;
> 
>@@ -310,8 +309,8 @@ int ptlrpc_start_pinger(void)
> 		CERROR("cannot start pinger thread: rc = %d\n", rc);
> 		return rc;
> 	}
>-	l_wait_event(pinger_thread.t_ctl_waitq,
>-		     thread_is_running(&pinger_thread), &lwi);
>+	wait_event(pinger_thread.t_ctl_waitq,
>+		   thread_is_running(&pinger_thread));
> 
> 	return 0;
> }
>@@ -320,7 +319,6 @@ static int ptlrpc_pinger_remove_timeouts(void);
> 
> int ptlrpc_stop_pinger(void)
> {
>-	struct l_wait_info lwi = { 0 };
> 	int rc = 0;
> 
> 	if (thread_is_init(&pinger_thread) ||
>@@ -331,8 +329,8 @@ int ptlrpc_stop_pinger(void)
> 	thread_set_flags(&pinger_thread, SVC_STOPPING);
> 	wake_up(&pinger_thread.t_ctl_waitq);
> 
>-	l_wait_event(pinger_thread.t_ctl_waitq,
>-		     thread_is_stopped(&pinger_thread), &lwi);
>+	wait_event(pinger_thread.t_ctl_waitq,
>+		   thread_is_stopped(&pinger_thread));
> 
> 	return rc;
> }
>diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c
>b/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c
>index d85c8638c009..e4197a60d1e2 100644
>--- a/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c
>+++ b/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c
>@@ -197,7 +197,6 @@ static int sec_gc_main(void *arg)
> 
> int sptlrpc_gc_init(void)
> {
>-	struct l_wait_info lwi = { 0 };
> 	struct task_struct *task;
> 
> 	mutex_init(&sec_gc_mutex);
>@@ -214,18 +213,16 @@ int sptlrpc_gc_init(void)
> 		return PTR_ERR(task);
> 	}
> 
>-	l_wait_event(sec_gc_thread.t_ctl_waitq,
>-		     thread_is_running(&sec_gc_thread), &lwi);
>+	wait_event(sec_gc_thread.t_ctl_waitq,
>+		   thread_is_running(&sec_gc_thread));
> 	return 0;
> }
> 
> void sptlrpc_gc_fini(void)
> {
>-	struct l_wait_info lwi = { 0 };
>-
> 	thread_set_flags(&sec_gc_thread, SVC_STOPPING);
> 	wake_up(&sec_gc_thread.t_ctl_waitq);
> 
>-	l_wait_event(sec_gc_thread.t_ctl_waitq,
>-		     thread_is_stopped(&sec_gc_thread), &lwi);
>+	wait_event(sec_gc_thread.t_ctl_waitq,
>+		   thread_is_stopped(&sec_gc_thread));
> }
>diff --git a/drivers/staging/lustre/lustre/ptlrpc/service.c
>b/drivers/staging/lustre/lustre/ptlrpc/service.c
>index 63be6e7273f3..d688cb3ff157 100644
>--- a/drivers/staging/lustre/lustre/ptlrpc/service.c
>+++ b/drivers/staging/lustre/lustre/ptlrpc/service.c
>@@ -2233,7 +2233,7 @@ static int ptlrpc_hr_main(void *arg)
> 	wake_up(&ptlrpc_hr.hr_waitq);
> 
> 	while (!ptlrpc_hr.hr_stopping) {
>-		l_wait_condition(hrt->hrt_waitq, hrt_dont_sleep(hrt, &replies));
>+		wait_event_noload(hrt->hrt_waitq, hrt_dont_sleep(hrt, &replies));
> 
> 		while (!list_empty(&replies)) {
> 			struct ptlrpc_reply_state *rs;
>@@ -2312,7 +2312,6 @@ static int ptlrpc_start_hr_threads(void)
> 
> static void ptlrpc_svcpt_stop_threads(struct ptlrpc_service_part *svcpt)
> {
>-	struct l_wait_info lwi = { 0 };
> 	struct ptlrpc_thread *thread;
> 	LIST_HEAD(zombie);
> 
>@@ -2341,8 +2340,8 @@ static void ptlrpc_svcpt_stop_threads(struct
>ptlrpc_service_part *svcpt)
> 
> 		CDEBUG(D_INFO, "waiting for stopping-thread %s #%u\n",
> 		       svcpt->scp_service->srv_thread_name, thread->t_id);
>-		l_wait_event(thread->t_ctl_waitq,
>-			     thread_is_stopped(thread), &lwi);
>+		wait_event(thread->t_ctl_waitq,
>+			   thread_is_stopped(thread));
> 
> 		spin_lock(&svcpt->scp_lock);
> 	}
>@@ -2403,7 +2402,6 @@ int ptlrpc_start_threads(struct ptlrpc_service *svc)
> 
> int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait)
> {
>-	struct l_wait_info lwi = { 0 };
> 	struct ptlrpc_thread *thread;
> 	struct ptlrpc_service *svc;
> 	struct task_struct *task;
>@@ -2499,9 +2497,8 @@ int ptlrpc_start_thread(struct ptlrpc_service_part
>*svcpt, int wait)
> 	if (!wait)
> 		return 0;
> 
>-	l_wait_event(thread->t_ctl_waitq,
>-		     thread_is_running(thread) || thread_is_stopped(thread),
>-		     &lwi);
>+	wait_event(thread->t_ctl_waitq,
>+		   thread_is_running(thread) || thread_is_stopped(thread));
> 
> 	rc = thread_is_stopped(thread) ? thread->t_id : 0;
> 	return rc;
>
>
>_______________________________________________
>lustre-devel mailing list
>lustre-devel at lists.lustre.org
>http://lists.lustre.org/listinfo.cgi/lustre-devel-lustre.org