xiaomi-sm8450/android_kernel_xiaomi_sm8450
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

dlm: replace usage of found with dedicated list iterator variable

Browse Source 
[ Upstream commit dc1acd5c94699389a9ed023e94dd860c846ea1f6 ]

To move the list iterator variable into the list_for_each_entry_*()
macro in the future it should be avoided to use the list iterator
variable after the loop body.

To *never* use the list iterator variable after the loop it was
concluded to use a separate iterator variable instead of a
found boolean [1].

This removes the need to use a found variable and simply checking if
the variable was set, can determine if the break/goto was hit.

Link: https://lore.kernel.org/all/CAHk-=wgRr_D8CB-D9Kg-c=EHreAsk5SqXPwr9Y7k9sA6cWXJ6w@mail.gmail.com/ [1]
Signed-off-by: Jakob Koschel <jakobkoschel@gmail.com>
Signed-off-by: Alexander Aring <aahringo@redhat.com>
Signed-off-by: David Teigland <teigland@redhat.com>
Stable-dep-of: 57e2c2f2d94c ("fs: dlm: fix mismatch of plock results from userspace")
Signed-off-by: Sasha Levin <sashal@kernel.org>
This commit is contained in:
Jakob Koschel
2022-04-06 14:05:31 -04:00
committed by Greg Kroah-Hartman
parent 7b44c1f383
commit e850cd32df
3 changed files with 56 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
fs/dlm/lock.c
View File

@@ -1856,7 +1856,7 @@ static void del_timeout(struct dlm_lkb *lkb)
void dlm_scan_timeout(struct dlm_ls *ls) void dlm_scan_timeout(struct dlm_ls *ls)
{ {
struct dlm_rsb *r; struct dlm_rsb *r;
struct dlm_lkb *lkb; struct dlm_lkb *lkb = NULL, *iter;
int do_cancel, do_warn; int do_cancel, do_warn;
s64 wait_us; s64 wait_us;
@@ -1867,27 +1867,28 @@ void dlm_scan_timeout(struct dlm_ls *ls)
do_cancel = 0; do_cancel = 0;
do_warn = 0; do_warn = 0;
mutex_lock(&ls->ls_timeout_mutex); mutex_lock(&ls->ls_timeout_mutex);
list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list) { list_for_each_entry(iter, &ls->ls_timeout, lkb_time_list) {
wait_us = ktime_to_us(ktime_sub(ktime_get(), wait_us = ktime_to_us(ktime_sub(ktime_get(),
lkb->lkb_timestamp)); iter->lkb_timestamp));
if ((lkb->lkb_exflags & DLM_LKF_TIMEOUT) && if ((iter->lkb_exflags & DLM_LKF_TIMEOUT) &&
wait_us >= (lkb->lkb_timeout_cs * 10000)) wait_us >= (iter->lkb_timeout_cs * 10000))
do_cancel = 1; do_cancel = 1;
if ((lkb->lkb_flags & DLM_IFL_WATCH_TIMEWARN) && if ((iter->lkb_flags & DLM_IFL_WATCH_TIMEWARN) &&
wait_us >= dlm_config.ci_timewarn_cs * 10000) wait_us >= dlm_config.ci_timewarn_cs * 10000)
do_warn = 1; do_warn = 1;
if (!do_cancel && !do_warn) if (!do_cancel && !do_warn)
continue; continue;
hold_lkb(lkb); hold_lkb(iter);
lkb = iter;
break; break;
} }
mutex_unlock(&ls->ls_timeout_mutex); mutex_unlock(&ls->ls_timeout_mutex);
if (!do_cancel && !do_warn) if (!lkb)
break; break;
r = lkb->lkb_resource; r = lkb->lkb_resource;
@@ -5241,21 +5242,18 @@ void dlm_recover_waiters_pre(struct dlm_ls *ls)
static struct dlm_lkb *find_resend_waiter(struct dlm_ls *ls) static struct dlm_lkb *find_resend_waiter(struct dlm_ls *ls)
{ {
struct dlm_lkb *lkb; struct dlm_lkb *lkb = NULL, *iter;
int found = 0;
mutex_lock(&ls->ls_waiters_mutex); mutex_lock(&ls->ls_waiters_mutex);
list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) { list_for_each_entry(iter, &ls->ls_waiters, lkb_wait_reply) {
if (lkb->lkb_flags & DLM_IFL_RESEND) { if (iter->lkb_flags & DLM_IFL_RESEND) {
hold_lkb(lkb); hold_lkb(iter);
found = 1; lkb = iter;
break; break;
} }
} }
mutex_unlock(&ls->ls_waiters_mutex); mutex_unlock(&ls->ls_waiters_mutex);
if (!found)
lkb = NULL;
return lkb; return lkb;
} }
@@ -5914,37 +5912,36 @@ int dlm_user_adopt_orphan(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
int mode, uint32_t flags, void *name, unsigned int namelen, int mode, uint32_t flags, void *name, unsigned int namelen,
unsigned long timeout_cs, uint32_t *lkid) unsigned long timeout_cs, uint32_t *lkid)
{ {
struct dlm_lkb *lkb; struct dlm_lkb *lkb = NULL, *iter;
struct dlm_user_args *ua; struct dlm_user_args *ua;
int found_other_mode = 0; int found_other_mode = 0;
int found = 0;
int rv = 0; int rv = 0;
mutex_lock(&ls->ls_orphans_mutex); mutex_lock(&ls->ls_orphans_mutex);
list_for_each_entry(lkb, &ls->ls_orphans, lkb_ownqueue) { list_for_each_entry(iter, &ls->ls_orphans, lkb_ownqueue) {
if (lkb->lkb_resource->res_length != namelen) if (iter->lkb_resource->res_length != namelen)
continue; continue;
if (memcmp(lkb->lkb_resource->res_name, name, namelen)) if (memcmp(iter->lkb_resource->res_name, name, namelen))
continue; continue;
if (lkb->lkb_grmode != mode) { if (iter->lkb_grmode != mode) {
found_other_mode = 1; found_other_mode = 1;
continue; continue;
} }
found = 1; lkb = iter;
list_del_init(&lkb->lkb_ownqueue); list_del_init(&iter->lkb_ownqueue);
lkb->lkb_flags &= ~DLM_IFL_ORPHAN; iter->lkb_flags &= ~DLM_IFL_ORPHAN;
*lkid = lkb->lkb_id; *lkid = iter->lkb_id;
break; break;
} }
mutex_unlock(&ls->ls_orphans_mutex); mutex_unlock(&ls->ls_orphans_mutex);
if (!found && found_other_mode) { if (!lkb && found_other_mode) {
rv = -EAGAIN; rv = -EAGAIN;
goto out; goto out;
} }
if (!found) { if (!lkb) {
rv = -ENOENT; rv = -ENOENT;
goto out; goto out;
} }

24
fs/dlm/plock.c
View File

@@ -434,9 +434,9 @@ static ssize_t dev_read(struct file *file, char __user *u, size_t count,
static ssize_t dev_write(struct file *file, const char __user *u, size_t count, static ssize_t dev_write(struct file *file, const char __user *u, size_t count,
loff_t *ppos) loff_t *ppos)
{ {
struct plock_op *op = NULL, *iter;
struct dlm_plock_info info; struct dlm_plock_info info;
struct plock_op *op; int do_callback = 0;
int found = 0, do_callback = 0;
if (count != sizeof(info)) if (count != sizeof(info))
return -EINVAL; return -EINVAL;
@@ -448,23 +448,23 @@ static ssize_t dev_write(struct file *file, const char __user *u, size_t count,
return -EINVAL; return -EINVAL;
spin_lock(&ops_lock); spin_lock(&ops_lock);
list_for_each_entry(op, &recv_list, list) { list_for_each_entry(iter, &recv_list, list) {
if (op->info.fsid == info.fsid && if (iter->info.fsid == info.fsid &&
op->info.number == info.number && iter->info.number == info.number &&
op->info.owner == info.owner) { iter->info.owner == info.owner) {
list_del_init(&op->list); list_del_init(&iter->list);
memcpy(&op->info, &info, sizeof(info)); memcpy(&iter->info, &info, sizeof(info));
if (op->data) if (iter->data)
do_callback = 1; do_callback = 1;
else else
op->done = 1; iter->done = 1;
found = 1; op = iter;
break; break;
} }
} }
spin_unlock(&ops_lock); spin_unlock(&ops_lock);
if (found) { if (op) {
if (do_callback) if (do_callback)
dlm_plock_callback(op); dlm_plock_callback(op);
else else

39
fs/dlm/recover.c
View File

@@ -732,10 +732,9 @@ void dlm_recovered_lock(struct dlm_rsb *r)
static void recover_lvb(struct dlm_rsb *r) static void recover_lvb(struct dlm_rsb *r)
{ {
struct dlm_lkb *lkb, *high_lkb = NULL; struct dlm_lkb *big_lkb = NULL, *iter, *high_lkb = NULL;
uint32_t high_seq = 0; uint32_t high_seq = 0;
int lock_lvb_exists = 0; int lock_lvb_exists = 0;
int big_lock_exists = 0;
int lvblen = r->res_ls->ls_lvblen; int lvblen = r->res_ls->ls_lvblen;
if (!rsb_flag(r, RSB_NEW_MASTER2) && if (!rsb_flag(r, RSB_NEW_MASTER2) &&
@@ -751,37 +750,37 @@ static void recover_lvb(struct dlm_rsb *r)
/* we are the new master, so figure out if VALNOTVALID should /* we are the new master, so figure out if VALNOTVALID should
be set, and set the rsb lvb from the best lkb available. */ be set, and set the rsb lvb from the best lkb available. */
list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) { list_for_each_entry(iter, &r->res_grantqueue, lkb_statequeue) {
if (!(lkb->lkb_exflags & DLM_LKF_VALBLK)) if (!(iter->lkb_exflags & DLM_LKF_VALBLK))
continue; continue;
lock_lvb_exists = 1; lock_lvb_exists = 1;
if (lkb->lkb_grmode > DLM_LOCK_CR) { if (iter->lkb_grmode > DLM_LOCK_CR) {
big_lock_exists = 1; big_lkb = iter;
goto setflag; goto setflag;
} }
if (((int)lkb->lkb_lvbseq - (int)high_seq) >= 0) { if (((int)iter->lkb_lvbseq - (int)high_seq) >= 0) {
high_lkb = lkb; high_lkb = iter;
high_seq = lkb->lkb_lvbseq; high_seq = iter->lkb_lvbseq;
} }
} }
list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) { list_for_each_entry(iter, &r->res_convertqueue, lkb_statequeue) {
if (!(lkb->lkb_exflags & DLM_LKF_VALBLK)) if (!(iter->lkb_exflags & DLM_LKF_VALBLK))
continue; continue;
lock_lvb_exists = 1; lock_lvb_exists = 1;
if (lkb->lkb_grmode > DLM_LOCK_CR) { if (iter->lkb_grmode > DLM_LOCK_CR) {
big_lock_exists = 1; big_lkb = iter;
goto setflag; goto setflag;
} }
if (((int)lkb->lkb_lvbseq - (int)high_seq) >= 0) { if (((int)iter->lkb_lvbseq - (int)high_seq) >= 0) {
high_lkb = lkb; high_lkb = iter;
high_seq = lkb->lkb_lvbseq; high_seq = iter->lkb_lvbseq;
} }
} }
@@ -790,7 +789,7 @@ static void recover_lvb(struct dlm_rsb *r)
goto out; goto out;
/* lvb is invalidated if only NL/CR locks remain */ /* lvb is invalidated if only NL/CR locks remain */
if (!big_lock_exists) if (!big_lkb)
rsb_set_flag(r, RSB_VALNOTVALID); rsb_set_flag(r, RSB_VALNOTVALID);
if (!r->res_lvbptr) { if (!r->res_lvbptr) {
@@ -799,9 +798,9 @@ static void recover_lvb(struct dlm_rsb *r)
goto out; goto out;
} }
if (big_lock_exists) { if (big_lkb) {
r->res_lvbseq = lkb->lkb_lvbseq; r->res_lvbseq = big_lkb->lkb_lvbseq;
memcpy(r->res_lvbptr, lkb->lkb_lvbptr, lvblen); memcpy(r->res_lvbptr, big_lkb->lkb_lvbptr, lvblen);
} else if (high_lkb) { } else if (high_lkb) {
r->res_lvbseq = high_lkb->lkb_lvbseq; r->res_lvbseq = high_lkb->lkb_lvbseq;
memcpy(r->res_lvbptr, high_lkb->lkb_lvbptr, lvblen); memcpy(r->res_lvbptr, high_lkb->lkb_lvbptr, lvblen);