Merge tag 'locks-v3.15-2' of git://git.samba.org/jlayton/linux

Pull file locking fixes from Jeff Layton: "File locking related bugfixes for v3.15 (pile #2) - fix for a long-standing bug in __break_lease that can cause soft lockups - renaming of file-private locks to "open file description" locks, and the command macros to more visually distinct names The fix for __break_lease is also in the pile of patches for which Bruce sent a pull request, but I assume that your merge procedure will handle that correctly. For the other patches, I don't like the fact that we need to rename this stuff at this late stage, but it should be settled now (hopefully)" * tag 'locks-v3.15-2' of git://git.samba.org/jlayton/linux: locks: rename FL_FILE_PVT and IS_FILE_PVT to use "*_OFDLCK" instead locks: rename file-private locks to "open file description locks" locks: allow __break_lease to sleep even when break_time is 0

Merge tag 'locks-v3.15-2' of git://git.samba.org/jlayton/linux
Pull file locking fixes from Jeff Layton: "File locking related bugfixes for v3.15 (pile #2) - fix for a long-standing bug in __break_lease that can cause soft lockups - renaming of file-private locks to "open file description" locks, and the command macros to more visually distinct names The fix for __break_lease is also in the pile of patches for which Bruce sent a pull request, but I assume that your merge procedure will handle that correctly. For the other patches, I don't like the fact that we need to rename this stuff at this late stage, but it should be settled now (hopefully)" * tag 'locks-v3.15-2' of git://git.samba.org/jlayton/linux: locks: rename FL_FILE_PVT and IS_FILE_PVT to use "*_OFDLCK" instead locks: rename file-private locks to "open file description locks" locks: allow __break_lease to sleep even when break_time is 0
Linus Torvalds
2 parents b8e6dece37 cff2fce58b
Showing 7 changed files Side-by-side Diff
arch/arm/kernel/sys_oabi-compat.c
fs/compat.c
fs/fcntl.c
fs/locks.c
include/linux/fs.h
include/uapi/asm-generic/fcntl.h
security/selinux/hooks.c
@@ -203,9 +203,9 @@
 	int ret;
  
 	switch (cmd) {
-	case F_GETLKP:
-	case F_SETLKP:
-	case F_SETLKPW:
+	case F_OFD_GETLK:
+	case F_OFD_SETLK:
+	case F_OFD_SETLKW:
 	case F_GETLK64:
 	case F_SETLK64:
 	case F_SETLKW64:
@@ -457,9 +457,9 @@
 	case F_GETLK64:
 	case F_SETLK64:
 	case F_SETLKW64:
-	case F_GETLKP:
-	case F_SETLKP:
-	case F_SETLKPW:
+	case F_OFD_GETLK:
+	case F_OFD_SETLK:
+	case F_OFD_SETLKW:
 		ret = get_compat_flock64(&f, compat_ptr(arg));
 		if (ret != 0)
 			break;
@@ -468,7 +468,7 @@
 		conv_cmd = convert_fcntl_cmd(cmd);
 		ret = sys_fcntl(fd, conv_cmd, (unsigned long)&f);
 		set_fs(old_fs);
-		if ((conv_cmd == F_GETLK || conv_cmd == F_GETLKP) && ret == 0) {
+		if ((conv_cmd == F_GETLK || conv_cmd == F_OFD_GETLK) && ret == 0) {
 			/* need to return lock information - see above for commentary */
 			if (f.l_start > COMPAT_LOFF_T_MAX)
 				ret = -EOVERFLOW;
@@ -493,9 +493,9 @@
 	case F_GETLK64:
 	case F_SETLK64:
 	case F_SETLKW64:
-	case F_GETLKP:
-	case F_SETLKP:
-	case F_SETLKPW:
+	case F_OFD_GETLK:
+	case F_OFD_SETLK:
+	case F_OFD_SETLKW:
 		return -EINVAL;
 	}
 	return compat_sys_fcntl64(fd, cmd, arg);
@@ -274,15 +274,15 @@
 		break;
 #if BITS_PER_LONG != 32
 	/* 32-bit arches must use fcntl64() */
-	case F_GETLKP:
+	case F_OFD_GETLK:
 #endif
 	case F_GETLK:
 		err = fcntl_getlk(filp, cmd, (struct flock __user *) arg);
 		break;
 #if BITS_PER_LONG != 32
 	/* 32-bit arches must use fcntl64() */
-	case F_SETLKP:
-	case F_SETLKPW:
+	case F_OFD_SETLK:
+	case F_OFD_SETLKW:
 #endif
 		/* Fallthrough */
 	case F_SETLK:
  
@@ -399,13 +399,13 @@
  
 	switch (cmd) {
 	case F_GETLK64:
-	case F_GETLKP:
+	case F_OFD_GETLK:
 		err = fcntl_getlk64(f.file, cmd, (struct flock64 __user *) arg);
 		break;
 	case F_SETLK64:
 	case F_SETLKW64:
-	case F_SETLKP:
-	case F_SETLKPW:
+	case F_OFD_SETLK:
+	case F_OFD_SETLKW:
 		err = fcntl_setlk64(fd, f.file, cmd,
 				(struct flock64 __user *) arg);
 		break;
@@ -135,7 +135,7 @@
 #define IS_POSIX(fl)	(fl->fl_flags & FL_POSIX)
 #define IS_FLOCK(fl)	(fl->fl_flags & FL_FLOCK)
 #define IS_LEASE(fl)	(fl->fl_flags & (FL_LEASE|FL_DELEG))
-#define IS_FILE_PVT(fl)	(fl->fl_flags & FL_FILE_PVT)
+#define IS_OFDLCK(fl)	(fl->fl_flags & FL_OFDLCK)
  
 static bool lease_breaking(struct file_lock *fl)
 {
@@ -564,7 +564,7 @@
 	BUG_ON(!list_empty(&waiter->fl_block));
 	waiter->fl_next = blocker;
 	list_add_tail(&waiter->fl_block, &blocker->fl_block);
-	if (IS_POSIX(blocker) && !IS_FILE_PVT(blocker))
+	if (IS_POSIX(blocker) && !IS_OFDLCK(blocker))
 		locks_insert_global_blocked(waiter);
 }
  
  
@@ -759,12 +759,12 @@
  * of tasks (such as posix threads) sharing the same open file table.
  * To handle those cases, we just bail out after a few iterations.
  *
- * For FL_FILE_PVT locks, the owner is the filp, not the files_struct.
+ * For FL_OFDLCK locks, the owner is the filp, not the files_struct.
  * Because the owner is not even nominally tied to a thread of
  * execution, the deadlock detection below can't reasonably work well. Just
  * skip it for those.
  *
- * In principle, we could do a more limited deadlock detection on FL_FILE_PVT
+ * In principle, we could do a more limited deadlock detection on FL_OFDLCK
  * locks that just checks for the case where two tasks are attempting to
  * upgrade from read to write locks on the same inode.
  */
  
@@ -791,9 +791,9 @@
  
 	/*
 	 * This deadlock detector can't reasonably detect deadlocks with
-	 * FL_FILE_PVT locks, since they aren't owned by a process, per-se.
+	 * FL_OFDLCK locks, since they aren't owned by a process, per-se.
 	 */
-	if (IS_FILE_PVT(caller_fl))
+	if (IS_OFDLCK(caller_fl))
 		return 0;
  
 	while ((block_fl = what_owner_is_waiting_for(block_fl))) {
@@ -1890,7 +1890,7 @@
  
 static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl)
 {
-	flock->l_pid = IS_FILE_PVT(fl) ? -1 : fl->fl_pid;
+	flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid;
 #if BITS_PER_LONG == 32
 	/*
 	 * Make sure we can represent the posix lock via
@@ -1912,7 +1912,7 @@
 #if BITS_PER_LONG == 32
 static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl)
 {
-	flock->l_pid = IS_FILE_PVT(fl) ? -1 : fl->fl_pid;
+	flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid;
 	flock->l_start = fl->fl_start;
 	flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
 		fl->fl_end - fl->fl_start + 1;
  
@@ -1941,13 +1941,13 @@
 	if (error)
 		goto out;
  
-	if (cmd == F_GETLKP) {
+	if (cmd == F_OFD_GETLK) {
 		error = -EINVAL;
 		if (flock.l_pid != 0)
 			goto out;
  
 		cmd = F_GETLK;
-		file_lock.fl_flags |= FL_FILE_PVT;
+		file_lock.fl_flags |= FL_OFDLCK;
 		file_lock.fl_owner = (fl_owner_t)filp;
 	}
  
  
  
  
  
@@ -2073,25 +2073,25 @@
  
 	/*
 	 * If the cmd is requesting file-private locks, then set the
-	 * FL_FILE_PVT flag and override the owner.
+	 * FL_OFDLCK flag and override the owner.
 	 */
 	switch (cmd) {
-	case F_SETLKP:
+	case F_OFD_SETLK:
 		error = -EINVAL;
 		if (flock.l_pid != 0)
 			goto out;
  
 		cmd = F_SETLK;
-		file_lock->fl_flags |= FL_FILE_PVT;
+		file_lock->fl_flags |= FL_OFDLCK;
 		file_lock->fl_owner = (fl_owner_t)filp;
 		break;
-	case F_SETLKPW:
+	case F_OFD_SETLKW:
 		error = -EINVAL;
 		if (flock.l_pid != 0)
 			goto out;
  
 		cmd = F_SETLKW;
-		file_lock->fl_flags |= FL_FILE_PVT;
+		file_lock->fl_flags |= FL_OFDLCK;
 		file_lock->fl_owner = (fl_owner_t)filp;
 		/* Fallthrough */
 	case F_SETLKW:
  
@@ -2143,13 +2143,13 @@
 	if (error)
 		goto out;
  
-	if (cmd == F_GETLKP) {
+	if (cmd == F_OFD_GETLK) {
 		error = -EINVAL;
 		if (flock.l_pid != 0)
 			goto out;
  
 		cmd = F_GETLK64;
-		file_lock.fl_flags |= FL_FILE_PVT;
+		file_lock.fl_flags |= FL_OFDLCK;
 		file_lock.fl_owner = (fl_owner_t)filp;
 	}
  
  
  
  
  
@@ -2208,25 +2208,25 @@
  
 	/*
 	 * If the cmd is requesting file-private locks, then set the
-	 * FL_FILE_PVT flag and override the owner.
+	 * FL_OFDLCK flag and override the owner.
 	 */
 	switch (cmd) {
-	case F_SETLKP:
+	case F_OFD_SETLK:
 		error = -EINVAL;
 		if (flock.l_pid != 0)
 			goto out;
  
 		cmd = F_SETLK64;
-		file_lock->fl_flags |= FL_FILE_PVT;
+		file_lock->fl_flags |= FL_OFDLCK;
 		file_lock->fl_owner = (fl_owner_t)filp;
 		break;
-	case F_SETLKPW:
+	case F_OFD_SETLKW:
 		error = -EINVAL;
 		if (flock.l_pid != 0)
 			goto out;
  
 		cmd = F_SETLKW64;
-		file_lock->fl_flags |= FL_FILE_PVT;
+		file_lock->fl_flags |= FL_OFDLCK;
 		file_lock->fl_owner = (fl_owner_t)filp;
 		/* Fallthrough */
 	case F_SETLKW64:
@@ -2412,8 +2412,8 @@
 	if (IS_POSIX(fl)) {
 		if (fl->fl_flags & FL_ACCESS)
 			seq_printf(f, "ACCESS");
-		else if (IS_FILE_PVT(fl))
-			seq_printf(f, "FLPVT ");
+		else if (IS_OFDLCK(fl))
+			seq_printf(f, "OFDLCK");
 		else
 			seq_printf(f, "POSIX ");
  
@@ -815,7 +815,7 @@
 #define FL_SLEEP	128	/* A blocking lock */
 #define FL_DOWNGRADE_PENDING	256 /* Lease is being downgraded */
 #define FL_UNLOCK_PENDING	512 /* Lease is being broken */
-#define FL_FILE_PVT	1024	/* lock is private to the file */
+#define FL_OFDLCK	1024	/* lock is "owned" by struct file */
  
 /*
  * Special return value from posix_lock_file() and vfs_lock_file() for
@@ -133,20 +133,20 @@
 #endif
  
 /*
- * fd "private" POSIX locks.
+ * Open File Description Locks
  *
- * Usually POSIX locks held by a process are released on *any* close and are
+ * Usually record locks held by a process are released on *any* close and are
  * not inherited across a fork().
  *
- * These cmd values will set locks that conflict with normal POSIX locks, but
- * are "owned" by the opened file, not the process. This means that they are
- * inherited across fork() like BSD (flock) locks, and they are only released
- * automatically when the last reference to the the open file against which
- * they were acquired is put.
+ * These cmd values will set locks that conflict with process-associated
+ * record  locks, but are "owned" by the open file description, not the
+ * process. This means that they are inherited across fork() like BSD (flock)
+ * locks, and they are only released automatically when the last reference to
+ * the the open file against which they were acquired is put.
  */
-#define F_GETLKP	36
-#define F_SETLKP	37
-#define F_SETLKPW	38
+#define F_OFD_GETLK	36
+#define F_OFD_SETLK	37
+#define F_OFD_SETLKW	38
  
 #define F_OWNER_TID	0
 #define F_OWNER_PID	1
@@ -3317,9 +3317,9 @@
 	case F_GETLK:
 	case F_SETLK:
 	case F_SETLKW:
-	case F_GETLKP:
-	case F_SETLKP:
-	case F_SETLKPW:
+	case F_OFD_GETLK:
+	case F_OFD_SETLK:
+	case F_OFD_SETLKW:
 #if BITS_PER_LONG == 32
 	case F_GETLK64:
 	case F_SETLK64:
...	...	@@ -203,9 +203,9 @@
203	203	int ret;
204	204
205	205	switch (cmd) {
206		- case F_GETLKP:
207		- case F_SETLKP:
208		- case F_SETLKPW:
	206	+ case F_OFD_GETLK:
	207	+ case F_OFD_SETLK:
	208	+ case F_OFD_SETLKW:
209	209	case F_GETLK64:
210	210	case F_SETLK64:
211	211	case F_SETLKW64:
...	...	@@ -457,9 +457,9 @@
457	457	case F_GETLK64:
458	458	case F_SETLK64:
459	459	case F_SETLKW64:
460		- case F_GETLKP:
461		- case F_SETLKP:
462		- case F_SETLKPW:
	460	+ case F_OFD_GETLK:
	461	+ case F_OFD_SETLK:
	462	+ case F_OFD_SETLKW:
463	463	ret = get_compat_flock64(&f, compat_ptr(arg));
464	464	if (ret != 0)
465	465	break;
...	...	@@ -468,7 +468,7 @@
468	468	conv_cmd = convert_fcntl_cmd(cmd);
469	469	ret = sys_fcntl(fd, conv_cmd, (unsigned long)&f);
470	470	set_fs(old_fs);
471		- if ((conv_cmd == F_GETLK \|\| conv_cmd == F_GETLKP) && ret == 0) {
	471	+ if ((conv_cmd == F_GETLK \|\| conv_cmd == F_OFD_GETLK) && ret == 0) {
472	472	/* need to return lock information - see above for commentary */
473	473	if (f.l_start > COMPAT_LOFF_T_MAX)
474	474	ret = -EOVERFLOW;
...	...	@@ -493,9 +493,9 @@
493	493	case F_GETLK64:
494	494	case F_SETLK64:
495	495	case F_SETLKW64:
496		- case F_GETLKP:
497		- case F_SETLKP:
498		- case F_SETLKPW:
	496	+ case F_OFD_GETLK:
	497	+ case F_OFD_SETLK:
	498	+ case F_OFD_SETLKW:
499	499	return -EINVAL;
500	500	}
501	501	return compat_sys_fcntl64(fd, cmd, arg);
...	...	@@ -274,15 +274,15 @@
274	274	break;
275	275	#if BITS_PER_LONG != 32
276	276	/* 32-bit arches must use fcntl64() */
277		- case F_GETLKP:
	277	+ case F_OFD_GETLK:
278	278	#endif
279	279	case F_GETLK:
280	280	err = fcntl_getlk(filp, cmd, (struct flock __user *) arg);
281	281	break;
282	282	#if BITS_PER_LONG != 32
283	283	/* 32-bit arches must use fcntl64() */
284		- case F_SETLKP:
285		- case F_SETLKPW:
	284	+ case F_OFD_SETLK:
	285	+ case F_OFD_SETLKW:
286	286	#endif
287	287	/* Fallthrough */
288	288	case F_SETLK:
289	289
...	...	@@ -399,13 +399,13 @@
399	399
400	400	switch (cmd) {
401	401	case F_GETLK64:
402		- case F_GETLKP:
	402	+ case F_OFD_GETLK:
403	403	err = fcntl_getlk64(f.file, cmd, (struct flock64 __user *) arg);
404	404	break;
405	405	case F_SETLK64:
406	406	case F_SETLKW64:
407		- case F_SETLKP:
408		- case F_SETLKPW:
	407	+ case F_OFD_SETLK:
	408	+ case F_OFD_SETLKW:
409	409	err = fcntl_setlk64(fd, f.file, cmd,
410	410	(struct flock64 __user *) arg);
411	411	break;
...	...	@@ -135,7 +135,7 @@
135	135	#define IS_POSIX(fl) (fl->fl_flags & FL_POSIX)
136	136	#define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK)
137	137	#define IS_LEASE(fl) (fl->fl_flags & (FL_LEASE\|FL_DELEG))
138		-#define IS_FILE_PVT(fl) (fl->fl_flags & FL_FILE_PVT)
	138	+#define IS_OFDLCK(fl) (fl->fl_flags & FL_OFDLCK)
139	139
140	140	static bool lease_breaking(struct file_lock *fl)
141	141	{
...	...	@@ -564,7 +564,7 @@
564	564	BUG_ON(!list_empty(&waiter->fl_block));
565	565	waiter->fl_next = blocker;
566	566	list_add_tail(&waiter->fl_block, &blocker->fl_block);
567		- if (IS_POSIX(blocker) && !IS_FILE_PVT(blocker))
	567	+ if (IS_POSIX(blocker) && !IS_OFDLCK(blocker))
568	568	locks_insert_global_blocked(waiter);
569	569	}
570	570
571	571
...	...	@@ -759,12 +759,12 @@
759	759	* of tasks (such as posix threads) sharing the same open file table.
760	760	* To handle those cases, we just bail out after a few iterations.
761	761	*
762		- * For FL_FILE_PVT locks, the owner is the filp, not the files_struct.
	762	+ * For FL_OFDLCK locks, the owner is the filp, not the files_struct.
763	763	* Because the owner is not even nominally tied to a thread of
764	764	* execution, the deadlock detection below can't reasonably work well. Just
765	765	* skip it for those.
766	766	*
767		- * In principle, we could do a more limited deadlock detection on FL_FILE_PVT
	767	+ * In principle, we could do a more limited deadlock detection on FL_OFDLCK
768	768	* locks that just checks for the case where two tasks are attempting to
769	769	* upgrade from read to write locks on the same inode.
770	770	*/
771	771
...	...	@@ -791,9 +791,9 @@
791	791
792	792	/*
793	793	* This deadlock detector can't reasonably detect deadlocks with
794		- * FL_FILE_PVT locks, since they aren't owned by a process, per-se.
	794	+ * FL_OFDLCK locks, since they aren't owned by a process, per-se.
795	795	*/
796		- if (IS_FILE_PVT(caller_fl))
	796	+ if (IS_OFDLCK(caller_fl))
797	797	return 0;
798	798
799	799	while ((block_fl = what_owner_is_waiting_for(block_fl))) {
...	...	@@ -1890,7 +1890,7 @@
1890	1890
1891	1891	static int posix_lock_to_flock(struct flock flock, struct file_lock fl)
1892	1892	{
1893		- flock->l_pid = IS_FILE_PVT(fl) ? -1 : fl->fl_pid;
	1893	+ flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid;
1894	1894	#if BITS_PER_LONG == 32
1895	1895	/*
1896	1896	* Make sure we can represent the posix lock via
...	...	@@ -1912,7 +1912,7 @@
1912	1912	#if BITS_PER_LONG == 32
1913	1913	static void posix_lock_to_flock64(struct flock64 flock, struct file_lock fl)
1914	1914	{
1915		- flock->l_pid = IS_FILE_PVT(fl) ? -1 : fl->fl_pid;
	1915	+ flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid;
1916	1916	flock->l_start = fl->fl_start;
1917	1917	flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1918	1918	fl->fl_end - fl->fl_start + 1;
1919	1919
...	...	@@ -1941,13 +1941,13 @@
1941	1941	if (error)
1942	1942	goto out;
1943	1943
1944		- if (cmd == F_GETLKP) {
	1944	+ if (cmd == F_OFD_GETLK) {
1945	1945	error = -EINVAL;
1946	1946	if (flock.l_pid != 0)
1947	1947	goto out;
1948	1948
1949	1949	cmd = F_GETLK;
1950		- file_lock.fl_flags \|= FL_FILE_PVT;
	1950	+ file_lock.fl_flags \|= FL_OFDLCK;
1951	1951	file_lock.fl_owner = (fl_owner_t)filp;
1952	1952	}
1953	1953
1954	1954
1955	1955
1956	1956
1957	1957
...	...	@@ -2073,25 +2073,25 @@
2073	2073
2074	2074	/*
2075	2075	* If the cmd is requesting file-private locks, then set the
2076		- * FL_FILE_PVT flag and override the owner.
	2076	+ * FL_OFDLCK flag and override the owner.
2077	2077	*/
2078	2078	switch (cmd) {
2079		- case F_SETLKP:
	2079	+ case F_OFD_SETLK:
2080	2080	error = -EINVAL;
2081	2081	if (flock.l_pid != 0)
2082	2082	goto out;
2083	2083
2084	2084	cmd = F_SETLK;
2085		- file_lock->fl_flags \|= FL_FILE_PVT;
	2085	+ file_lock->fl_flags \|= FL_OFDLCK;
2086	2086	file_lock->fl_owner = (fl_owner_t)filp;
2087	2087	break;
2088		- case F_SETLKPW:
	2088	+ case F_OFD_SETLKW:
2089	2089	error = -EINVAL;
2090	2090	if (flock.l_pid != 0)
2091	2091	goto out;
2092	2092
2093	2093	cmd = F_SETLKW;
2094		- file_lock->fl_flags \|= FL_FILE_PVT;
	2094	+ file_lock->fl_flags \|= FL_OFDLCK;
2095	2095	file_lock->fl_owner = (fl_owner_t)filp;
2096	2096	/* Fallthrough */
2097	2097	case F_SETLKW:
2098	2098
...	...	@@ -2143,13 +2143,13 @@
2143	2143	if (error)
2144	2144	goto out;
2145	2145
2146		- if (cmd == F_GETLKP) {
	2146	+ if (cmd == F_OFD_GETLK) {
2147	2147	error = -EINVAL;
2148	2148	if (flock.l_pid != 0)
2149	2149	goto out;
2150	2150
2151	2151	cmd = F_GETLK64;
2152		- file_lock.fl_flags \|= FL_FILE_PVT;
	2152	+ file_lock.fl_flags \|= FL_OFDLCK;
2153	2153	file_lock.fl_owner = (fl_owner_t)filp;
2154	2154	}
2155	2155
2156	2156
2157	2157
2158	2158
2159	2159
...	...	@@ -2208,25 +2208,25 @@
2208	2208
2209	2209	/*
2210	2210	* If the cmd is requesting file-private locks, then set the
2211		- * FL_FILE_PVT flag and override the owner.
	2211	+ * FL_OFDLCK flag and override the owner.
2212	2212	*/
2213	2213	switch (cmd) {
2214		- case F_SETLKP:
	2214	+ case F_OFD_SETLK:
2215	2215	error = -EINVAL;
2216	2216	if (flock.l_pid != 0)
2217	2217	goto out;
2218	2218
2219	2219	cmd = F_SETLK64;
2220		- file_lock->fl_flags \|= FL_FILE_PVT;
	2220	+ file_lock->fl_flags \|= FL_OFDLCK;
2221	2221	file_lock->fl_owner = (fl_owner_t)filp;
2222	2222	break;
2223		- case F_SETLKPW:
	2223	+ case F_OFD_SETLKW:
2224	2224	error = -EINVAL;
2225	2225	if (flock.l_pid != 0)
2226	2226	goto out;
2227	2227
2228	2228	cmd = F_SETLKW64;
2229		- file_lock->fl_flags \|= FL_FILE_PVT;
	2229	+ file_lock->fl_flags \|= FL_OFDLCK;
2230	2230	file_lock->fl_owner = (fl_owner_t)filp;
2231	2231	/* Fallthrough */
2232	2232	case F_SETLKW64:
...	...	@@ -2412,8 +2412,8 @@
2412	2412	if (IS_POSIX(fl)) {
2413	2413	if (fl->fl_flags & FL_ACCESS)
2414	2414	seq_printf(f, "ACCESS");
2415		- else if (IS_FILE_PVT(fl))
2416		- seq_printf(f, "FLPVT ");
	2415	+ else if (IS_OFDLCK(fl))
	2416	+ seq_printf(f, "OFDLCK");
2417	2417	else
2418	2418	seq_printf(f, "POSIX ");
2419	2419
...	...	@@ -815,7 +815,7 @@
815	815	#define FL_SLEEP 128 /* A blocking lock */
816	816	#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */
817	817	#define FL_UNLOCK_PENDING 512 /* Lease is being broken */
818		-#define FL_FILE_PVT 1024 /* lock is private to the file */
	818	+#define FL_OFDLCK 1024 /* lock is "owned" by struct file */
819	819
820	820	/*
821	821	* Special return value from posix_lock_file() and vfs_lock_file() for
...	...	@@ -133,20 +133,20 @@
133	133	#endif
134	134
135	135	/*
136		- * fd "private" POSIX locks.
	136	+ * Open File Description Locks
137	137	*
138		- * Usually POSIX locks held by a process are released on any close and are
	138	+ * Usually record locks held by a process are released on any close and are
139	139	* not inherited across a fork().
140	140	*
141		- * These cmd values will set locks that conflict with normal POSIX locks, but
142		- * are "owned" by the opened file, not the process. This means that they are
143		- * inherited across fork() like BSD (flock) locks, and they are only released
144		- * automatically when the last reference to the the open file against which
145		- * they were acquired is put.
	141	+ * These cmd values will set locks that conflict with process-associated
	142	+ * record locks, but are "owned" by the open file description, not the
	143	+ * process. This means that they are inherited across fork() like BSD (flock)
	144	+ * locks, and they are only released automatically when the last reference to
	145	+ * the the open file against which they were acquired is put.
146	146	*/
147		-#define F_GETLKP 36
148		-#define F_SETLKP 37
149		-#define F_SETLKPW 38
	147	+#define F_OFD_GETLK 36
	148	+#define F_OFD_SETLK 37
	149	+#define F_OFD_SETLKW 38
150	150
151	151	#define F_OWNER_TID 0
152	152	#define F_OWNER_PID 1
...	...	@@ -3317,9 +3317,9 @@
3317	3317	case F_GETLK:
3318	3318	case F_SETLK:
3319	3319	case F_SETLKW:
3320		- case F_GETLKP:
3321		- case F_SETLKP:
3322		- case F_SETLKPW:
	3320	+ case F_OFD_GETLK:
	3321	+ case F_OFD_SETLK:
	3322	+ case F_OFD_SETLKW:
3323	3323	#if BITS_PER_LONG == 32
3324	3324	case F_GETLK64:
3325	3325	case F_SETLK64: