[PATCH v2 15/41] filelock: make posix_same_owner take file_lock_core pointers

[Jeff Layton]

Change posix_same_owner to take struct file_lock_core pointers, and
convert the callers to pass those in.

Signed-off-by: Jeff Layton <jlay...@kernel.org>
---
 fs/locks.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/fs/locks.c b/fs/locks.c
index a0d6fc0e043a..bd0cfee230ae 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -590,9 +590,9 @@ static inline int locks_overlap(struct file_lock *fl1, 
struct file_lock *fl2)
 /*
  * Check whether two locks have the same owner.
  */
-static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
+static int posix_same_owner(struct file_lock_core *fl1, struct file_lock_core 
*fl2)
 {
-       return fl1->fl_core.flc_owner == fl2->fl_core.flc_owner;
+       return fl1->flc_owner == fl2->flc_owner;
 }
 
 /* Must be called with the flc_lock held! */
@@ -857,7 +857,7 @@ static bool posix_locks_conflict(struct file_lock 
*caller_fl,
        /* POSIX locks owned by the same process do not conflict with
         * each other.
         */
-       if (posix_same_owner(caller_fl, sys_fl))
+       if (posix_same_owner(&caller_fl->fl_core, &sys_fl->fl_core))
                return false;
 
        /* Check whether they overlap */
@@ -875,7 +875,7 @@ static bool posix_test_locks_conflict(struct file_lock 
*caller_fl,
 {
        /* F_UNLCK checks any locks on the same fd. */
        if (caller_fl->fl_core.flc_type == F_UNLCK) {
-               if (!posix_same_owner(caller_fl, sys_fl))
+               if (!posix_same_owner(&caller_fl->fl_core, &sys_fl->fl_core))
                        return false;
                return locks_overlap(caller_fl, sys_fl);
        }
@@ -978,7 +978,7 @@ static struct file_lock *what_owner_is_waiting_for(struct 
file_lock *block_fl)
        struct file_lock *fl;
 
        hash_for_each_possible(blocked_hash, fl, fl_core.flc_link, 
posix_owner_key(block_fl)) {
-               if (posix_same_owner(fl, block_fl)) {
+               if (posix_same_owner(&fl->fl_core, &block_fl->fl_core)) {
                        while (fl->fl_core.flc_blocker)
                                fl = fl->fl_core.flc_blocker;
                        return fl;
@@ -1005,7 +1005,7 @@ static int posix_locks_deadlock(struct file_lock 
*caller_fl,
        while ((block_fl = what_owner_is_waiting_for(block_fl))) {
                if (i++ > MAX_DEADLK_ITERATIONS)
                        return 0;
-               if (posix_same_owner(caller_fl, block_fl))
+               if (posix_same_owner(&caller_fl->fl_core, &block_fl->fl_core))
                        return 1;
        }
        return 0;
@@ -1178,13 +1178,13 @@ static int posix_lock_inode(struct inode *inode, struct 
file_lock *request,
 
        /* Find the first old lock with the same owner as the new lock */
        list_for_each_entry(fl, &ctx->flc_posix, fl_core.flc_list) {
-               if (posix_same_owner(request, fl))
+               if (posix_same_owner(&request->fl_core, &fl->fl_core))
                        break;
        }
 
        /* Process locks with this owner. */
        list_for_each_entry_safe_from(fl, tmp, &ctx->flc_posix, 
fl_core.flc_list) {
-               if (!posix_same_owner(request, fl))
+               if (!posix_same_owner(&request->fl_core, &fl->fl_core))
                        break;
 
                /* Detect adjacent or overlapping regions (if same lock type) */

-- 
2.43.0