CIFS: Move brlock code to ops struct

Signed-off-by: Pavel Shilovsky <pshilovsky@samba.org>

diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index b2eb577b5f3f63d84e230d3cebe54f66c08037af..d3c72713fec44c88001466dd0ba5393985d85615 100644 (file)
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -353,6 +353,14 @@ struct smb_version_operations {
        /* query remote filesystem */
        int (*queryfs)(const unsigned int, struct cifs_tcon *,
                       struct kstatfs *);
+       /* send mandatory brlock to the server */
+       int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,
+                        __u64, __u32, int, int, bool);
+       /* unlock range of mandatory locks */
+       int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *,
+                                const unsigned int);
+       /* push brlocks from the cache to the server */
+       int (*push_mand_locks)(struct cifsFileInfo *);
 };
 
 struct smb_version_values {

diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index 3b628f2af258dd0a20b84676c724057541732acc..a7e238f8889869f1f16a007ec393f293d0ee9500 100644 (file)
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -124,6 +124,9 @@ extern u64 cifs_UnixTimeToNT(struct timespec);
 extern struct timespec cnvrtDosUnixTm(__le16 le_date, __le16 le_time,
                                      int offset);
 extern void cifs_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock);
+extern int cifs_unlock_range(struct cifsFileInfo *cfile,
+                            struct file_lock *flock, const unsigned int xid);
+extern int cifs_push_mandatory_locks(struct cifsFileInfo *cfile);
 
 extern struct cifsFileInfo *cifs_new_fileinfo(struct cifs_fid *fid,
                                              struct file *file,

diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 63963730cb285548ce0fdf1aadb758acf7bcac87..90ab83647b82a9d2d9f2da10c422dc33468b2fb6 100644 (file)
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -903,7 +903,7 @@ try_again:
        return rc;
 }
 
-static int
+int
 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
 {
        unsigned int xid;
@@ -1111,7 +1111,7 @@ cifs_push_locks(struct cifsFileInfo *cfile)
            ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
                return cifs_push_posix_locks(cfile);
 
-       return cifs_push_mandatory_locks(cfile);
+       return tcon->ses->server->ops->push_mand_locks(cfile);
 }
 
 static void
@@ -1161,15 +1161,6 @@ cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
                cFYI(1, "Unknown type of lock");
 }
 
-static int
-cifs_mandatory_lock(unsigned 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->fid.netfid,
-                          current->tgid, length, offset, unlock, lock,
-                          (__u8)type, wait, 0);
-}
-
 static int
 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
           bool wait_flag, bool posix_lck, unsigned int xid)
@@ -1203,11 +1194,11 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
                return rc;
 
        /* BB we could chain these into one lock request BB */
-       rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length, type,
-                                1, 0, false);
+       rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
+                                   1, 0, false);
        if (rc == 0) {
-               rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
-                                        type, 0, 1, false);
+               rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
+                                           type, 0, 1, false);
                flock->fl_type = F_UNLCK;
                if (rc != 0)
                        cERROR(1, "Error unlocking previously locked "
@@ -1220,13 +1211,14 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
                return 0;
        }
 
-       rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
-                                type | server->vals->shared_lock_type, 1, 0,
-                                false);
+       type &= ~server->vals->exclusive_lock_type;
+
+       rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
+                                   type | server->vals->shared_lock_type,
+                                   1, 0, false);
        if (rc == 0) {
-               rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
-                                        type | server->vals->shared_lock_type,
-                                        0, 1, false);
+               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;
                if (rc != 0)
                        cERROR(1, "Error unlocking previously locked "
@@ -1256,7 +1248,7 @@ cifs_free_llist(struct list_head *llist)
        }
 }
 
-static int
+int
 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
                  unsigned int xid)
 {
@@ -1408,8 +1400,8 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
                if (rc <= 0)
                        goto out;
 
-               rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
-                                        type, 1, 0, wait_flag);
+               rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
+                                           type, 1, 0, wait_flag);
                if (rc) {
                        kfree(lock);
                        goto out;
@@ -1417,7 +1409,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
 
                cifs_lock_add(cfile, lock);
        } else if (unlock)
-               rc = cifs_unlock_range(cfile, flock, xid);
+               rc = server->ops->mand_unlock_range(cfile, flock, xid);
 
 out:
        if (flock->fl_flags & FL_POSIX)

diff --git a/fs/cifs/smb1ops.c b/fs/cifs/smb1ops.c
index ed7f955323834cf6e707232c6e1c348186735a9b..5fb0fe5f72b60820aee15eedd061e536aa9545bc 100644 (file)
--- a/fs/cifs/smb1ops.c
+++ b/fs/cifs/smb1ops.c
@@ -899,6 +899,15 @@ cifs_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
        return rc;
 }
 
+static int
+cifs_mand_lock(const unsigned 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->fid.netfid,
+                          current->tgid, length, offset, unlock, lock,
+                          (__u8)type, wait, 0);
+}
+
 struct smb_version_operations smb1_operations = {
        .send_cancel = send_nt_cancel,
        .compare_fids = cifs_compare_fids,
@@ -960,6 +969,9 @@ struct smb_version_operations smb1_operations = {
        .calc_smb_size = smbCalcSize,
        .oplock_response = cifs_oplock_response,
        .queryfs = cifs_queryfs,
+       .mand_lock = cifs_mand_lock,
+       .mand_unlock_range = cifs_unlock_range,
+       .push_mand_locks = cifs_push_mandatory_locks,
 };
 
 struct smb_version_values smb1_values = {