Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 55157dfb authored by Pavel Shilovsky's avatar Pavel Shilovsky
Browse files

CIFS: Separate protocol specific part from getlk 



Signed-off-by: default avatarPavel Shilovsky <piastry@etersoft.ru>
parent 106dc538

fs/cifs/cifsglob.h

+2 −0
Original line number Original line Diff line number Diff line
@@ -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 {

fs/cifs/file.c

+30 −22
Original line number Original line Diff line number Diff line
@@ -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 @@ cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock, 
	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 "

fs/cifs/smb1ops.c

+7 −0
Original line number Original line Diff line number Diff line
@@ -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 = {