Merge tag '6.9-rc-smb3-client-fixes-part1' of git://git.samba.org/sfrench/cifs-2.6

[sfrench/cifs-2.6.git] / fs / smb / client / file.c

diff --git a/fs/smb/client/file.c b/fs/smb/client/file.c
index 41d2985839806ef6e8e6e555dbfb9e8ec8115529..ec25d3c3e1ee3985152bec6c8e66a801917d9c0e 100644 (file)
--- a/fs/smb/client/file.c
+++ b/fs/smb/client/file.c
@@ -1316,20 +1316,20 @@ cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
        down_read(&cinode->lock_sem);
 
        exist = cifs_find_lock_conflict(cfile, offset, length, type,
-                                       flock->fl_flags, &conf_lock,
+                                       flock->c.flc_flags, &conf_lock,
                                        CIFS_LOCK_OP);
        if (exist) {
                flock->fl_start = conf_lock->offset;
                flock->fl_end = conf_lock->offset + conf_lock->length - 1;
-               flock->fl_pid = conf_lock->pid;
+               flock->c.flc_pid = conf_lock->pid;
                if (conf_lock->type & server->vals->shared_lock_type)
-                       flock->fl_type = F_RDLCK;
+                       flock->c.flc_type = F_RDLCK;
                else
-                       flock->fl_type = F_WRLCK;
+                       flock->c.flc_type = F_WRLCK;
        } else if (!cinode->can_cache_brlcks)
                rc = 1;
        else
-               flock->fl_type = F_UNLCK;
+               flock->c.flc_type = F_UNLCK;
 
        up_read(&cinode->lock_sem);
        return rc;
@@ -1405,16 +1405,16 @@ cifs_posix_lock_test(struct file *file, struct file_lock *flock)
 {
        int rc = 0;
        struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
-       unsigned char saved_type = flock->fl_type;
+       unsigned char saved_type = flock->c.flc_type;
 
-       if ((flock->fl_flags & FL_POSIX) == 0)
+       if ((flock->c.flc_flags & FL_POSIX) == 0)
                return 1;
 
        down_read(&cinode->lock_sem);
        posix_test_lock(file, flock);
 
-       if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
-               flock->fl_type = saved_type;
+       if (lock_is_unlock(flock) && !cinode->can_cache_brlcks) {
+               flock->c.flc_type = saved_type;
                rc = 1;
        }
 
@@ -1435,7 +1435,7 @@ cifs_posix_lock_set(struct file *file, struct file_lock *flock)
        struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
        int rc = FILE_LOCK_DEFERRED + 1;
 
-       if ((flock->fl_flags & FL_POSIX) == 0)
+       if ((flock->c.flc_flags & FL_POSIX) == 0)
                return rc;
 
        cifs_down_write(&cinode->lock_sem);
@@ -1585,7 +1585,9 @@ cifs_push_posix_locks(struct cifsFileInfo *cfile)
 
        el = locks_to_send.next;
        spin_lock(&flctx->flc_lock);
-       list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
+       for_each_file_lock(flock, &flctx->flc_posix) {
+               unsigned char ftype = flock->c.flc_type;
+
                if (el == &locks_to_send) {
                        /*
                         * The list ended. We don't have enough allocated
@@ -1595,12 +1597,12 @@ cifs_push_posix_locks(struct cifsFileInfo *cfile)
                        break;
                }
                length = cifs_flock_len(flock);
-               if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
+               if (ftype == F_RDLCK || ftype == F_SHLCK)
                        type = CIFS_RDLCK;
                else
                        type = CIFS_WRLCK;
                lck = list_entry(el, struct lock_to_push, llist);
-               lck->pid = hash_lockowner(flock->fl_owner);
+               lck->pid = hash_lockowner(flock->c.flc_owner);
                lck->netfid = cfile->fid.netfid;
                lck->length = length;
                lck->type = type;
@@ -1667,42 +1669,43 @@ static void
 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
                bool *wait_flag, struct TCP_Server_Info *server)
 {
-       if (flock->fl_flags & FL_POSIX)
+       if (flock->c.flc_flags & FL_POSIX)
                cifs_dbg(FYI, "Posix\n");
-       if (flock->fl_flags & FL_FLOCK)
+       if (flock->c.flc_flags & FL_FLOCK)
                cifs_dbg(FYI, "Flock\n");
-       if (flock->fl_flags & FL_SLEEP) {
+       if (flock->c.flc_flags & FL_SLEEP) {
                cifs_dbg(FYI, "Blocking lock\n");
                *wait_flag = true;
        }
-       if (flock->fl_flags & FL_ACCESS)
+       if (flock->c.flc_flags & FL_ACCESS)
                cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
-       if (flock->fl_flags & FL_LEASE)
+       if (flock->c.flc_flags & FL_LEASE)
                cifs_dbg(FYI, "Lease on file - not implemented yet\n");
-       if (flock->fl_flags &
+       if (flock->c.flc_flags &
            (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
               FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
-               cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
+               cifs_dbg(FYI, "Unknown lock flags 0x%x\n",
+                        flock->c.flc_flags);
 
        *type = server->vals->large_lock_type;
-       if (flock->fl_type == F_WRLCK) {
+       if (lock_is_write(flock)) {
                cifs_dbg(FYI, "F_WRLCK\n");
                *type |= server->vals->exclusive_lock_type;
                *lock = 1;
-       } else if (flock->fl_type == F_UNLCK) {
+       } else if (lock_is_unlock(flock)) {
                cifs_dbg(FYI, "F_UNLCK\n");
                *type |= server->vals->unlock_lock_type;
                *unlock = 1;
                /* Check if unlock includes more than one lock range */
-       } else if (flock->fl_type == F_RDLCK) {
+       } else if (lock_is_read(flock)) {
                cifs_dbg(FYI, "F_RDLCK\n");
                *type |= server->vals->shared_lock_type;
                *lock = 1;
-       } else if (flock->fl_type == F_EXLCK) {
+       } else if (flock->c.flc_type == F_EXLCK) {
                cifs_dbg(FYI, "F_EXLCK\n");
                *type |= server->vals->exclusive_lock_type;
                *lock = 1;
-       } else if (flock->fl_type == F_SHLCK) {
+       } else if (flock->c.flc_type == F_SHLCK) {
                cifs_dbg(FYI, "F_SHLCK\n");
                *type |= server->vals->shared_lock_type;
                *lock = 1;
@@ -1734,7 +1737,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
                else
                        posix_lock_type = CIFS_WRLCK;
                rc = CIFSSMBPosixLock(xid, tcon, netfid,
-                                     hash_lockowner(flock->fl_owner),
+                                     hash_lockowner(flock->c.flc_owner),
                                      flock->fl_start, length, flock,
                                      posix_lock_type, wait_flag);
                return rc;
@@ -1751,7 +1754,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
        if (rc == 0) {
                rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
                                            type, 0, 1, false);
-               flock->fl_type = F_UNLCK;
+               flock->c.flc_type = F_UNLCK;
                if (rc != 0)
                        cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
                                 rc);
@@ -1759,7 +1762,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
        }
 
        if (type & server->vals->shared_lock_type) {
-               flock->fl_type = F_WRLCK;
+               flock->c.flc_type = F_WRLCK;
                return 0;
        }
 
@@ -1771,12 +1774,12 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
        if (rc == 0) {
                rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
                        type | server->vals->shared_lock_type, 0, 1, false);
-               flock->fl_type = F_RDLCK;
+               flock->c.flc_type = F_RDLCK;
                if (rc != 0)
                        cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
                                 rc);
        } else
-               flock->fl_type = F_WRLCK;
+               flock->c.flc_type = F_WRLCK;
 
        return 0;
 }
@@ -1944,7 +1947,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
                        posix_lock_type = CIFS_UNLCK;
 
                rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
-                                     hash_lockowner(flock->fl_owner),
+                                     hash_lockowner(flock->c.flc_owner),
                                      flock->fl_start, length,
                                      NULL, posix_lock_type, wait_flag);
                goto out;
@@ -1954,7 +1957,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
                struct cifsLockInfo *lock;
 
                lock = cifs_lock_init(flock->fl_start, length, type,
-                                     flock->fl_flags);
+                                     flock->c.flc_flags);
                if (!lock)
                        return -ENOMEM;
 
@@ -1993,7 +1996,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
                rc = server->ops->mand_unlock_range(cfile, flock, xid);
 
 out:
-       if ((flock->fl_flags & FL_POSIX) || (flock->fl_flags & FL_FLOCK)) {
+       if ((flock->c.flc_flags & FL_POSIX) || (flock->c.flc_flags & FL_FLOCK)) {
                /*
                 * If this is a request to remove all locks because we
                 * are closing the file, it doesn't matter if the
@@ -2002,7 +2005,7 @@ out:
                 */
                if (rc) {
                        cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
-                       if (!(flock->fl_flags & FL_CLOSE))
+                       if (!(flock->c.flc_flags & FL_CLOSE))
                                return rc;
                }
                rc = locks_lock_file_wait(file, flock);
@@ -2023,7 +2026,7 @@ int cifs_flock(struct file *file, int cmd, struct file_lock *fl)
 
        xid = get_xid();
 
-       if (!(fl->fl_flags & FL_FLOCK)) {
+       if (!(fl->c.flc_flags & FL_FLOCK)) {
                rc = -ENOLCK;
                free_xid(xid);
                return rc;
@@ -2074,7 +2077,8 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
        xid = get_xid();
 
        cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type=0x%x flags=0x%x r=%lld:%lld\n", __func__, file, cmd,
-                flock->fl_flags, flock->fl_type, (long long)flock->fl_start,
+                flock->c.flc_flags, flock->c.flc_type,
+                (long long)flock->fl_start,
                 (long long)flock->fl_end);
 
        cfile = (struct cifsFileInfo *)file->private_data;