leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

GFS2: Clean up of gdlm_lock function

Browse Source 
The DLM never returns -EAGAIN in response to dlm_lock(), and even
if it did, the test in gdlm_lock() was wrong anyway. Once that
test is removed, it is possible to greatly simplify this code
by simply using a "normal" error return code (0 for success).

We then no longer need the LM_OUT_ASYNC return code which can
be removed.

Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
This commit is contained in:
Steven Whitehouse 2010-11-29 12:50:38 +00:00
parent 802ec9b668
commit 921169ca2f
3 changed files with 17 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
fs/gfs2/glock.c
View File

@ -541,21 +541,6 @@ out_locked:
spin_unlock(&gl->gl_spin); spin_unlock(&gl->gl_spin);
} }
static unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, void *lock,
unsigned int req_state,
unsigned int flags)
{
int ret = LM_OUT_ERROR;
if (!sdp->sd_lockstruct.ls_ops->lm_lock)
return req_state == LM_ST_UNLOCKED ? 0 : req_state;
if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock,
req_state, flags);
return ret;
}
/** /**
* do_xmote - Calls the DLM to change the state of a lock * do_xmote - Calls the DLM to change the state of a lock
* @gl: The lock state * @gl: The lock state
@ -575,8 +560,8 @@ __acquires(&gl->gl_spin)
lck_flags &= (LM_FLAG_TRY | LM_FLAG_TRY_1CB | LM_FLAG_NOEXP | lck_flags &= (LM_FLAG_TRY | LM_FLAG_TRY_1CB | LM_FLAG_NOEXP |
LM_FLAG_PRIORITY); LM_FLAG_PRIORITY);
BUG_ON(gl->gl_state == target); GLOCK_BUG_ON(gl, gl->gl_state == target);
BUG_ON(gl->gl_state == gl->gl_target); GLOCK_BUG_ON(gl, gl->gl_state == gl->gl_target);
if ((target == LM_ST_UNLOCKED || target == LM_ST_DEFERRED) && if ((target == LM_ST_UNLOCKED || target == LM_ST_DEFERRED) &&
glops->go_inval) { glops->go_inval) {
set_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags); set_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
@ -594,15 +579,17 @@ __acquires(&gl->gl_spin)
gl->gl_state == LM_ST_DEFERRED) && gl->gl_state == LM_ST_DEFERRED) &&
!(lck_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) !(lck_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)))
lck_flags |= LM_FLAG_TRY_1CB; lck_flags |= LM_FLAG_TRY_1CB;
ret = gfs2_lm_lock(sdp, gl, target, lck_flags);
if (!(ret & LM_OUT_ASYNC)) { if (sdp->sd_lockstruct.ls_ops->lm_lock) {
finish_xmote(gl, ret); /* lock_dlm */
ret = sdp->sd_lockstruct.ls_ops->lm_lock(gl, target, lck_flags);
GLOCK_BUG_ON(gl, ret);
} else { /* lock_nolock */
finish_xmote(gl, target);
if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0) if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
gfs2_glock_put(gl); gfs2_glock_put(gl);
} else {
GLOCK_BUG_ON(gl, ret != LM_OUT_ASYNC);
} }
spin_lock(&gl->gl_spin); spin_lock(&gl->gl_spin);
} }

12
fs/gfs2/glock.h
View File

@ -91,7 +91,7 @@ enum {
#define GL_NOCACHE 0x00000400 #define GL_NOCACHE 0x00000400
/* /*
* lm_lock() and lm_async_cb return flags * lm_async_cb return flags
* *
* LM_OUT_ST_MASK * LM_OUT_ST_MASK
* Masks the lower two bits of lock state in the returned value. * Masks the lower two bits of lock state in the returned value.
@ -99,15 +99,11 @@ enum {
* LM_OUT_CANCELED * LM_OUT_CANCELED
* The lock request was canceled. * The lock request was canceled.
* *
* LM_OUT_ASYNC
* The result of the request will be returned in an LM_CB_ASYNC callback.
*
*/ */
#define LM_OUT_ST_MASK 0x00000003 #define LM_OUT_ST_MASK 0x00000003
#define LM_OUT_CANCELED 0x00000008 #define LM_OUT_CANCELED 0x00000008
#define LM_OUT_ASYNC 0x00000080 #define LM_OUT_ERROR 0x00000004
#define LM_OUT_ERROR 0x00000100
/* /*
* lm_recovery_done() messages * lm_recovery_done() messages
@ -124,8 +120,8 @@ struct lm_lockops {
void (*lm_unmount) (struct gfs2_sbd *sdp); void (*lm_unmount) (struct gfs2_sbd *sdp);
void (*lm_withdraw) (struct gfs2_sbd *sdp); void (*lm_withdraw) (struct gfs2_sbd *sdp);
void (*lm_put_lock) (struct kmem_cache *cachep, struct gfs2_glock *gl); void (*lm_put_lock) (struct kmem_cache *cachep, struct gfs2_glock *gl);
unsigned int (*lm_lock) (struct gfs2_glock *gl, int (*lm_lock) (struct gfs2_glock *gl, unsigned int req_state,
unsigned int req_state, unsigned int flags); unsigned int flags);
void (*lm_cancel) (struct gfs2_glock *gl); void (*lm_cancel) (struct gfs2_glock *gl);
const match_table_t *lm_tokens; const match_table_t *lm_tokens;
}; };

14
fs/gfs2/lock_dlm.c
View File

@ -146,11 +146,10 @@ static u32 make_flags(const u32 lkid, const unsigned int gfs_flags,
return lkf; return lkf;
} }
static unsigned int gdlm_lock(struct gfs2_glock *gl, static int gdlm_lock(struct gfs2_glock *gl, unsigned int req_state,
unsigned int req_state, unsigned int flags) unsigned int flags)
{ {
struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct; struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;
int error;
int req; int req;
u32 lkf; u32 lkf;
@ -162,13 +161,8 @@ static unsigned int gdlm_lock(struct gfs2_glock *gl,
* Submit the actual lock request. * Submit the actual lock request.
*/ */
error = dlm_lock(ls->ls_dlm, req, &gl->gl_lksb, lkf, gl->gl_strname, return dlm_lock(ls->ls_dlm, req, &gl->gl_lksb, lkf, gl->gl_strname,
GDLM_STRNAME_BYTES - 1, 0, gdlm_ast, gl, gdlm_bast); GDLM_STRNAME_BYTES - 1, 0, gdlm_ast, gl, gdlm_bast);
if (error == -EAGAIN)
return 0;
if (error)
return LM_OUT_ERROR;
return LM_OUT_ASYNC;
} }
static void gdlm_put_lock(struct kmem_cache *cachep, struct gfs2_glock *gl) static void gdlm_put_lock(struct kmem_cache *cachep, struct gfs2_glock *gl)