Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S937668AbdLRRtM (ORCPT ); Mon, 18 Dec 2017 12:49:12 -0500 Received: from esa1.cray.iphmx.com ([68.232.142.33]:54773 "EHLO esa1.cray.iphmx.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S934541AbdLRRs7 (ORCPT ); Mon, 18 Dec 2017 12:48:59 -0500 X-IronPort-AV: E=Sophos;i="5.45,422,1508799600"; d="scan'208";a="17061592" X-Cray-OBMMKR: 1433258124 17061592 From: Patrick Farrell To: NeilBrown , Oleg Drokin , "Andreas Dilger" , James Simmons , Greg Kroah-Hartman CC: lkml , lustre Subject: Re: [lustre-devel] [PATCH 02/16] staging: lustre: replace simple cases of l_wait_event() with wait_event(). Thread-Topic: [lustre-devel] [PATCH 02/16] staging: lustre: replace simple cases of l_wait_event() with wait_event(). Thread-Index: AQHTd9CAK5NxI5nlZUWr+vBjNn31CqNI/LYA Date: Mon, 18 Dec 2017 17:48:53 +0000 Message-ID: References: <151358127190.5099.12792810096274074963.stgit@noble> <151358147981.5099.13114335078693829049.stgit@noble> In-Reply-To: <151358147981.5099.13114335078693829049.stgit@noble> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: user-agent: Microsoft-MacOutlook/14.7.2.170228 authentication-results: spf=none (sender IP is ) smtp.mailfrom=paf@cray.com; x-originating-ip: [136.162.2.1] x-ms-publictraffictype: Email x-microsoft-exchange-diagnostics: 1;MWHPR1101MB2144;6:apI833DZP4bpyVBQ65ivqc+zJ3cl5R4gDsXUlMvxorZLs1O1vW4VD7nPFcHfBdzlB7sv0HH6yUnO0QBokjpVtwtziBcmk/d2XOi9AdpG7PUmQw6RM41SEIoam/3yv9sjs42NM7LolgRAF7gCOfyVv5HmKNiNVMTrBnZ01ZozoIeOfg4IVuzTp0RMbydtMj4U2VXbTmyqAq8l8XL8UViMpsYuxp0pXuJ51eDDTHJEyMqVX675FrMWkW6dJ6wVjdSS1R4QFWV83QeewisqKbcFlUuKx5shG2yptCipsGB9CSa0FEAUG0t6rCMJWP+h5DaFGoKxfuo/tLBV4fXGO+k0nhp0P9Tim519ovRWID6yMZk=;5:22mkfd4UYKlHpfYK7H0tmPbxFXsEKbgoGgAwM/UnIanH4jm0AFBvzIsHvtxaGtUbgLS3ejKeZrCh9hrIL90Ab8mIGKMMwKRYbVO0n3/atz4e8W+gVrP1Y6o/O+qqvYWKqWXdLq4h5GuOoHGmUTbcis3EkkMG0KKjN+5T38pjvDE=;24:4Xl69nMvB2DXHjnGkLHT9S6jXzVGUlnJ5DDZ39DSTvkKEQXLOAC7VBgWk7annfoaRCp0A8KggI/HKOBa1FekCZyeXB821q7DxOh8+HSNOA4=;7:WJACLKm7out7iOl0FfmiFZtFmIUOjyK1NR+uwigBvOkPktJFtmdvMBUlWLPOcb6prwqrJeLFAcUcjCIG6R0VhZWZcqdoh8n2LRhk3OLXOjslAQv9daL8k+1BB6l4W2pm7PKGEZhepsGdtTy9b5W64Fwey1b8go/o19+pYKSBjMsolEE2LmBVjhvbz7QFLA/MyK0w/knFUec9N/7NA5oW7QsnytV21lEJ4n5Q+ubwizjccGvpXp2slhjlfVlbJSql x-ms-exchange-antispam-srfa-diagnostics: SSOS; x-ms-office365-filtering-correlation-id: 8430a974-5c01-4daf-9e0c-08d5463f9a86 x-microsoft-antispam: UriScan:;BCL:0;PCL:0;RULEID:(5600026)(4604075)(4534020)(4602075)(4627115)(201703031133081)(201702281549075)(2017052603307);SRVR:MWHPR1101MB2144; x-ms-traffictypediagnostic: MWHPR1101MB2144: x-microsoft-antispam-prvs: x-exchange-antispam-report-test: UriScan:(788757137089); x-exchange-antispam-report-cfa-test: BCL:0;PCL:0;RULEID:(6040450)(2401047)(8121501046)(5005006)(10201501046)(93006095)(93001095)(3002001)(3231023)(6041248)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123558100)(20161123555025)(20161123564025)(20161123562025)(20161123560025)(6072148)(201708071742011);SRVR:MWHPR1101MB2144;BCL:0;PCL:0;RULEID:(100000803101)(100110400095);SRVR:MWHPR1101MB2144; x-forefront-prvs: 0525BB0ADF x-forefront-antispam-report: SFV:NSPM;SFS:(10019020)(346002)(366004)(376002)(39850400004)(396003)(51914003)(24454002)(199004)(189003)(77096006)(6486002)(2900100001)(36756003)(66066001)(58126008)(316002)(6436002)(3280700002)(105586002)(54906003)(110136005)(25786009)(6306002)(4326008)(2906002)(3660700001)(6512007)(14454004)(229853002)(478600001)(5660300001)(6246003)(2950100002)(83506002)(76176011)(53946003)(59450400001)(99286004)(53936002)(305945005)(97736004)(86362001)(7736002)(575784001)(106356001)(68736007)(6116002)(102836003)(3846002)(8676002)(6506007)(8936002)(53546011)(81156014)(81166006)(13693001)(42262002)(579004);DIR:OUT;SFP:1102;SCL:1;SRVR:MWHPR1101MB2144;H:MWHPR1101MB2143.namprd11.prod.outlook.com;FPR:;SPF:None;PTR:InfoNoRecords;A:1;MX:1;LANG:en; spamdiagnosticoutput: 1:99 spamdiagnosticmetadata: NSPM Content-Type: text/plain; charset="Windows-1252" Content-ID: <80FA201E058B4E478FB9989BC2C9B302@namprd11.prod.outlook.com> MIME-Version: 1.0 X-MS-Exchange-CrossTenant-Network-Message-Id: 8430a974-5c01-4daf-9e0c-08d5463f9a86 X-MS-Exchange-CrossTenant-originalarrivaltime: 18 Dec 2017 17:48:53.0784 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: e7b8488a-c0cd-4614-aae1-996bfabec247 X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR1101MB2144 X-OriginatorOrg: cray.com Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from quoted-printable to 8bit by nfs id vBIHnIRS015354 Content-Length: 21977 Lines: 624 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" 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 >--- > 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@lists.lustre.org >http://lists.lustre.org/listinfo.cgi/lustre-devel-lustre.org