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

Commit ff4d7fa8 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

* git://git.samba.org/sfrench/cifs-2.6:
  CIFS: Cleanup byte-range locking code style
  CIFS: Simplify setlk error handling for mandatory locking
parents e0d65113 a88b4707

fs/cifs/file.c

+50 −55
Original line number Original line Diff line number Diff line
@@ -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 @@ cifs_lock_add_if(struct cifsInodeInfo *cinode, __u64 offset, __u64 length, 
					(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);