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

From: NeilBrown
Date: Mon Dec 18 2017 - 16:37:44 EST

Next message: Joe Perches: "Re: [PATCH 2/5] staging: rtl8712: style fix multiple line dereferences"
Previous message: Igor Stoppa: "[PATCH 1/1] genalloc: track beginning of allocations"
In reply to: Patrick Farrell: "Re: [lustre-devel] [PATCH 02/16] staging: lustre: replace simple cases of l_wait_event() with wait_event()."
Next in thread: Patrick Farrell: "Re: [lustre-devel] [PATCH 02/16] staging: lustre: replace simple cases of l_wait_event() with wait_event()."
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

On Mon, Dec 18 2017, Patrick Farrell wrote:

> 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.

I does take a while for these things to filter through. Maybe I should
examine all places that call flush_signals() and see which ones
really want to use TASK_IDLE (which is what I should have used, instead
of TASK_UNINTERRUPTIBLE | TASK_NOLOAD).

>
> 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?

Always hard to know how best to handle patch that affect multiple
subsystems.
Once I figure out what to do with l_wait_event_exclusive_head(),
I'll probably send any patches related to that together with the
wait_noload changes...
Though maybe I need to use swait_event_idle(). Time to learn about
"simple wait queues" I guess.

Thanks,
NeilBrown

>
> - Patrick
>
> On 12/18/17, 1:17 AM, "lustre-devel on behalf of NeilBrown"
> <lustre-devel-bounces@xxxxxxxxxxxxxxxx on behalf of neilb@xxxxxxxx> 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@xxxxxxxx>
>>---
>> 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@xxxxxxxxxxxxxxxx
>>http://lists.lustre.org/listinfo.cgi/lustre-devel-lustre.org

Attachment: signature.asc
Description: PGP signature

Next message: Joe Perches: "Re: [PATCH 2/5] staging: rtl8712: style fix multiple line dereferences"
Previous message: Igor Stoppa: "[PATCH 1/1] genalloc: track beginning of allocations"
In reply to: Patrick Farrell: "Re: [lustre-devel] [PATCH 02/16] staging: lustre: replace simple cases of l_wait_event() with wait_event()."
Next in thread: Patrick Farrell: "Re: [lustre-devel] [PATCH 02/16] staging: lustre: replace simple cases of l_wait_event() with wait_event()."
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]