Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[GFS2] flocks from same process trip kernel BUG at fs/gfs2/glock.c:1118!

Browse source 
This patch adds a new flag to the gfs2_holder structure GL_FLOCK.
It is set on holders of glocks representing flocks. This flag is
checked in add_to_queue() and a process is permitted to queue more
than one holder onto a glock if it is set. This solves the issue
of a process not being able to do multiple flocks on the same file.
Through a single descriptor, a process can now promote and demote
flocks. Through multiple descriptors a process can now queue
multiple flocks on the same file. There's still the problem of
a process deadlocking itself (because gfs2 blocking locks are not
interruptible) by queueing incompatible deadlock.

Signed-off-by: Abhijith Das <adas@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
This commit is contained in:
Abhijith Das 2007-09-13 23:35:27 -05:00 committed by Steven Whitehouse
parent 1ad38c437f
commit b4c20166dc
3 changed files with 32 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
fs/gfs2/glock.c
View file

@ -1106,24 +1106,31 @@ static void add_to_queue(struct gfs2_holder *gh)
if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags)) if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
BUG(); BUG();
existing = find_holder_by_owner(&gl->gl_holders, gh->gh_owner_pid); if (!(gh->gh_flags & GL_FLOCK)) {
if (existing) { existing = find_holder_by_owner(&gl->gl_holders,
print_symbol(KERN_WARNING "original: %s\n", existing->gh_ip); gh->gh_owner_pid);
printk(KERN_INFO "pid : %d\n", existing->gh_owner_pid); if (existing) {
printk(KERN_INFO "lock type : %d lock state : %d\n", print_symbol(KERN_WARNING "original: %s\n",
existing->gh_gl->gl_name.ln_type, existing->gh_gl->gl_state); existing->gh_ip);
print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip); printk(KERN_INFO "pid : %d\n", existing->gh_owner_pid);
printk(KERN_INFO "pid : %d\n", gh->gh_owner_pid); printk(KERN_INFO "lock type : %d lock state : %d\n",
printk(KERN_INFO "lock type : %d lock state : %d\n", existing->gh_gl->gl_name.ln_type,
gl->gl_name.ln_type, gl->gl_state); existing->gh_gl->gl_state);
BUG(); print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
} printk(KERN_INFO "pid : %d\n", gh->gh_owner_pid);
printk(KERN_INFO "lock type : %d lock state : %d\n",
existing = find_holder_by_owner(&gl->gl_waiters3, gh->gh_owner_pid); gl->gl_name.ln_type, gl->gl_state);
if (existing) { BUG();
print_symbol(KERN_WARNING "original: %s\n", existing->gh_ip); }
print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
BUG(); existing = find_holder_by_owner(&gl->gl_waiters3,
gh->gh_owner_pid);
if (existing) {
print_symbol(KERN_WARNING "original: %s\n",
existing->gh_ip);
print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
BUG();
}
} }
if (gh->gh_flags & LM_FLAG_PRIORITY) if (gh->gh_flags & LM_FLAG_PRIORITY)

1
fs/gfs2/glock.h
View file

@ -26,6 +26,7 @@
#define GL_SKIP 0x00000100 #define GL_SKIP 0x00000100
#define GL_ATIME 0x00000200 #define GL_ATIME 0x00000200
#define GL_NOCACHE 0x00000400 #define GL_NOCACHE 0x00000400
#define GL_FLOCK 0x00000800
#define GL_NOCANCEL 0x00001000 #define GL_NOCANCEL 0x00001000
#define GLR_TRYFAILED 13 #define GLR_TRYFAILED 13

13
fs/gfs2/ops_file.c
View file

@ -571,7 +571,8 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl)
int error = 0; int error = 0;
state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED; state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE; flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE
| GL_FLOCK;
mutex_lock(&fp->f_fl_mutex); mutex_lock(&fp->f_fl_mutex);
@ -579,21 +580,19 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl)
if (gl) { if (gl) {
if (fl_gh->gh_state == state) if (fl_gh->gh_state == state)
goto out; goto out;
gfs2_glock_hold(gl);
flock_lock_file_wait(file, flock_lock_file_wait(file,
&(struct file_lock){.fl_type = F_UNLCK}); &(struct file_lock){.fl_type = F_UNLCK});
gfs2_glock_dq_uninit(fl_gh); gfs2_glock_dq_wait(fl_gh);
gfs2_holder_reinit(state, flags, fl_gh);
} else { } else {
error = gfs2_glock_get(GFS2_SB(&ip->i_inode), error = gfs2_glock_get(GFS2_SB(&ip->i_inode),
ip->i_no_addr, &gfs2_flock_glops, ip->i_no_addr, &gfs2_flock_glops,
CREATE, &gl); CREATE, &gl);
if (error) if (error)
goto out; goto out;
gfs2_holder_init(gl, state, flags, fl_gh);
gfs2_glock_put(gl);
} }
gfs2_holder_init(gl, state, flags, fl_gh);
gfs2_glock_put(gl);
error = gfs2_glock_nq(fl_gh); error = gfs2_glock_nq(fl_gh);
if (error) { if (error) {
gfs2_holder_uninit(fl_gh); gfs2_holder_uninit(fl_gh);