From 94b72e3478d73133c29c0e31403e7e3e96a163f4 Mon Sep 17 00:00:00 2001 From: Mr NeilBrown Date: Thu, 7 Nov 2019 09:47:35 +1100 Subject: [PATCH] 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 Change-Id: I22b1278f5b481ce3074db3e59d37d9148016aed5 Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/50828 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Arshad Hussain Reviewed-by: James Simmons Reviewed-by: Oleg Drokin --- lustre/fld/fld_request.c | 2 +- lustre/ldlm/ldlm_internal.h | 4 ++-- lustre/ldlm/ldlm_lib.c | 25 +++++++++++++------------ lustre/ldlm/ldlm_lock.c | 4 ++-- lustre/ldlm/ldlm_lockd.c | 8 ++++---- lustre/lfsck/lfsck_engine.c | 32 ++++++++++++++++---------------- lustre/lfsck/lfsck_layout.c | 29 +++++++++++++++-------------- lustre/lfsck/lfsck_lib.c | 6 +++--- lustre/lfsck/lfsck_namespace.c | 18 +++++++++--------- lustre/mgs/mgs_barrier.c | 2 +- lustre/mgs/mgs_nids.c | 3 ++- lustre/obdclass/lprocfs_status_server.c | 8 ++++---- lustre/ofd/ofd_io.c | 12 ++++++------ lustre/osd-ldiskfs/osd_scrub.c | 15 ++++++++------- lustre/osd-zfs/osd_object.c | 4 ++-- lustre/osd-zfs/osd_scrub.c | 23 ++++++++++++----------- lustre/osp/osp_sync.c | 4 ++-- lustre/osp/osp_trans.c | 9 +++++---- lustre/ptlrpc/nrs_tbf.c | 20 ++++++++++---------- lustre/ptlrpc/pinger.c | 10 +++++----- lustre/ptlrpc/service.c | 4 ++-- lustre/quota/qsd_writeback.c | 12 ++++++------ lustre/target/tgt_mount.c | 4 ++-- lustre/target/update_recovery.c | 10 ++++++---- 24 files changed, 138 insertions(+), 130 deletions(-) diff --git a/lustre/fld/fld_request.c b/lustre/fld/fld_request.c index 8148ad7..5210efe 100644 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 = <d->ltd_layout_list; gen = <d->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 = <d->ltd_namespace_list; gen = <d->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 --- 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(<ds->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(<d->ltd_layout_phase_list); if (bk->lb_param & LPF_OST_ORPHAN) { spin_unlock(<ds->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 --- a/lustre/lfsck/lfsck_lib.c +++ b/lustre/lfsck/lfsck_lib.c @@ -260,9 +260,9 @@ again: down_write(<ds->ltd_rw_sem); while (!list_empty(<ds->ltd_orphan)) { - ltd = list_entry(ltds->ltd_orphan.next, - struct lfsck_tgt_desc, - ltd_orphan_list); + ltd = list_first_entry(<ds->ltd_orphan, + struct lfsck_tgt_desc, + ltd_orphan_list); list_del_init(<d->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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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); -- 1.8.3.1