10 files changed, 392 insertions, 18 deletions

diff --git a/fs/cifs/Kconfig b/fs/cifs/Kconfig
index a2172f3f69e3..e7b478b49985 100644
--- a/fs/cifs/Kconfig
+++ b/fs/cifs/Kconfig
@@ -192,6 +192,15 @@ config CIFS_SMB2
           options are also slightly simpler (compared to CIFS) due
           to protocol improvements.
 
+config CIFS_SMB311
+        bool "SMB3.1.1 network file system support (Experimental)"
+        depends on CIFS_SMB2 && INET
+
+        help
+          This enables experimental support for the newest, SMB3.1.1, dialect.
+          This dialect includes improved security negotiation features.
+          If unsure, say N
+
 config CIFS_FSCACHE
           bool "Provide CIFS client caching support"
           depends on CIFS=m && FSCACHE || CIFS=y && FSCACHE=y
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index 22b289a3b1c4..b406a32deb1f 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -171,6 +171,10 @@ enum smb_version {
         Smb_21,
         Smb_30,
         Smb_302,
+#ifdef CONFIG_CIFS_SMB311
+        Smb_311,
+#endif /* SMB311 */
+        Smb_version_err
 };
 
 struct mid_q_entry;
@@ -368,6 +372,8 @@ struct smb_version_operations {
         void (*new_lease_key)(struct cifs_fid *);
         int (*generate_signingkey)(struct cifs_ses *);
         int (*calc_signature)(struct smb_rqst *, struct TCP_Server_Info *);
+        int (*set_integrity)(const unsigned int, struct cifs_tcon *tcon,
+                             struct cifsFileInfo *src_file);
         int (*query_mf_symlink)(unsigned int, struct cifs_tcon *,
                                 struct cifs_sb_info *, const unsigned char *,
                                 char *, unsigned int *);
@@ -386,6 +392,9 @@ struct smb_version_operations {
         int (*clone_range)(const unsigned int, struct cifsFileInfo *src_file,
                         struct cifsFileInfo *target_file, u64 src_off, u64 len,
                         u64 dest_off);
+        int (*duplicate_extents)(const unsigned int, struct cifsFileInfo *src,
+                        struct cifsFileInfo *target_file, u64 src_off, u64 len,
+                        u64 dest_off);
         int (*validate_negotiate)(const unsigned int, struct cifs_tcon *);
         ssize_t (*query_all_EAs)(const unsigned int, struct cifs_tcon *,
                         const unsigned char *, const unsigned char *, char *,
@@ -1617,4 +1626,8 @@ extern struct smb_version_values smb30_values;
 #define SMB302_VERSION_STRING   "3.02"
 /*extern struct smb_version_operations smb302_operations;*/ /* not needed yet */
 extern struct smb_version_values smb302_values;
+#define SMB311_VERSION_STRING   "3.1.1"
+#define ALT_SMB311_VERSION_STRING "3.11"
+extern struct smb_version_operations smb311_operations;
+extern struct smb_version_values smb311_values;
 #endif  /* _CIFS_GLOB_H */
diff --git a/fs/cifs/cifspdu.h b/fs/cifs/cifspdu.h
index 5f9822ac0245..47b030da0781 100644
--- a/fs/cifs/cifspdu.h
+++ b/fs/cifs/cifspdu.h
@@ -2255,6 +2255,8 @@ typedef struct {
 
 
 /* List of FileSystemAttributes - see 2.5.1 of MS-FSCC */
+#define FILE_SUPPORTS_SPARSE_VDL        0x10000000 /* faster nonsparse extend */
+#define FILE_SUPPORTS_BLOCK_REFCOUNTING 0x08000000 /* allow ioctl dup extents */
 #define FILE_SUPPORT_INTEGRITY_STREAMS  0x04000000
 #define FILE_SUPPORTS_USN_JOURNAL       0x02000000
 #define FILE_SUPPORTS_OPEN_BY_FILE_ID   0x01000000
@@ -2310,6 +2312,16 @@ typedef struct { /* data block encoding of response to level 263 QPathInfo */
         char FileName[1];
 } __attribute__((packed)) FILE_ALL_INFO;        /* level 0x107 QPathInfo */
 
+typedef struct {
+        __le64 AllocationSize;
+        __le64 EndOfFile;       /* size ie offset to first free byte in file */
+        __le32 NumberOfLinks;   /* hard links */
+        __u8 DeletePending;
+        __u8 Directory;
+        __u16 Pad;
+} __attribute__((packed)) FILE_STANDARD_INFO;   /* level 0x102 QPathInfo */
+
+
 /* defines for enumerating possible values of the Unix type field below */
 #define UNIX_FILE      0
 #define UNIX_DIR       1
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index f26ffbfc64d8..672ef35c9f73 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -625,9 +625,8 @@ CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
                 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
                 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
                        CIFS_CRYPTO_KEY_SIZE);
-        } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
-                        server->capabilities & CAP_EXTENDED_SECURITY) &&
-                                (pSMBr->EncryptionKeyLength == 0)) {
+        } else if (pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
+                        server->capabilities & CAP_EXTENDED_SECURITY) {
                 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
                 rc = decode_ext_sec_blob(ses, pSMBr);
         } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 8383d5ea4202..773f4dc77630 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -280,6 +280,11 @@ static const match_table_t cifs_smb_version_tokens = {
         { Smb_21, SMB21_VERSION_STRING },
         { Smb_30, SMB30_VERSION_STRING },
         { Smb_302, SMB302_VERSION_STRING },
+#ifdef CONFIG_CIFS_SMB311
+        { Smb_311, SMB311_VERSION_STRING },
+        { Smb_311, ALT_SMB311_VERSION_STRING },
+#endif /* SMB311 */
+        { Smb_version_err, NULL }
 };
 
 static int ip_connect(struct TCP_Server_Info *server);
@@ -1133,6 +1138,12 @@ cifs_parse_smb_version(char *value, struct smb_vol *vol)
                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
                 vol->vals = &smb302_values;
                 break;
+#ifdef CONFIG_CIFS_SMB311
+        case Smb_311:
+                vol->ops = &smb311_operations;
+                vol->vals = &smb311_values;
+                break;
+#endif /* SMB311 */
 #endif
         default:
                 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
@@ -3461,6 +3472,8 @@ try_mount_again:
                 else if (ses)
                         cifs_put_smb_ses(ses);
 
+                cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
+
                 free_xid(xid);
         }
 #endif
diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index 8b7898b7670f..49b8b6e41a18 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -31,12 +31,15 @@
 #include "cifsproto.h"
 #include "cifs_debug.h"
 #include "cifsfs.h"
+#include <linux/btrfs.h>
 
 #define CIFS_IOCTL_MAGIC        0xCF
 #define CIFS_IOC_COPYCHUNK_FILE _IOW(CIFS_IOCTL_MAGIC, 3, int)
+#define CIFS_IOC_SET_INTEGRITY  _IO(CIFS_IOCTL_MAGIC, 4)
 
 static long cifs_ioctl_clone(unsigned int xid, struct file *dst_file,
-                        unsigned long srcfd, u64 off, u64 len, u64 destoff)
+                        unsigned long srcfd, u64 off, u64 len, u64 destoff,
+                        bool dup_extents)
 {
         int rc;
         struct cifsFileInfo *smb_file_target = dst_file->private_data;
@@ -109,9 +112,14 @@ static long cifs_ioctl_clone(unsigned int xid, struct file *dst_file,
         truncate_inode_pages_range(&target_inode->i_data, destoff,
                                    PAGE_CACHE_ALIGN(destoff + len)-1);
 
-        if (target_tcon->ses->server->ops->clone_range)
+        if (dup_extents && target_tcon->ses->server->ops->duplicate_extents)
+                rc = target_tcon->ses->server->ops->duplicate_extents(xid,
+                        smb_file_src, smb_file_target, off, len, destoff);
+        else if (!dup_extents && target_tcon->ses->server->ops->clone_range)
                 rc = target_tcon->ses->server->ops->clone_range(xid,
                         smb_file_src, smb_file_target, off, len, destoff);
+        else
+                rc = -EOPNOTSUPP;
 
         /* force revalidate of size and timestamps of target file now
            that target is updated on the server */
@@ -205,7 +213,20 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
                         }
                         break;
                 case CIFS_IOC_COPYCHUNK_FILE:
-                        rc = cifs_ioctl_clone(xid, filep, arg, 0, 0, 0);
+                        rc = cifs_ioctl_clone(xid, filep, arg, 0, 0, 0, false);
+                        break;
+                case BTRFS_IOC_CLONE:
+                        rc = cifs_ioctl_clone(xid, filep, arg, 0, 0, 0, true);
+                        break;
+                case CIFS_IOC_SET_INTEGRITY:
+                        if (pSMBFile == NULL)
+                                break;
+                        tcon = tlink_tcon(pSMBFile->tlink);
+                        if (tcon->ses->server->ops->set_integrity)
+                                rc = tcon->ses->server->ops->set_integrity(xid,
+                                                tcon, pSMBFile);
+                        else
+                                rc = -EOPNOTSUPP;
                         break;
                 default:
                         cifs_dbg(FYI, "unsupported ioctl\n");
diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c
index 54daee5ad4c1..df91bcf56d67 100644
--- a/fs/cifs/smb2ops.c
+++ b/fs/cifs/smb2ops.c
@@ -806,6 +806,53 @@ smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon,
                             cfile->fid.volatile_fid, cfile->pid, &eof, false);
 }
 
+#ifdef CONFIG_CIFS_SMB311
+static int
+smb2_duplicate_extents(const unsigned int xid,
+                        struct cifsFileInfo *srcfile,
+                        struct cifsFileInfo *trgtfile, u64 src_off,
+                        u64 len, u64 dest_off)
+{
+        int rc;
+        unsigned int ret_data_len;
+        char *retbuf = NULL;
+        struct duplicate_extents_to_file dup_ext_buf;
+        struct cifs_tcon *tcon = tlink_tcon(trgtfile->tlink);
+
+        /* server fileays advertise duplicate extent support with this flag */
+        if ((le32_to_cpu(tcon->fsAttrInfo.Attributes) &
+             FILE_SUPPORTS_BLOCK_REFCOUNTING) == 0)
+                return -EOPNOTSUPP;
+
+        dup_ext_buf.VolatileFileHandle = srcfile->fid.volatile_fid;
+        dup_ext_buf.PersistentFileHandle = srcfile->fid.persistent_fid;
+        dup_ext_buf.SourceFileOffset = cpu_to_le64(src_off);
+        dup_ext_buf.TargetFileOffset = cpu_to_le64(dest_off);
+        dup_ext_buf.ByteCount = cpu_to_le64(len);
+        cifs_dbg(FYI, "duplicate extents: src off %lld dst off %lld len %lld",
+                src_off, dest_off, len);
+
+        rc = smb2_set_file_size(xid, tcon, trgtfile, dest_off + len, false);
+        if (rc)
+                goto duplicate_extents_out;
+
+        rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
+                        trgtfile->fid.volatile_fid,
+                        FSCTL_DUPLICATE_EXTENTS_TO_FILE,
+                        true /* is_fsctl */, (char *)&dup_ext_buf,
+                        sizeof(struct duplicate_extents_to_file),
+                        (char **)&retbuf,
+                        &ret_data_len);
+
+        if (ret_data_len > 0)
+                cifs_dbg(FYI, "non-zero response length in duplicate extents");
+
+duplicate_extents_out:
+        return rc;
+}
+#endif /* CONFIG_CIFS_SMB311 */
+
+
 static int
 smb2_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
                    struct cifsFileInfo *cfile)
@@ -815,6 +862,28 @@ smb2_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
 }
 
 static int
+smb3_set_integrity(const unsigned int xid, struct cifs_tcon *tcon,
+                   struct cifsFileInfo *cfile)
+{
+        struct fsctl_set_integrity_information_req integr_info;
+        char *retbuf = NULL;
+        unsigned int ret_data_len;
+
+        integr_info.ChecksumAlgorithm = cpu_to_le16(CHECKSUM_TYPE_UNCHANGED);
+        integr_info.Flags = 0;
+        integr_info.Reserved = 0;
+
+        return SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
+                        cfile->fid.volatile_fid,
+                        FSCTL_SET_INTEGRITY_INFORMATION,
+                        true /* is_fsctl */, (char *)&integr_info,
+                        sizeof(struct fsctl_set_integrity_information_req),
+                        (char **)&retbuf,
+                        &ret_data_len);
+
+}
+
+static int
 smb2_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
                      const char *path, struct cifs_sb_info *cifs_sb,
                      struct cifs_fid *fid, __u16 search_flags,
@@ -1624,6 +1693,7 @@ struct smb_version_operations smb30_operations = {
         .new_lease_key = smb2_new_lease_key,
         .generate_signingkey = generate_smb3signingkey,
         .calc_signature = smb3_calc_signature,
+        .set_integrity  = smb3_set_integrity,
         .is_read_op = smb21_is_read_op,
         .set_oplock_level = smb3_set_oplock_level,
         .create_lease_buf = smb3_create_lease_buf,
@@ -1635,6 +1705,94 @@ struct smb_version_operations smb30_operations = {
         .fallocate = smb3_fallocate,
 };
 
+#ifdef CONFIG_CIFS_SMB311
+struct smb_version_operations smb311_operations = {
+        .compare_fids = smb2_compare_fids,
+        .setup_request = smb2_setup_request,
+        .setup_async_request = smb2_setup_async_request,
+        .check_receive = smb2_check_receive,
+        .add_credits = smb2_add_credits,
+        .set_credits = smb2_set_credits,
+        .get_credits_field = smb2_get_credits_field,
+        .get_credits = smb2_get_credits,
+        .wait_mtu_credits = smb2_wait_mtu_credits,
+        .get_next_mid = smb2_get_next_mid,
+        .read_data_offset = smb2_read_data_offset,
+        .read_data_length = smb2_read_data_length,
+        .map_error = map_smb2_to_linux_error,
+        .find_mid = smb2_find_mid,
+        .check_message = smb2_check_message,
+        .dump_detail = smb2_dump_detail,
+        .clear_stats = smb2_clear_stats,
+        .print_stats = smb2_print_stats,
+        .dump_share_caps = smb2_dump_share_caps,
+        .is_oplock_break = smb2_is_valid_oplock_break,
+        .downgrade_oplock = smb2_downgrade_oplock,
+        .need_neg = smb2_need_neg,
+        .negotiate = smb2_negotiate,
+        .negotiate_wsize = smb2_negotiate_wsize,
+        .negotiate_rsize = smb2_negotiate_rsize,
+        .sess_setup = SMB2_sess_setup,
+        .logoff = SMB2_logoff,
+        .tree_connect = SMB2_tcon,
+        .tree_disconnect = SMB2_tdis,
+        .qfs_tcon = smb3_qfs_tcon,
+        .is_path_accessible = smb2_is_path_accessible,
+        .can_echo = smb2_can_echo,
+        .echo = SMB2_echo,
+        .query_path_info = smb2_query_path_info,
+        .get_srv_inum = smb2_get_srv_inum,
+        .query_file_info = smb2_query_file_info,
+        .set_path_size = smb2_set_path_size,
+        .set_file_size = smb2_set_file_size,
+        .set_file_info = smb2_set_file_info,
+        .set_compression = smb2_set_compression,
+        .mkdir = smb2_mkdir,
+        .mkdir_setinfo = smb2_mkdir_setinfo,
+        .rmdir = smb2_rmdir,
+        .unlink = smb2_unlink,
+        .rename = smb2_rename_path,
+        .create_hardlink = smb2_create_hardlink,
+        .query_symlink = smb2_query_symlink,
+        .query_mf_symlink = smb3_query_mf_symlink,
+        .create_mf_symlink = smb3_create_mf_symlink,
+        .open = smb2_open_file,
+        .set_fid = smb2_set_fid,
+        .close = smb2_close_file,
+        .flush = smb2_flush_file,
+        .async_readv = smb2_async_readv,
+        .async_writev = smb2_async_writev,
+        .sync_read = smb2_sync_read,
+        .sync_write = smb2_sync_write,
+        .query_dir_first = smb2_query_dir_first,
+        .query_dir_next = smb2_query_dir_next,
+        .close_dir = smb2_close_dir,
+        .calc_smb_size = smb2_calc_size,
+        .is_status_pending = smb2_is_status_pending,
+        .oplock_response = smb2_oplock_response,
+        .queryfs = smb2_queryfs,
+        .mand_lock = smb2_mand_lock,
+        .mand_unlock_range = smb2_unlock_range,
+        .push_mand_locks = smb2_push_mandatory_locks,
+        .get_lease_key = smb2_get_lease_key,
+        .set_lease_key = smb2_set_lease_key,
+        .new_lease_key = smb2_new_lease_key,
+        .generate_signingkey = generate_smb3signingkey,
+        .calc_signature = smb3_calc_signature,
+        .set_integrity  = smb3_set_integrity,
+        .is_read_op = smb21_is_read_op,
+        .set_oplock_level = smb3_set_oplock_level,
+        .create_lease_buf = smb3_create_lease_buf,
+        .parse_lease_buf = smb3_parse_lease_buf,
+        .clone_range = smb2_clone_range,
+        .duplicate_extents = smb2_duplicate_extents,
+/*      .validate_negotiate = smb3_validate_negotiate, */ /* not used in 3.11 */
+        .wp_retry_size = smb2_wp_retry_size,
+        .dir_needs_close = smb2_dir_needs_close,
+        .fallocate = smb3_fallocate,
+};
+#endif /* CIFS_SMB311 */
+
 struct smb_version_values smb20_values = {
         .version_string = SMB20_VERSION_STRING,
         .protocol_id = SMB20_PROT_ID,
@@ -1714,3 +1872,25 @@ struct smb_version_values smb302_values = {
         .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
         .create_lease_size = sizeof(struct create_lease_v2),
 };
+
+#ifdef CONFIG_CIFS_SMB311
+struct smb_version_values smb311_values = {
+        .version_string = SMB311_VERSION_STRING,
+        .protocol_id = SMB311_PROT_ID,
+        .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU,
+        .large_lock_type = 0,
+        .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
+        .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
+        .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
+        .header_size = sizeof(struct smb2_hdr),
+        .max_header_size = MAX_SMB2_HDR_SIZE,
+        .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
+        .lock_cmd = SMB2_LOCK,
+        .cap_unix = 0,
+        .cap_nt_find = SMB2_NT_FIND,
+        .cap_large_files = SMB2_LARGE_FILES,
+        .signing_enabled = SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED,
+        .signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
+        .create_lease_size = sizeof(struct create_lease_v2),
+};
+#endif /* SMB311 */
diff --git a/fs/cifs/smb2pdu.c b/fs/cifs/smb2pdu.c
index 54cbe19d9c08..b8b4f08ee094 100644
--- a/fs/cifs/smb2pdu.c
+++ b/fs/cifs/smb2pdu.c
@@ -304,6 +304,59 @@ small_smb2_init(__le16 smb2_command, struct cifs_tcon *tcon,
         return rc;
 }
 
+#ifdef CONFIG_CIFS_SMB311
+/* offset is sizeof smb2_negotiate_req - 4 but rounded up to 8 bytes */
+#define OFFSET_OF_NEG_CONTEXT 0x68  /* sizeof(struct smb2_negotiate_req) - 4 */
+
+
+#define SMB2_PREAUTH_INTEGRITY_CAPABILITIES     cpu_to_le16(1)
+#define SMB2_ENCRYPTION_CAPABILITIES            cpu_to_le16(2)
+
+static void
+build_preauth_ctxt(struct smb2_preauth_neg_context *pneg_ctxt)
+{
+        pneg_ctxt->ContextType = SMB2_PREAUTH_INTEGRITY_CAPABILITIES;
+        pneg_ctxt->DataLength = cpu_to_le16(38);
+        pneg_ctxt->HashAlgorithmCount = cpu_to_le16(1);
+        pneg_ctxt->SaltLength = cpu_to_le16(SMB311_SALT_SIZE);
+        get_random_bytes(pneg_ctxt->Salt, SMB311_SALT_SIZE);
+        pneg_ctxt->HashAlgorithms = SMB2_PREAUTH_INTEGRITY_SHA512;
+}
+
+static void
+build_encrypt_ctxt(struct smb2_encryption_neg_context *pneg_ctxt)
+{
+        pneg_ctxt->ContextType = SMB2_ENCRYPTION_CAPABILITIES;
+        pneg_ctxt->DataLength = cpu_to_le16(6);
+        pneg_ctxt->CipherCount = cpu_to_le16(2);
+        pneg_ctxt->Ciphers[0] = SMB2_ENCRYPTION_AES128_GCM;
+        pneg_ctxt->Ciphers[1] = SMB2_ENCRYPTION_AES128_CCM;
+}
+
+static void
+assemble_neg_contexts(struct smb2_negotiate_req *req)
+{
+
+        /* +4 is to account for the RFC1001 len field */
+        char *pneg_ctxt = (char *)req + OFFSET_OF_NEG_CONTEXT + 4;
+
+        build_preauth_ctxt((struct smb2_preauth_neg_context *)pneg_ctxt);
+        /* Add 2 to size to round to 8 byte boundary */
+        pneg_ctxt += 2 + sizeof(struct smb2_preauth_neg_context);
+        build_encrypt_ctxt((struct smb2_encryption_neg_context *)pneg_ctxt);
+        req->NegotiateContextOffset = cpu_to_le32(OFFSET_OF_NEG_CONTEXT);
+        req->NegotiateContextCount = cpu_to_le16(2);
+        inc_rfc1001_len(req, 4 + sizeof(struct smb2_preauth_neg_context) + 2
+                        + sizeof(struct smb2_encryption_neg_context)); /* calculate hash */
+}
+#else
+static void assemble_neg_contexts(struct smb2_negotiate_req *req)
+{
+        return;
+}
+#endif /* SMB311 */
+
+
 /*
  *
  *      SMB2 Worker functions follow:
@@ -363,10 +416,12 @@ SMB2_negotiate(const unsigned int xid, struct cifs_ses *ses)
         /* ClientGUID must be zero for SMB2.02 dialect */
         if (ses->server->vals->protocol_id == SMB20_PROT_ID)
                 memset(req->ClientGUID, 0, SMB2_CLIENT_GUID_SIZE);
-        else
+        else {
                 memcpy(req->ClientGUID, server->client_guid,
                         SMB2_CLIENT_GUID_SIZE);
-
+                if (ses->server->vals->protocol_id == SMB311_PROT_ID)
+                        assemble_neg_contexts(req);
+        }
         iov[0].iov_base = (char *)req;
         /* 4 for rfc1002 length field */
         iov[0].iov_len = get_rfc1002_length(req) + 4;
@@ -393,8 +448,12 @@ SMB2_negotiate(const unsigned int xid, struct cifs_ses *ses)
                 cifs_dbg(FYI, "negotiated smb3.0 dialect\n");
         else if (rsp->DialectRevision == cpu_to_le16(SMB302_PROT_ID))
                 cifs_dbg(FYI, "negotiated smb3.02 dialect\n");
+#ifdef CONFIG_CIFS_SMB311
+        else if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID))
+                cifs_dbg(FYI, "negotiated smb3.1.1 dialect\n");
+#endif /* SMB311 */
         else {
-                cifs_dbg(VFS, "Illegal dialect returned by server %d\n",
+                cifs_dbg(VFS, "Illegal dialect returned by server 0x%x\n",
                          le16_to_cpu(rsp->DialectRevision));
                 rc = -EIO;
                 goto neg_exit;
@@ -572,7 +631,7 @@ ssetup_ntlmssp_authenticate:
                 return rc;
 
         req->hdr.SessionId = 0; /* First session, not a reauthenticate */
-        req->VcNumber = 0; /* MBZ */
+        req->Flags = 0; /* MBZ */
         /* to enable echos and oplocks */
         req->hdr.CreditRequest = cpu_to_le16(3);
 
diff --git a/fs/cifs/smb2pdu.h b/fs/cifs/smb2pdu.h
index 70867d54fb8b..451108284a2f 100644
--- a/fs/cifs/smb2pdu.h
+++ b/fs/cifs/smb2pdu.h
@@ -136,9 +136,6 @@ struct smb2_transform_hdr {
         __u64  SessionId;
 } __packed;
 
-/* Encryption Algorithms */
-#define SMB2_ENCRYPTION_AES128_CCM      cpu_to_le16(0x0001)
-
 /*
  *      SMB2 flag definitions
  */
@@ -191,7 +188,10 @@ struct smb2_negotiate_req {
         __le16 Reserved;        /* MBZ */
         __le32 Capabilities;
         __u8   ClientGUID[SMB2_CLIENT_GUID_SIZE];
-        __le64 ClientStartTime; /* MBZ */
+        /* In SMB3.02 and earlier next three were MBZ le64 ClientStartTime */
+        __le32 NegotiateContextOffset; /* SMB3.1.1 only. MBZ earlier */
+        __le16 NegotiateContextCount;  /* SMB3.1.1 only. MBZ earlier */
+        __le16 Reserved2;
         __le16 Dialects[1]; /* One dialect (vers=) at a time for now */
 } __packed;
 
@@ -200,6 +200,7 @@ struct smb2_negotiate_req {
 #define SMB21_PROT_ID 0x0210
 #define SMB30_PROT_ID 0x0300
 #define SMB302_PROT_ID 0x0302
+#define SMB311_PROT_ID 0x0311
 #define BAD_PROT_ID   0xFFFF
 
 /* SecurityMode flags */
@@ -217,12 +218,38 @@ struct smb2_negotiate_req {
 #define SMB2_NT_FIND                    0x00100000
 #define SMB2_LARGE_FILES                0x00200000
 
+#define SMB311_SALT_SIZE                        32
+/* Hash Algorithm Types */
+#define SMB2_PREAUTH_INTEGRITY_SHA512   cpu_to_le16(0x0001)
+
+struct smb2_preauth_neg_context {
+        __le16  ContextType; /* 1 */
+        __le16  DataLength;
+        __le32  Reserved;
+        __le16  HashAlgorithmCount; /* 1 */
+        __le16  SaltLength;
+        __le16  HashAlgorithms; /* HashAlgorithms[0] since only one defined */
+        __u8    Salt[SMB311_SALT_SIZE];
+} __packed;
+
+/* Encryption Algorithms Ciphers */
+#define SMB2_ENCRYPTION_AES128_CCM      cpu_to_le16(0x0001)
+#define SMB2_ENCRYPTION_AES128_GCM      cpu_to_le16(0x0002)
+
+struct smb2_encryption_neg_context {
+        __le16  ContextType; /* 2 */
+        __le16  DataLength;
+        __le32  Reserved;
+        __le16  CipherCount; /* AES-128-GCM and AES-128-CCM */
+        __le16  Ciphers[2]; /* Ciphers[0] since only one used now */
+} __packed;
+
 struct smb2_negotiate_rsp {
         struct smb2_hdr hdr;
         __le16 StructureSize;   /* Must be 65 */
         __le16 SecurityMode;
         __le16 DialectRevision;
-        __le16 Reserved;        /* MBZ */
+        __le16 NegotiateContextCount;   /* Prior to SMB3.1.1 was Reserved & MBZ */
         __u8   ServerGUID[16];
         __le32 Capabilities;
         __le32 MaxTransactSize;
@@ -232,14 +259,18 @@ struct smb2_negotiate_rsp {
         __le64 ServerStartTime;
         __le16 SecurityBufferOffset;
         __le16 SecurityBufferLength;
-        __le32 Reserved2;       /* may be any value, ignore */
+        __le32 NegotiateContextOffset;  /* Pre:SMB3.1.1 was reserved/ignored */
         __u8   Buffer[1];       /* variable length GSS security buffer */
 } __packed;
 
+/* Flags */
+#define SMB2_SESSION_REQ_FLAG_BINDING           0x01
+#define SMB2_SESSION_REQ_FLAG_ENCRYPT_DATA      0x04
+
 struct smb2_sess_setup_req {
         struct smb2_hdr hdr;
         __le16 StructureSize; /* Must be 25 */
-        __u8   VcNumber;
+        __u8   Flags;
         __u8   SecurityMode;
         __le32 Capabilities;
         __le32 Channel;
@@ -274,10 +305,13 @@ struct smb2_logoff_rsp {
         __le16 Reserved;
 } __packed;
 
+/* Flags/Reserved for SMB3.1.1 */
+#define SMB2_SHAREFLAG_CLUSTER_RECONNECT        0x0001
+
 struct smb2_tree_connect_req {
         struct smb2_hdr hdr;
         __le16 StructureSize;   /* Must be 9 */
-        __le16 Reserved;
+        __le16 Reserved; /* Flags in SMB3.1.1 */
         __le16 PathOffset;
         __le16 PathLength;
         __u8   Buffer[1];       /* variable length */
@@ -587,6 +621,29 @@ struct copychunk_ioctl_rsp {
         __le32 TotalBytesWritten;
 } __packed;
 
+struct fsctl_set_integrity_information_req {
+        __le16  ChecksumAlgorithm;
+        __le16  Reserved;
+        __le32  Flags;
+} __packed;
+
+struct fsctl_get_integrity_information_rsp {
+        __le16  ChecksumAlgorithm;
+        __le16  Reserved;
+        __le32  Flags;
+        __le32  ChecksumChunkSizeInBytes;
+        __le32  ClusterSizeInBytes;
+} __packed;
+
+/* Integrity ChecksumAlgorithm choices for above */
+#define CHECKSUM_TYPE_NONE      0x0000
+#define CHECKSUM_TYPE_CRC64     0x0002
+#define CHECKSUM_TYPE_UNCHANGED 0xFFFF  /* set only */
+
+/* Integrity flags for above */
+#define FSCTL_INTEGRITY_FLAG_CHECKSUM_ENFORCEMENT_OFF   0x00000001
+
+
 struct validate_negotiate_info_req {
         __le32 Capabilities;
         __u8   Guid[SMB2_CLIENT_GUID_SIZE];
@@ -620,6 +677,14 @@ struct compress_ioctl {
         __le16 CompressionState; /* See cifspdu.h for possible flag values */
 } __packed;
 
+struct duplicate_extents_to_file {
+        __u64 PersistentFileHandle; /* source file handle, opaque endianness */
+        __u64 VolatileFileHandle;
+        __le64 SourceFileOffset;
+        __le64 TargetFileOffset;
+        __le64 ByteCount;  /* Bytes to be copied */
+} __packed;
+
 struct smb2_ioctl_req {
         struct smb2_hdr hdr;
         __le16 StructureSize;   /* Must be 57 */
diff --git a/fs/cifs/smbfsctl.h b/fs/cifs/smbfsctl.h
index 83efa59535be..a639d0dab453 100644
--- a/fs/cifs/smbfsctl.h
+++ b/fs/cifs/smbfsctl.h
@@ -75,10 +75,13 @@
 #define FSCTL_QUERY_SPARING_INFO     0x00090138 /* BB add struct */
 #define FSCTL_SET_ZERO_ON_DEALLOC    0x00090194 /* BB add struct */
 #define FSCTL_SET_SHORT_NAME_BEHAVIOR 0x000901B4 /* BB add struct */
+#define FSCTL_GET_INTEGRITY_INFORMATION 0x0009027C
 #define FSCTL_QUERY_ALLOCATED_RANGES 0x000940CF /* BB add struct */
 #define FSCTL_SET_DEFECT_MANAGEMENT  0x00098134 /* BB add struct */
 #define FSCTL_FILE_LEVEL_TRIM        0x00098208 /* BB add struct */
+#define FSCTL_DUPLICATE_EXTENTS_TO_FILE 0x00098344
 #define FSCTL_SIS_LINK_FILES         0x0009C104
+#define FSCTL_SET_INTEGRITY_INFORMATION 0x0009C280
 #define FSCTL_PIPE_PEEK              0x0011400C /* BB add struct */
 #define FSCTL_PIPE_TRANSCEIVE        0x0011C017 /* BB add struct */
 /* strange that the number for this op is not sequential with previous op */