LU-6142 lustre: use list_first/last_entry() for list heads

This patch changes
    list_entry(foo.next, ...)
to
    list_first_entry(&foo, ...)
and
    list_entry(foo.prev, ...)
to
    list_last_entry(&foo, ...)

in cases where 'foo' is a list head - not a list member.

Test-Parameters: trivial
Signed-off-by: Mr NeilBrown <neilb@suse.de>
Change-Id: I22b1278f5b481ce3074db3e59d37d9148016aed5
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/50828
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Arshad Hussain <arshad.hussain@aeoncomputing.com>
Reviewed-by: James Simmons <jsimmons@infradead.org>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/fld/fld_request.c b/lustre/fld/fld_request.c
index 8148ad7..5210efe 100644 (file)
--- a/lustre/fld/fld_request.c
+++ b/lustre/fld/fld_request.c
@@ -492,7 +492,7 @@ again:
                                                  struct lu_fld_target,
                                                  ft_chain);
                else
-                       target = list_entry(target->ft_chain.next,
+                       target = list_first_entry(&target->ft_chain,
                                                 struct lu_fld_target,
                                                 ft_chain);
                spin_unlock(&fld->lcf_lock);

diff --git a/lustre/ldlm/ldlm_internal.h b/lustre/ldlm/ldlm_internal.h
index 517ab60..dd90ea2 100644 (file)
--- a/lustre/ldlm/ldlm_internal.h
+++ b/lustre/ldlm/ldlm_internal.h
@@ -241,8 +241,8 @@ ldlm_interval_extent(struct ldlm_interval *node)
         struct ldlm_lock *lock;
        LASSERT(!list_empty(&node->li_group));
 
-       lock = list_entry(node->li_group.next, struct ldlm_lock,
-                              l_sl_policy);
+       lock = list_first_entry(&node->li_group, struct ldlm_lock,
+                               l_sl_policy);
         return &lock->l_policy_data.l_extent;
 }
 

diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c
index 995073d..c20d102 100644 (file)
--- a/lustre/ldlm/ldlm_lib.c
+++ b/lustre/ldlm/ldlm_lib.c
@@ -805,8 +805,9 @@ int server_disconnect_export(struct obd_export *exp)
        spin_lock(&exp->exp_lock);
        while (!list_empty(&exp->exp_outstanding_replies)) {
                struct ptlrpc_reply_state *rs =
-                       list_entry(exp->exp_outstanding_replies.next,
-                                      struct ptlrpc_reply_state, rs_exp_list);
+                       list_first_entry(&exp->exp_outstanding_replies,
+                                        struct ptlrpc_reply_state,
+                                        rs_exp_list);
                struct ptlrpc_service_part *svcpt = rs->rs_svcpt;
 
                spin_lock(&svcpt->scp_rep_lock);
@@ -2118,8 +2119,8 @@ static int check_for_next_transno(struct lu_target *lut)
 
        spin_lock(&obd->obd_recovery_task_lock);
        if (!list_empty(&obd->obd_req_replay_queue)) {
-               req = list_entry(obd->obd_req_replay_queue.next,
-                                    struct ptlrpc_request, rq_list);
+               req = list_first_entry(&obd->obd_req_replay_queue,
+                                      struct ptlrpc_request, rq_list);
                req_transno = lustre_msg_get_transno(req->rq_reqmsg);
        }
 
@@ -2366,8 +2367,8 @@ static struct ptlrpc_request *target_next_replay_lock(struct lu_target *lut)
 
        spin_lock(&obd->obd_recovery_task_lock);
        if (!list_empty(&obd->obd_lock_replay_queue)) {
-               req = list_entry(obd->obd_lock_replay_queue.next,
-                                    struct ptlrpc_request, rq_list);
+               req = list_first_entry(&obd->obd_lock_replay_queue,
+                                      struct ptlrpc_request, rq_list);
                list_del_init(&req->rq_list);
                spin_unlock(&obd->obd_recovery_task_lock);
        } else {
@@ -2386,8 +2387,8 @@ static struct ptlrpc_request *target_next_final_ping(struct obd_device *obd)
 
        spin_lock(&obd->obd_recovery_task_lock);
        if (!list_empty(&obd->obd_final_req_queue)) {
-               req = list_entry(obd->obd_final_req_queue.next,
-                                    struct ptlrpc_request, rq_list);
+               req = list_first_entry(&obd->obd_final_req_queue,
+                                      struct ptlrpc_request, rq_list);
                list_del_init(&req->rq_list);
                spin_unlock(&obd->obd_recovery_task_lock);
                if (req->rq_export->exp_in_recovery) {
@@ -2509,8 +2510,8 @@ static __u64 get_next_replay_req_transno(struct obd_device *obd)
        if (!list_empty(&obd->obd_req_replay_queue)) {
                struct ptlrpc_request *req;
 
-               req = list_entry(obd->obd_req_replay_queue.next,
-                                struct ptlrpc_request, rq_list);
+               req = list_first_entry(&obd->obd_req_replay_queue,
+                                      struct ptlrpc_request, rq_list);
                transno = lustre_msg_get_transno(req->rq_reqmsg);
        }
 
@@ -2642,8 +2643,8 @@ static void replay_request_or_update(struct lu_env *env,
                         * replay has been executed by update with the
                         * same transno
                         */
-                       req = list_entry(obd->obd_req_replay_queue.next,
-                                       struct ptlrpc_request, rq_list);
+                       req = list_first_entry(&obd->obd_req_replay_queue,
+                                              struct ptlrpc_request, rq_list);
 
                        list_del_init(&req->rq_list);
                        obd->obd_requests_queued_for_recovery--;

diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c
index 00fcb77..df40beb 100644 (file)
--- a/lustre/ldlm/ldlm_lock.c
+++ b/lustre/ldlm/ldlm_lock.c
@@ -2647,8 +2647,8 @@ int ldlm_export_cancel_blocked_locks(struct obd_export *exp)
 
                spin_lock_bh(&exp->exp_bl_list_lock);
                if (!list_empty(&exp->exp_bl_list)) {
-                       lock = list_entry(exp->exp_bl_list.next,
-                                         struct ldlm_lock, l_exp_list);
+                       lock = list_first_entry(&exp->exp_bl_list,
+                                               struct ldlm_lock, l_exp_list);
                        LDLM_LOCK_GET(lock);
                        list_del_init(&lock->l_exp_list);
                } else {

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 3c164f0..f1c7b5a 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -324,8 +324,8 @@ static void waiting_locks_callback(TIMER_DATA_TYPE unused)
 
        spin_lock_bh(&waiting_locks_spinlock);
        while (!list_empty(&waiting_locks_list)) {
-               lock = list_entry(waiting_locks_list.next, struct ldlm_lock,
-                                 l_pending_chain);
+               lock = list_first_entry(&waiting_locks_list, struct ldlm_lock,
+                                       l_pending_chain);
                if (lock->l_callback_timestamp > ktime_get_seconds() ||
                    lock->l_req_mode == LCK_GROUP)
                        break;
@@ -354,8 +354,8 @@ static void waiting_locks_callback(TIMER_DATA_TYPE unused)
                time64_t now = ktime_get_seconds();
                timeout_t delta = 0;
 
-               lock = list_entry(waiting_locks_list.next, struct ldlm_lock,
-                                 l_pending_chain);
+               lock = list_first_entry(&waiting_locks_list, struct ldlm_lock,
+                                       l_pending_chain);
                if (lock->l_callback_timestamp - now > 0)
                        delta = lock->l_callback_timestamp - now;
                mod_timer(&waiting_locks_timer,

diff --git a/lustre/lfsck/lfsck_engine.c b/lustre/lfsck/lfsck_engine.c
index 8d4e380..19564d6 100644 (file)
--- a/lustre/lfsck/lfsck_engine.c
+++ b/lustre/lfsck/lfsck_engine.c
@@ -586,8 +586,8 @@ static int lfsck_post(const struct lu_env *env, struct lfsck_instance *lfsck,
                struct lfsck_lmv_unit *llu;
 
                spin_lock(&lfsck->li_lock);
-               llu = list_entry(lfsck->li_list_lmv.next,
-                                struct lfsck_lmv_unit, llu_link);
+               llu = list_first_entry(&lfsck->li_list_lmv,
+                                      struct lfsck_lmv_unit, llu_link);
                list_del_init(&llu->llu_link);
                spin_unlock(&lfsck->li_lock);
 
@@ -863,8 +863,8 @@ static int lfsck_master_oit_engine(const struct lu_env *env,
                        struct lfsck_lmv_unit *llu;
 
                        spin_lock(&lfsck->li_lock);
-                       llu = list_entry(lfsck->li_list_lmv.next,
-                                        struct lfsck_lmv_unit, llu_link);
+                       llu = list_first_entry(&lfsck->li_list_lmv,
+                                              struct lfsck_lmv_unit, llu_link);
                        list_del_init(&llu->llu_link);
                        spin_unlock(&lfsck->li_lock);
 
@@ -1490,17 +1490,17 @@ again:
                        __u32            *gen;
 
                        if (com->lc_type == LFSCK_TYPE_LAYOUT) {
-                               ltd = list_entry(lad->lad_mdt_list.next,
-                                                struct lfsck_tgt_desc,
-                                                ltd_layout_list);
+                               ltd = list_first_entry(&lad->lad_mdt_list,
+                                                      struct lfsck_tgt_desc,
+                                                      ltd_layout_list);
                                list = &ltd->ltd_layout_list;
                                gen = &ltd->ltd_layout_gen;
                        } else {
                                struct lfsck_namespace *ns = com->lc_file_ram;
 
-                               ltd = list_entry(lad->lad_mdt_list.next,
-                                                struct lfsck_tgt_desc,
-                                                ltd_namespace_list);
+                               ltd = list_first_entry(&lad->lad_mdt_list,
+                                                      struct lfsck_tgt_desc,
+                                                      ltd_namespace_list);
                                list = &ltd->ltd_namespace_list;
                                gen = &ltd->ltd_namespace_gen;
                                lr->lr_flags2 = ns->ln_flags & ~LF_INCOMPLETE;
@@ -1611,9 +1611,9 @@ int lfsck_assistant_engine(void *args)
                                     !thread_is_running(mthread)))
                                GOTO(cleanup, rc = lad->lad_post_result);
 
-                       lar = list_entry(lad->lad_req_list.next,
-                                        struct lfsck_assistant_req,
-                                        lar_list);
+                       lar = list_first_entry(&lad->lad_req_list,
+                                              struct lfsck_assistant_req,
+                                              lar_list);
                        /* Only the lfsck_assistant_engine thread itself can
                         * remove the "lar" from the head of the list, LFSCK
                         * engine thread only inserts other new "lar" at the
@@ -1754,9 +1754,9 @@ cleanup:
 
        thread_set_flags(athread, SVC_STOPPING);
        while (!list_empty(&lad->lad_req_list)) {
-               lar = list_entry(lad->lad_req_list.next,
-                                struct lfsck_assistant_req,
-                                lar_list);
+               lar = list_first_entry(&lad->lad_req_list,
+                                      struct lfsck_assistant_req,
+                                      lar_list);
                list_del_init(&lar->lar_list);
                lad->lad_prefetched--;
                spin_unlock(&lad->lad_lock);

diff --git a/lustre/lfsck/lfsck_layout.c b/lustre/lfsck/lfsck_layout.c
index f2f2a16..58637ce 100644 (file)
--- a/lustre/lfsck/lfsck_layout.c
+++ b/lustre/lfsck/lfsck_layout.c
@@ -4757,9 +4757,9 @@ static int lfsck_layout_assistant_handler_p2(const struct lu_env *env,
 
        spin_lock(&ltds->ltd_lock);
        while (!list_empty(&lad->lad_ost_phase2_list)) {
-               ltd = list_entry(lad->lad_ost_phase2_list.next,
-                                struct lfsck_tgt_desc,
-                                ltd_layout_phase_list);
+               ltd = list_first_entry(&lad->lad_ost_phase2_list,
+                                      struct lfsck_tgt_desc,
+                                      ltd_layout_phase_list);
                list_del_init(&ltd->ltd_layout_phase_list);
                if (bk->lb_param & LPF_OST_ORPHAN) {
                        spin_unlock(&ltds->ltd_lock);
@@ -4955,9 +4955,9 @@ lfsck_layout_slave_query_master(const struct lu_env *env,
        llsd->llsd_touch_gen++;
        spin_lock(&llsd->llsd_lock);
        while (!list_empty(&llsd->llsd_master_list)) {
-               llst = list_entry(llsd->llsd_master_list.next,
-                                 struct lfsck_layout_slave_target,
-                                 llst_list);
+               llst = list_first_entry(&llsd->llsd_master_list,
+                                       struct lfsck_layout_slave_target,
+                                       llst_list);
                if (llst->llst_gen == llsd->llsd_touch_gen)
                        break;
 
@@ -5035,9 +5035,9 @@ lfsck_layout_slave_notify_master(const struct lu_env *env,
        llsd->llsd_touch_gen++;
        spin_lock(&llsd->llsd_lock);
        while (!list_empty(&llsd->llsd_master_list)) {
-               llst = list_entry(llsd->llsd_master_list.next,
-                                 struct lfsck_layout_slave_target,
-                                 llst_list);
+               llst = list_first_entry(&llsd->llsd_master_list,
+                                       struct lfsck_layout_slave_target,
+                                       llst_list);
                if (llst->llst_gen == llsd->llsd_touch_gen)
                        break;
 
@@ -6575,8 +6575,9 @@ static void lfsck_layout_slave_quit(const struct lu_env *env,
 
        spin_lock(&llsd->llsd_lock);
        while (!list_empty(&llsd->llsd_master_list)) {
-               llst = list_entry(llsd->llsd_master_list.next,
-                                 struct lfsck_layout_slave_target, llst_list);
+               llst = list_first_entry(&llsd->llsd_master_list,
+                                       struct lfsck_layout_slave_target,
+                                       llst_list);
                list_del_init(&llst->llst_list);
                spin_unlock(&llsd->llsd_lock);
                lfsck_layout_llst_put(llst);
@@ -6988,9 +6989,9 @@ static void lfsck_layout_assistant_fill_pos(const struct lu_env *env,
        if (list_empty(&lad->lad_req_list))
                return;
 
-       llr = list_entry(lad->lad_req_list.next,
-                        struct lfsck_layout_req,
-                        llr_lar.lar_list);
+       llr = list_first_entry(&lad->lad_req_list,
+                              struct lfsck_layout_req,
+                              llr_lar.lar_list);
        pos->lp_oit_cookie = llr->llr_lar.lar_parent->lso_oit_cookie - 1;
 }
 

diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c
index c2115a3..bb69561 100644 (file)
--- a/lustre/lfsck/lfsck_lib.c
+++ b/lustre/lfsck/lfsck_lib.c
@@ -260,9 +260,9 @@ again:
 
        down_write(&ltds->ltd_rw_sem);
        while (!list_empty(&ltds->ltd_orphan)) {
-               ltd = list_entry(ltds->ltd_orphan.next,
-                                struct lfsck_tgt_desc,
-                                ltd_orphan_list);
+               ltd = list_first_entry(&ltds->ltd_orphan,
+                                      struct lfsck_tgt_desc,
+                                      ltd_orphan_list);
                list_del_init(&ltd->ltd_orphan_list);
                rc = __lfsck_add_target(env, lfsck, ltd, for_ost, true);
                /* Do not hold the semaphore for too long time. */

diff --git a/lustre/lfsck/lfsck_namespace.c b/lustre/lfsck/lfsck_namespace.c
index 08dc908..328b0e3 100644 (file)
--- a/lustre/lfsck/lfsck_namespace.c
+++ b/lustre/lfsck/lfsck_namespace.c
@@ -4182,8 +4182,8 @@ static void lfsck_namespace_release_lmv(const struct lu_env *env,
                struct lfsck_lmv_unit   *llu;
                struct lfsck_lmv        *llmv;
 
-               llu = list_entry(lfsck->li_list_lmv.next,
-                                struct lfsck_lmv_unit, llu_link);
+               llu = list_first_entry(&lfsck->li_list_lmv,
+                                      struct lfsck_lmv_unit, llu_link);
                llmv = &llu->llu_lmv;
 
                LASSERTF(atomic_read(&llmv->ll_ref) == 1,
@@ -6523,8 +6523,8 @@ out:
                RETURN(1);
 
        spin_lock(&lad->lad_lock);
-       lar = list_entry(lad->lad_req_list.next, struct lfsck_assistant_req,
-                         lar_list);
+       lar = list_first_entry(&lad->lad_req_list, struct lfsck_assistant_req,
+                              lar_list);
        list_del_init(&lar->lar_list);
        spin_unlock(&lad->lad_lock);
 
@@ -6675,8 +6675,8 @@ static int lfsck_namespace_assistant_handler_p2(const struct lu_env *env,
                struct lfsck_lmv_unit *llu;
 
                spin_lock(&lfsck->li_lock);
-               llu = list_entry(lfsck->li_list_lmv.next,
-                                struct lfsck_lmv_unit, llu_link);
+               llu = list_first_entry(&lfsck->li_list_lmv,
+                                      struct lfsck_lmv_unit, llu_link);
                list_del_init(&llu->llu_link);
                spin_unlock(&lfsck->li_lock);
 
@@ -6723,9 +6723,9 @@ static void lfsck_namespace_assistant_fill_pos(const struct lu_env *env,
        if (list_empty(&lad->lad_req_list))
                return;
 
-       lnr = list_entry(lad->lad_req_list.next,
-                        struct lfsck_namespace_req,
-                        lnr_lar.lar_list);
+       lnr = list_first_entry(&lad->lad_req_list,
+                              struct lfsck_namespace_req,
+                              lnr_lar.lar_list);
        pos->lp_oit_cookie = lnr->lnr_lar.lar_parent->lso_oit_cookie;
        pos->lp_dir_cookie = lnr->lnr_dir_cookie - 1;
        pos->lp_dir_parent = lnr->lnr_lar.lar_parent->lso_fid;

diff --git a/lustre/mgs/mgs_barrier.c b/lustre/mgs/mgs_barrier.c
index d6c1bd7..75ab5ae 100644 (file)
--- a/lustre/mgs/mgs_barrier.c
+++ b/lustre/mgs/mgs_barrier.c
@@ -161,7 +161,7 @@ again:
                list_add_tail(&work->gl_list, &gl_list);
        }
 
-       work = list_entry(gl_list.next, struct ldlm_glimpse_work, gl_list);
+       work = list_first_entry(&gl_list, struct ldlm_glimpse_work, gl_list);
 
        lock_res(res);
        list_for_each(pos, &res->lr_granted) {

diff --git a/lustre/mgs/mgs_nids.c b/lustre/mgs/mgs_nids.c
index be7fae1..d9fdd36 100644 (file)
--- a/lustre/mgs/mgs_nids.c
+++ b/lustre/mgs/mgs_nids.c
@@ -372,7 +372,8 @@ static void mgs_nidtbl_fini_fs(struct fs_db *fsdb)
        while (!list_empty(&head)) {
                struct mgs_nidtbl_target *tgt;
 
-               tgt = list_entry(head.next, struct mgs_nidtbl_target, mnt_list);
+               tgt = list_first_entry(&head, struct mgs_nidtbl_target,
+                                      mnt_list);
                list_del(&tgt->mnt_list);
                OBD_FREE_PTR(tgt);
        }

diff --git a/lustre/obdclass/lprocfs_status_server.c b/lustre/obdclass/lprocfs_status_server.c
index a979216..e374e3c 100644 (file)
--- a/lustre/obdclass/lprocfs_status_server.c
+++ b/lustre/obdclass/lprocfs_status_server.c
@@ -333,8 +333,8 @@ void lprocfs_free_per_client_stats(struct obd_device *obd)
        /* we need extra list - because hash_exit called to early */
        /* not need locking because all clients is died */
        while (!list_empty(&obd->obd_nid_stats)) {
-               stat = list_entry(obd->obd_nid_stats.next,
-                                 struct nid_stat, nid_list);
+               stat = list_first_entry(&obd->obd_nid_stats,
+                                       struct nid_stat, nid_list);
                list_del_init(&stat->nid_list);
                cfs_hash_del(hash, &stat->nid, &stat->nid_hash);
                lprocfs_free_client_stats(stat);
@@ -532,8 +532,8 @@ lprocfs_nid_stats_clear_seq_write(struct file *file, const char __user *buffer,
                          lprocfs_nid_stats_clear_write_cb, &free_list);
 
        while (!list_empty(&free_list)) {
-               client_stat = list_entry(free_list.next, struct nid_stat,
-                                        nid_list);
+               client_stat = list_first_entry(&free_list, struct nid_stat,
+                                              nid_list);
                list_del_init(&client_stat->nid_list);
                lprocfs_free_client_stats(client_stat);
        }

diff --git a/lustre/ofd/ofd_io.c b/lustre/ofd/ofd_io.c
index fc40364..a7583cc 100644 (file)
--- a/lustre/ofd/ofd_io.c
+++ b/lustre/ofd/ofd_io.c
@@ -187,9 +187,9 @@ static int ofd_inconsistency_verification_main(void *_args)
 
                while (!list_empty(&ofd->ofd_inconsistency_list)) {
                        __set_current_state(TASK_RUNNING);
-                       oii = list_entry(ofd->ofd_inconsistency_list.next,
-                                        struct ofd_inconsistency_item,
-                                        oii_list);
+                       oii = list_first_entry(&ofd->ofd_inconsistency_list,
+                                              struct ofd_inconsistency_item,
+                                              oii_list);
                        list_del_init(&oii->oii_list);
                        spin_unlock(&ofd->ofd_inconsistency_lock);
                        ofd_inconsistency_verify_one(env, ofd, oii, lrl);
@@ -205,9 +205,9 @@ static int ofd_inconsistency_verification_main(void *_args)
        while (!list_empty(&ofd->ofd_inconsistency_list)) {
                struct ofd_object *fo;
 
-               oii = list_entry(ofd->ofd_inconsistency_list.next,
-                                struct ofd_inconsistency_item,
-                                oii_list);
+               oii = list_first_entry(&ofd->ofd_inconsistency_list,
+                                      struct ofd_inconsistency_item,
+                                      oii_list);
                list_del_init(&oii->oii_list);
                fo = oii->oii_obj;
                spin_unlock(&ofd->ofd_inconsistency_lock);

diff --git a/lustre/osd-ldiskfs/osd_scrub.c b/lustre/osd-ldiskfs/osd_scrub.c
index 3a125ab..81d25e0 100644 (file)
--- a/lustre/osd-ldiskfs/osd_scrub.c
+++ b/lustre/osd-ldiskfs/osd_scrub.c
@@ -827,8 +827,9 @@ static int osd_scrub_next(struct osd_thread_info *info, struct osd_device *dev,
                if (likely(!list_empty(&scrub->os_inconsistent_items))) {
                        struct osd_inconsistent_item *oii;
 
-                       oii = list_entry(scrub->os_inconsistent_items.next,
-                               struct osd_inconsistent_item, oii_list);
+                       oii = list_first_entry(&scrub->os_inconsistent_items,
+                                              struct osd_inconsistent_item,
+                                              oii_list);
 
                        *oic = &oii->oii_cache;
                        scrub->os_in_prior = 1;
@@ -2482,8 +2483,8 @@ static void osd_initial_OI_scrub(struct osd_thread_info *info,
                if (list_empty(&dev->od_ios_list))
                        break;
 
-               item = list_entry(dev->od_ios_list.next,
-                                 struct osd_ios_item, oii_list);
+               item = list_first_entry(&dev->od_ios_list,
+                                       struct osd_ios_item, oii_list);
                list_del_init(&item->oii_list);
 
                LASSERT(item->oii_scandir != NULL);
@@ -2527,9 +2528,9 @@ static void osd_initial_OI_scrub(struct osd_thread_info *info,
                while (!list_empty(&dev->od_index_restore_list)) {
                        struct lustre_index_restore_unit *liru;
 
-                       liru = list_entry(dev->od_index_restore_list.next,
-                                         struct lustre_index_restore_unit,
-                                         liru_link);
+                       liru = list_first_entry(&dev->od_index_restore_list,
+                                               struct lustre_index_restore_unit,
+                                               liru_link);
                        list_del(&liru->liru_link);
                        if (buf)
                                osd_index_restore(info->oti_env, dev, liru,

diff --git a/lustre/osd-zfs/osd_object.c b/lustre/osd-zfs/osd_object.c
index 778b822..75aa683 100644 (file)
--- a/lustre/osd-zfs/osd_object.c
+++ b/lustre/osd-zfs/osd_object.c
@@ -122,8 +122,8 @@ void osd_object_sa_dirty_rele(const struct lu_env *env, struct osd_thandle *oh)
        struct osd_object *obj;
 
        while (!list_empty(&oh->ot_sa_list)) {
-               obj = list_entry(oh->ot_sa_list.next,
-                                struct osd_object, oo_sa_linkage);
+               obj = list_first_entry(&oh->ot_sa_list,
+                                      struct osd_object, oo_sa_linkage);
                write_lock(&obj->oo_attr_lock);
                list_del_init(&obj->oo_sa_linkage);
                write_unlock(&obj->oo_attr_lock);

diff --git a/lustre/osd-zfs/osd_scrub.c b/lustre/osd-zfs/osd_scrub.c
index 3f18a4f..fbec6d3 100644 (file)
--- a/lustre/osd-zfs/osd_scrub.c
+++ b/lustre/osd-zfs/osd_scrub.c
@@ -165,8 +165,8 @@ osd_scrub_check_update(const struct lu_env *env, struct osd_device *dev,
                GOTO(out, rc = val);
 
        if (scrub->os_in_prior)
-               oii = list_entry(scrub->os_inconsistent_items.next,
-                                struct osd_inconsistent_item, oii_list);
+               oii = list_first_entry(&scrub->os_inconsistent_items,
+                                      struct osd_inconsistent_item, oii_list);
 
        if (oid < sf->sf_pos_latest_start && !oii)
                GOTO(out, rc = 0);
@@ -360,8 +360,9 @@ again:
                if (likely(!list_empty(&scrub->os_inconsistent_items))) {
                        struct osd_inconsistent_item *oii;
 
-                       oii = list_entry(scrub->os_inconsistent_items.next,
-                               struct osd_inconsistent_item, oii_list);
+                       oii = list_first_entry(&scrub->os_inconsistent_items,
+                                              struct osd_inconsistent_item,
+                                              oii_list);
                        *fid = oii->oii_cache.oic_fid;
                        *oid = oii->oii_cache.oic_dnode;
                        scrub->os_in_prior = 1;
@@ -539,8 +540,8 @@ out:
        while (!list_empty(&scrub->os_inconsistent_items)) {
                struct osd_inconsistent_item *oii;
 
-               oii = list_entry(scrub->os_inconsistent_items.next,
-                                struct osd_inconsistent_item, oii_list);
+               oii = list_first_entry(&scrub->os_inconsistent_items,
+                                      struct osd_inconsistent_item, oii_list);
                list_del_init(&oii->oii_list);
                OBD_FREE_PTR(oii);
        }
@@ -1241,8 +1242,8 @@ static void osd_initial_OI_scrub(const struct lu_env *env,
        while (!list_empty(&dev->od_ios_list)) {
                struct osd_ios_item *item;
 
-               item = list_entry(dev->od_ios_list.next,
-                                 struct osd_ios_item, oii_list);
+               item = list_first_entry(&dev->od_ios_list,
+                                       struct osd_ios_item, oii_list);
                list_del_init(&item->oii_list);
                item->oii_scan_dir(env, dev, item->oii_parent,
                                   item->oii_handle_dirent, item->oii_flags);
@@ -1260,9 +1261,9 @@ static void osd_initial_OI_scrub(const struct lu_env *env,
                while (!list_empty(&dev->od_index_restore_list)) {
                        struct lustre_index_restore_unit *liru;
 
-                       liru = list_entry(dev->od_index_restore_list.next,
-                                         struct lustre_index_restore_unit,
-                                         liru_link);
+                       liru = list_first_entry(&dev->od_index_restore_list,
+                                               struct lustre_index_restore_unit,
+                                               liru_link);
                        list_del(&liru->liru_link);
                        if (buf)
                                osd_index_restore(env, dev, liru, buf,

diff --git a/lustre/osp/osp_sync.c b/lustre/osp/osp_sync.c
index bfc5b38..be0f901 100644 (file)
--- a/lustre/osp/osp_sync.c
+++ b/lustre/osp/osp_sync.c
@@ -1040,8 +1040,8 @@ static void osp_sync_process_committed(const struct lu_env *env,
        while (!list_empty(&list)) {
                struct osp_job_req_args *jra;
 
-               jra = list_entry(list.next, struct osp_job_req_args,
-                                jra_committed_link);
+               jra = list_first_entry(&list, struct osp_job_req_args,
+                                      jra_committed_link);
                LASSERT(jra->jra_magic == OSP_JOB_MAGIC);
                list_del_init(&jra->jra_committed_link);
 

diff --git a/lustre/osp/osp_trans.c b/lustre/osp/osp_trans.c
index 872d5e9..e06b21a 100644 (file)
--- a/lustre/osp/osp_trans.c
+++ b/lustre/osp/osp_trans.c
@@ -294,8 +294,8 @@ static int osp_prep_inline_update_req(const struct lu_env *env,
        __u32 update_req_size;
        int rc;
 
-       ours = list_entry(our->our_req_list.next,
-                         struct osp_update_request_sub, ours_list);
+       ours = list_first_entry(&our->our_req_list,
+                               struct osp_update_request_sub, ours_list);
        update_req_size = object_update_request_size(ours->ours_req);
        req_capsule_set_size(&req->rq_pill, &RMF_OUT_UPDATE_HEADER, RCL_CLIENT,
                             update_req_size + sizeof(*ouh));
@@ -386,8 +386,9 @@ int osp_prep_update_req(const struct lu_env *env, struct obd_import *imp,
                RETURN(-ENOMEM);
 
        if (buf_count == 1) {
-               ours = list_entry(our->our_req_list.next,
-                                 struct osp_update_request_sub, ours_list);
+               ours = list_first_entry(&our->our_req_list,
+                                       struct osp_update_request_sub,
+                                       ours_list);
 
                /* Let's check if it can be packed inline */
                if (object_update_request_size(ours->ours_req) +

diff --git a/lustre/ptlrpc/nrs_tbf.c b/lustre/ptlrpc/nrs_tbf.c
index d44e4ae..6ca8588 100644 (file)
--- a/lustre/ptlrpc/nrs_tbf.c
+++ b/lustre/ptlrpc/nrs_tbf.c
@@ -703,9 +703,9 @@ nrs_tbf_jobid_cli_put(struct nrs_tbf_head *head,
        while (cfs_hash_bd_count_get(&bd) > hw) {
                if (unlikely(list_empty(&bkt->ntb_lru)))
                        break;
-               cli = list_entry(bkt->ntb_lru.next,
-                                    struct nrs_tbf_client,
-                                    tc_lru);
+               cli = list_first_entry(&bkt->ntb_lru,
+                                      struct nrs_tbf_client,
+                                      tc_lru);
                LASSERT(atomic_read(&cli->tc_ref) == 0);
                cfs_hash_bd_del_locked(hs, &bd, &cli->tc_hnode);
                list_move(&cli->tc_lru, &zombies);
@@ -1719,9 +1719,9 @@ nrs_tbf_cli_put(struct nrs_tbf_head *head, struct nrs_tbf_client *cli)
        while (cfs_hash_bd_count_get(&bd) > hw) {
                if (unlikely(list_empty(&bkt->ntb_lru)))
                        break;
-               cli = list_entry(bkt->ntb_lru.next,
-                                struct nrs_tbf_client,
-                                tc_lru);
+               cli = list_first_entry(&bkt->ntb_lru,
+                                      struct nrs_tbf_client,
+                                      tc_lru);
                LASSERT(atomic_read(&cli->tc_ref) == 0);
                cfs_hash_bd_del_locked(hs, &bd, &cli->tc_hnode);
                list_move(&cli->tc_lru, &zombies);
@@ -3066,9 +3066,9 @@ struct ptlrpc_nrs_request *nrs_tbf_req_get(struct ptlrpc_nrs_policy *policy,
        cli = container_of(node, struct nrs_tbf_client, tc_node);
        LASSERT(cli->tc_in_heap);
        if (unlikely(peek)) {
-               nrq = list_entry(cli->tc_list.next,
-                                    struct ptlrpc_nrs_request,
-                                    nr_u.tbf.tr_list);
+               nrq = list_first_entry(&cli->tc_list,
+                                      struct ptlrpc_nrs_request,
+                                      nr_u.tbf.tr_list);
        } else {
                struct nrs_tbf_rule *rule = cli->tc_rule;
                __u64 now = ktime_to_ns(ktime_get());
@@ -3101,7 +3101,7 @@ struct ptlrpc_nrs_request *nrs_tbf_req_get(struct ptlrpc_nrs_policy *policy,
                        ntoken = 1;
 
                if (ntoken > 0) {
-                       nrq = list_entry(cli->tc_list.next,
+                       nrq = list_first_entry(&cli->tc_list,
                                         struct ptlrpc_nrs_request,
                                         nr_u.tbf.tr_list);
                        ntoken--;

diff --git a/lustre/ptlrpc/pinger.c b/lustre/ptlrpc/pinger.c
index 861b65c..4cb2585 100644 (file)
--- a/lustre/ptlrpc/pinger.c
+++ b/lustre/ptlrpc/pinger.c
@@ -484,8 +484,8 @@ static int ping_evictor_main(void *arg)
                 * is not strictly necessary.
                 */
                spin_lock(&pet_lock);
-               obd = list_entry(pet_list.next, struct obd_device,
-                                obd_evict_list);
+               obd = list_first_entry(&pet_list, struct obd_device,
+                                      obd_evict_list);
                spin_unlock(&pet_lock);
 
                expire_time = ktime_get_real_seconds() - PING_EVICT_TIMEOUT;
@@ -501,9 +501,9 @@ static int ping_evictor_main(void *arg)
                 */
                spin_lock(&obd->obd_dev_lock);
                while (!list_empty(&obd->obd_exports_timed)) {
-                       exp = list_entry(obd->obd_exports_timed.next,
-                                        struct obd_export,
-                                        exp_obd_chain_timed);
+                       exp = list_first_entry(&obd->obd_exports_timed,
+                                              struct obd_export,
+                                              exp_obd_chain_timed);
                        if (expire_time > exp->exp_last_request_time) {
                                struct obd_uuid *client_uuid;
 

diff --git a/lustre/ptlrpc/service.c b/lustre/ptlrpc/service.c
index 50a356e..3f30014 100644 (file)
--- a/lustre/ptlrpc/service.c
+++ b/lustre/ptlrpc/service.c
@@ -1148,8 +1148,8 @@ void ptlrpc_update_export_timer(struct obd_export *exp, time64_t extra_delay)
                RETURN_EXIT;
        }
 
-       newest_exp = list_entry(exp->exp_obd->obd_exports_timed.prev,
-                               struct obd_export, exp_obd_chain_timed);
+       newest_exp = list_last_entry(&exp->exp_obd->obd_exports_timed,
+                                    struct obd_export, exp_obd_chain_timed);
 
        list_move_tail(&exp->exp_obd_chain_timed,
                       &exp->exp_obd->obd_exports_timed);

diff --git a/lustre/quota/qsd_writeback.c b/lustre/quota/qsd_writeback.c
index b322d36..21bc53f 100644 (file)
--- a/lustre/quota/qsd_writeback.c
+++ b/lustre/quota/qsd_writeback.c
@@ -459,8 +459,8 @@ static bool qsd_job_pending(struct qsd_instance *qsd, struct list_head *upd,
        spin_lock(&qsd->qsd_adjust_lock);
        if (!list_empty(&qsd->qsd_adjust_list)) {
                struct lquota_entry *lqe;
-               lqe = list_entry(qsd->qsd_adjust_list.next,
-                                    struct lquota_entry, lqe_link);
+               lqe = list_first_entry(&qsd->qsd_adjust_list,
+                                      struct lquota_entry, lqe_link);
                if (ktime_get_seconds() >= lqe->lqe_adjust_time)
                        job_pending = true;
        }
@@ -565,8 +565,8 @@ static int qsd_upd_thread(void *_args)
                spin_lock(&qsd->qsd_adjust_lock);
                cur_time = ktime_get_seconds();
                while (!list_empty(&qsd->qsd_adjust_list)) {
-                       lqe = list_entry(qsd->qsd_adjust_list.next,
-                                        struct lquota_entry, lqe_link);
+                       lqe = list_first_entry(&qsd->qsd_adjust_list,
+                                              struct lquota_entry, lqe_link);
                        /* deferred items are sorted by time */
                        if (lqe->lqe_adjust_time > cur_time)
                                break;
@@ -681,8 +681,8 @@ static void qsd_cleanup_adjust(struct qsd_instance *qsd)
 
        spin_lock(&qsd->qsd_adjust_lock);
        while (!list_empty(&qsd->qsd_adjust_list)) {
-               lqe = list_entry(qsd->qsd_adjust_list.next,
-                                struct lquota_entry, lqe_link);
+               lqe = list_first_entry(&qsd->qsd_adjust_list,
+                                      struct lquota_entry, lqe_link);
                list_del_init(&lqe->lqe_link);
                lqe_putref(lqe);
        }

diff --git a/lustre/target/tgt_mount.c b/lustre/target/tgt_mount.c
index 606add6..be62afd 100644 (file)
--- a/lustre/target/tgt_mount.c
+++ b/lustre/target/tgt_mount.c
@@ -1043,8 +1043,8 @@ static int lustre_stop_lwp(struct super_block *sb)
        ENTRY;
        mutex_lock(&lsi->lsi_lwp_mutex);
        while (!list_empty(&lsi->lsi_lwp_list)) {
-               lwp = list_entry(lsi->lsi_lwp_list.next, struct obd_device,
-                                obd_lwp_list);
+               lwp = list_first_entry(&lsi->lsi_lwp_list, struct obd_device,
+                                      obd_lwp_list);
                list_del_init(&lwp->obd_lwp_list);
                lwp->obd_force = 1;
                mutex_unlock(&lsi->lsi_lwp_mutex);

diff --git a/lustre/target/update_recovery.c b/lustre/target/update_recovery.c
index 95e28b7..495f758 100644 (file)
--- a/lustre/target/update_recovery.c
+++ b/lustre/target/update_recovery.c
@@ -570,8 +570,9 @@ distribute_txn_get_next_req(struct target_distribute_txn_data *tdtd)
 
        spin_lock(&tdtd->tdtd_replay_list_lock);
        if (!list_empty(&tdtd->tdtd_replay_list)) {
-               dtrq = list_entry(tdtd->tdtd_replay_list.next,
-                                struct distribute_txn_replay_req, dtrq_list);
+               dtrq = list_first_entry(&tdtd->tdtd_replay_list,
+                                       struct distribute_txn_replay_req,
+                                       dtrq_list);
                list_del_init(&dtrq->dtrq_list);
        }
        spin_unlock(&tdtd->tdtd_replay_list_lock);
@@ -595,8 +596,9 @@ __u64 distribute_txn_get_next_transno(struct target_distribute_txn_data *tdtd)
 
        spin_lock(&tdtd->tdtd_replay_list_lock);
        if (!list_empty(&tdtd->tdtd_replay_list)) {
-               dtrq = list_entry(tdtd->tdtd_replay_list.next,
-                                struct distribute_txn_replay_req, dtrq_list);
+               dtrq = list_first_entry(&tdtd->tdtd_replay_list,
+                                       struct distribute_txn_replay_req,
+                                       dtrq_list);
                transno = dtrq->dtrq_master_transno;
        }
        spin_unlock(&tdtd->tdtd_replay_list_lock);