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

Merge git://git.samba.org/sfrench/cifs-2.6

Browse Source 
* git://git.samba.org/sfrench/cifs-2.6:
  CIFS: Cleanup byte-range locking code style
  CIFS: Simplify setlk error handling for mandatory locking
This commit is contained in:
Linus Torvalds 2011-11-07 09:56:22 -08:00
commit ff4d7fa8c3
1 changed files with 50 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
fs/cifs/file.c
View File

@ -645,20 +645,20 @@ int cifs_closedir(struct inode *inode, struct file *file)
} }
static struct cifsLockInfo * static struct cifsLockInfo *
cifs_lock_init(__u64 len, __u64 offset, __u8 type, __u16 netfid) cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 netfid)
{ {
struct cifsLockInfo *li = struct cifsLockInfo *lock =
kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL); kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
if (!li) if (!lock)
return li; return lock;
li->netfid = netfid; lock->offset = offset;
li->offset = offset; lock->length = length;
li->length = len; lock->type = type;
li->type = type; lock->netfid = netfid;
li->pid = current->tgid; lock->pid = current->tgid;
INIT_LIST_HEAD(&li->blist); INIT_LIST_HEAD(&lock->blist);
init_waitqueue_head(&li->block_q); init_waitqueue_head(&lock->block_q);
return li; return lock;
} }
static void static void
@ -672,7 +672,7 @@ cifs_del_lock_waiters(struct cifsLockInfo *lock)
} }
static bool static bool
cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset, __cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
__u64 length, __u8 type, __u16 netfid, __u64 length, __u8 type, __u16 netfid,
struct cifsLockInfo **conf_lock) struct cifsLockInfo **conf_lock)
{ {
@ -694,6 +694,14 @@ cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
return false; return false;
} }
static bool
cifs_find_lock_conflict(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
struct cifsLockInfo **conf_lock)
{
return __cifs_find_lock_conflict(cinode, lock->offset, lock->length,
lock->type, lock->netfid, conf_lock);
}
static int static int
cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length, cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
__u8 type, __u16 netfid, struct file_lock *flock) __u8 type, __u16 netfid, struct file_lock *flock)
@ -704,7 +712,7 @@ cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
mutex_lock(&cinode->lock_mutex); mutex_lock(&cinode->lock_mutex);
exist = cifs_find_lock_conflict(cinode, offset, length, type, netfid, exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
&conf_lock); &conf_lock);
if (exist) { if (exist) {
flock->fl_start = conf_lock->offset; flock->fl_start = conf_lock->offset;
@ -723,40 +731,27 @@ cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
return rc; return rc;
} }
static int static void
cifs_lock_add(struct cifsInodeInfo *cinode, __u64 len, __u64 offset, cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
__u8 type, __u16 netfid)
{ {
struct cifsLockInfo *li;
li = cifs_lock_init(len, offset, type, netfid);
if (!li)
return -ENOMEM;
mutex_lock(&cinode->lock_mutex); mutex_lock(&cinode->lock_mutex);
list_add_tail(&li->llist, &cinode->llist); list_add_tail(&lock->llist, &cinode->llist);
mutex_unlock(&cinode->lock_mutex); mutex_unlock(&cinode->lock_mutex);
return 0;
} }
static int static int
cifs_lock_add_if(struct cifsInodeInfo *cinode, __u64 offset, __u64 length, cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
__u8 type, __u16 netfid, bool wait) bool wait)
{ {
struct cifsLockInfo *lock, *conf_lock; struct cifsLockInfo *conf_lock;
bool exist; bool exist;
int rc = 0; int rc = 0;
lock = cifs_lock_init(length, offset, type, netfid);
if (!lock)
return -ENOMEM;
try_again: try_again:
exist = false; exist = false;
mutex_lock(&cinode->lock_mutex); mutex_lock(&cinode->lock_mutex);
exist = cifs_find_lock_conflict(cinode, offset, length, type, netfid, exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
&conf_lock);
if (!exist && cinode->can_cache_brlcks) { if (!exist && cinode->can_cache_brlcks) {
list_add_tail(&lock->llist, &cinode->llist); list_add_tail(&lock->llist, &cinode->llist);
mutex_unlock(&cinode->lock_mutex); mutex_unlock(&cinode->lock_mutex);
@ -775,13 +770,10 @@ try_again:
(lock->blist.next == &lock->blist)); (lock->blist.next == &lock->blist));
if (!rc) if (!rc)
goto try_again; goto try_again;
else {
mutex_lock(&cinode->lock_mutex); mutex_lock(&cinode->lock_mutex);
list_del_init(&lock->blist); list_del_init(&lock->blist);
} }
}
kfree(lock);
mutex_unlock(&cinode->lock_mutex); mutex_unlock(&cinode->lock_mutex);
return rc; return rc;
} }
@ -933,7 +925,7 @@ cifs_push_posix_locks(struct cifsFileInfo *cfile)
else else
type = CIFS_WRLCK; type = CIFS_WRLCK;
lck = cifs_lock_init(length, flock->fl_start, type, lck = cifs_lock_init(flock->fl_start, length, type,
cfile->netfid); cfile->netfid);
if (!lck) { if (!lck) {
rc = -ENOMEM; rc = -ENOMEM;
@ -1070,14 +1062,12 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
if (rc != 0) if (rc != 0)
cERROR(1, "Error unlocking previously locked " cERROR(1, "Error unlocking previously locked "
"range %d during test of lock", rc); "range %d during test of lock", rc);
rc = 0; return 0;
return rc;
} }
if (type & LOCKING_ANDX_SHARED_LOCK) { if (type & LOCKING_ANDX_SHARED_LOCK) {
flock->fl_type = F_WRLCK; flock->fl_type = F_WRLCK;
rc = 0; return 0;
return rc;
} }
rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length, rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
@ -1095,8 +1085,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
} else } else
flock->fl_type = F_WRLCK; flock->fl_type = F_WRLCK;
rc = 0; return 0;
return rc;
} }
static void static void
@ -1254,20 +1243,26 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u8 type,
} }
if (lock) { if (lock) {
rc = cifs_lock_add_if(cinode, flock->fl_start, length, struct cifsLockInfo *lock;
type, netfid, wait_flag);
lock = cifs_lock_init(flock->fl_start, length, type, netfid);
if (!lock)
return -ENOMEM;
rc = cifs_lock_add_if(cinode, lock, wait_flag);
if (rc < 0) if (rc < 0)
return rc; kfree(lock);
else if (!rc) if (rc <= 0)
goto out; goto out;
rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length, rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
flock->fl_start, 0, 1, type, wait_flag, 0); flock->fl_start, 0, 1, type, wait_flag, 0);
if (rc == 0) { if (rc) {
/* For Windows locks we must store them. */ kfree(lock);
rc = cifs_lock_add(cinode, length, flock->fl_start, goto out;
type, netfid);
} }
cifs_lock_add(cinode, lock);
} else if (unlock) } else if (unlock)
rc = cifs_unlock_range(cfile, flock, xid); rc = cifs_unlock_range(cfile, flock, xid);