GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-07-23 07:12:09 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

CIFS: Separate protocol specific part from getlk

Browse source 
Signed-off-by: Pavel Shilovsky <piastry@etersoft.ru>
This commit is contained in:
Pavel Shilovsky 2012-02-28 14:04:17 +03:00
parent 106dc538ab
commit 55157dfbb5
3 changed files with 39 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

2
fs/cifs/cifsglob.h
View file

@ -156,10 +156,12 @@ enum smb_version {
struct mid_q_entry; struct mid_q_entry;
struct TCP_Server_Info; struct TCP_Server_Info;
struct cifsFileInfo;
struct smb_version_operations { struct smb_version_operations {
int (*send_cancel)(struct TCP_Server_Info *, void *, int (*send_cancel)(struct TCP_Server_Info *, void *,
struct mid_q_entry *); struct mid_q_entry *);
bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
}; };
struct smb_version_values { struct smb_version_values {

52
fs/cifs/file.c
View file

@ -671,7 +671,7 @@ cifs_del_lock_waiters(struct cifsLockInfo *lock)
static bool static bool
cifs_find_fid_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, cifs_find_fid_lock_conflict(struct cifsFileInfo *cfile, __u64 offset,
__u64 length, __u8 type, __u16 netfid, __u64 length, __u8 type, struct cifsFileInfo *cur,
struct cifsLockInfo **conf_lock) struct cifsLockInfo **conf_lock)
{ {
struct cifsLockInfo *li; struct cifsLockInfo *li;
@ -682,8 +682,8 @@ cifs_find_fid_lock_conflict(struct cifsFileInfo *cfile, __u64 offset,
offset >= li->offset + li->length) offset >= li->offset + li->length)
continue; continue;
else if ((type & server->vals->shared_lock_type) && else if ((type & server->vals->shared_lock_type) &&
((netfid == cfile->netfid && current->tgid == li->pid) ((server->ops->compare_fids(cur, cfile) &&
|| type == li->type)) current->tgid == li->pid) || type == li->type))
continue; continue;
else { else {
*conf_lock = li; *conf_lock = li;
@ -694,17 +694,17 @@ cifs_find_fid_lock_conflict(struct cifsFileInfo *cfile, __u64 offset,
} }
static bool static bool
cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset, cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
__u64 length, __u8 type, __u16 netfid, __u8 type, struct cifsLockInfo **conf_lock)
struct cifsLockInfo **conf_lock)
{ {
bool rc = false; bool rc = false;
struct cifsFileInfo *fid, *tmp; struct cifsFileInfo *fid, *tmp;
struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
spin_lock(&cifs_file_list_lock); spin_lock(&cifs_file_list_lock);
list_for_each_entry_safe(fid, tmp, &cinode->openFileList, flist) { list_for_each_entry_safe(fid, tmp, &cinode->openFileList, flist) {
rc = cifs_find_fid_lock_conflict(fid, offset, length, type, rc = cifs_find_fid_lock_conflict(fid, offset, length, type,
netfid, conf_lock); cfile, conf_lock);
if (rc) if (rc)
break; break;
} }
@ -732,8 +732,8 @@ cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
mutex_lock(&cinode->lock_mutex); mutex_lock(&cinode->lock_mutex);
exist = cifs_find_lock_conflict(cinode, offset, length, type, exist = cifs_find_lock_conflict(cfile, offset, length, type,
cfile->netfid, &conf_lock); &conf_lock);
if (exist) { if (exist) {
flock->fl_start = conf_lock->offset; flock->fl_start = conf_lock->offset;
flock->fl_end = conf_lock->offset + conf_lock->length - 1; flock->fl_end = conf_lock->offset + conf_lock->length - 1;
@ -779,8 +779,8 @@ try_again:
exist = false; exist = false;
mutex_lock(&cinode->lock_mutex); mutex_lock(&cinode->lock_mutex);
exist = cifs_find_lock_conflict(cinode, lock->offset, lock->length, exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
lock->type, cfile->netfid, &conf_lock); lock->type, &conf_lock);
if (!exist && cinode->can_cache_brlcks) { if (!exist && cinode->can_cache_brlcks) {
list_add_tail(&lock->llist, &cfile->llist); list_add_tail(&lock->llist, &cfile->llist);
mutex_unlock(&cinode->lock_mutex); mutex_unlock(&cinode->lock_mutex);
@ -1116,6 +1116,15 @@ cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
cFYI(1, "Unknown type of lock"); cFYI(1, "Unknown type of lock");
} }
static int
cifs_mandatory_lock(int xid, struct cifsFileInfo *cfile, __u64 offset,
__u64 length, __u32 type, int lock, int unlock, bool wait)
{
return CIFSSMBLock(xid, tlink_tcon(cfile->tlink), cfile->netfid,
current->tgid, length, offset, unlock, lock,
(__u8)type, wait, 0);
}
static int static int
cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
bool wait_flag, bool posix_lck, int xid) bool wait_flag, bool posix_lck, int xid)
@ -1149,12 +1158,11 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
return rc; return rc;
/* BB we could chain these into one lock request BB */ /* BB we could chain these into one lock request BB */
rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length, rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length, type,
flock->fl_start, 0, 1, type, 0, 0); 1, 0, false);
if (rc == 0) { if (rc == 0) {
rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
length, flock->fl_start, 1, 0, type, 0, 1, false);
type, 0, 0);
flock->fl_type = F_UNLCK; flock->fl_type = F_UNLCK;
if (rc != 0) if (rc != 0)
cERROR(1, "Error unlocking previously locked " cERROR(1, "Error unlocking previously locked "
@ -1167,13 +1175,13 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
return 0; return 0;
} }
rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length, rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
flock->fl_start, 0, 1, type | server->vals->shared_lock_type, 1, 0,
type | server->vals->shared_lock_type, 0, 0); false);
if (rc == 0) { if (rc == 0) {
rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
length, flock->fl_start, 1, 0, type | server->vals->shared_lock_type,
type | server->vals->shared_lock_type, 0, 0); 0, 1, false);
flock->fl_type = F_RDLCK; flock->fl_type = F_RDLCK;
if (rc != 0) if (rc != 0)
cERROR(1, "Error unlocking previously locked " cERROR(1, "Error unlocking previously locked "

7
fs/cifs/smb1ops.c
View file

@ -60,8 +60,15 @@ send_nt_cancel(struct TCP_Server_Info *server, void *buf,
return rc; return rc;
} }
static bool
cifs_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
{
return ob1->netfid == ob2->netfid;
}
struct smb_version_operations smb1_operations = { struct smb_version_operations smb1_operations = {
.send_cancel = send_nt_cancel, .send_cancel = send_nt_cancel,
.compare_fids = cifs_compare_fids,
}; };
struct smb_version_values smb1_values = { struct smb_version_values smb1_values = {