smb: client: negotiate compression algorithms

Change "compress=" mount option to a boolean flag, that, if set,
will enable negotiating compression algorithms with the server.

Do not de/compress anything for now.

Signed-off-by: Enzo Matsumiya <ematsumiya@suse.de>
Signed-off-by: Steve French <stfrench@microsoft.com>

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index 23d2622b969f09237eff1d122565bc81039aebf2..226d4835c92db8ba3f1f0540a16643d0b8ac3fd0 100644 (file)
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -278,6 +278,24 @@ static int cifs_debug_files_proc_show(struct seq_file *m, void *v)
        return 0;
 }
 
+static __always_inline const char *compression_alg_str(__le16 alg)
+{
+       switch (alg) {
+       case SMB3_COMPRESS_NONE:
+               return "NONE";
+       case SMB3_COMPRESS_LZNT1:
+               return "LZNT1";
+       case SMB3_COMPRESS_LZ77:
+               return "LZ77";
+       case SMB3_COMPRESS_LZ77_HUFF:
+               return "LZ77-Huffman";
+       case SMB3_COMPRESS_PATTERN:
+               return "Pattern_V1";
+       default:
+               return "invalid";
+       }
+}
+
 static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 {
        struct mid_q_entry *mid_entry;
@@ -423,12 +441,6 @@ skip_rdma:
                        server->echo_credits,
                        server->oplock_credits,
                        server->dialect);
-               if (server->compress_algorithm == SMB3_COMPRESS_LZNT1)
-                       seq_printf(m, " COMPRESS_LZNT1");
-               else if (server->compress_algorithm == SMB3_COMPRESS_LZ77)
-                       seq_printf(m, " COMPRESS_LZ77");
-               else if (server->compress_algorithm == SMB3_COMPRESS_LZ77_HUFF)
-                       seq_printf(m, " COMPRESS_LZ77_HUFF");
                if (server->sign)
                        seq_printf(m, " signed");
                if (server->posix_ext_supported)
@@ -460,6 +472,14 @@ skip_rdma:
                                   server->leaf_fullpath);
                }
 
+               seq_puts(m, "\nCompression: ");
+               if (!server->compression.requested)
+                       seq_puts(m, "disabled on mount");
+               else if (server->compression.enabled)
+                       seq_printf(m, "enabled (%s)", compression_alg_str(server->compression.alg));
+               else
+                       seq_puts(m, "disabled (not supported by this server)");
+
                seq_printf(m, "\n\n\tSessions: ");
                i = 0;
                list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

diff --git a/fs/smb/client/cifsglob.h b/fs/smb/client/cifsglob.h
index a0506a45eae39f9c42429b545e03d0c19ca6e65e..8be62ed053a25e4c56018641553d10314d0f1563 100644 (file)
--- a/fs/smb/client/cifsglob.h
+++ b/fs/smb/client/cifsglob.h
@@ -769,7 +769,11 @@ struct TCP_Server_Info {
        unsigned int    max_write;
        unsigned int    min_offload;
        unsigned int    retrans;
-       __le16  compress_algorithm;
+       struct {
+               bool requested; /* "compress" mount option set*/
+               bool enabled; /* actually negotiated with server */
+               __le16 alg; /* preferred alg negotiated with server */
+       } compression;
        __u16   signing_algorithm;
        __le16  cipher_type;
         /* save initital negprot hash */

diff --git a/fs/smb/client/connect.c b/fs/smb/client/connect.c
index 5d82921d63d172f3968fdde22954258d1bc58580..86ae578904a269be0fd17c7d110dc1548ef2f203 100644 (file)
--- a/fs/smb/client/connect.c
+++ b/fs/smb/client/connect.c
@@ -1736,7 +1736,7 @@ cifs_get_tcp_session(struct smb3_fs_context *ctx,
        tcp_ses->channel_sequence_num = 0; /* only tracked for primary channel */
        tcp_ses->reconnect_instance = 1;
        tcp_ses->lstrp = jiffies;
-       tcp_ses->compress_algorithm = cpu_to_le16(ctx->compression);
+       tcp_ses->compression.requested = ctx->compress;
        spin_lock_init(&tcp_ses->req_lock);
        spin_lock_init(&tcp_ses->srv_lock);
        spin_lock_init(&tcp_ses->mid_lock);

diff --git a/fs/smb/client/fs_context.c b/fs/smb/client/fs_context.c
index 4b767efa47f1fa3af0f5a7744a64cf41b319db99..bdcbe6ff2739ab4539c128e7945258a8914a477a 100644 (file)
--- a/fs/smb/client/fs_context.c
+++ b/fs/smb/client/fs_context.c
@@ -963,7 +963,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
 
        switch (opt) {
        case Opt_compress:
-               ctx->compression = UNKNOWN_TYPE;
+               ctx->compress = true;
                cifs_dbg(VFS,
                        "SMB3 compression support is experimental\n");
                break;

diff --git a/fs/smb/client/fs_context.h b/fs/smb/client/fs_context.h
index 1f09754977e7ccdfaa029a078de7d6cf27d22b16..7863f2248c4df8f1e892c2b8589813cca1f1bdd4 100644 (file)
--- a/fs/smb/client/fs_context.h
+++ b/fs/smb/client/fs_context.h
@@ -273,7 +273,7 @@ struct smb3_fs_context {
        unsigned int max_credits; /* smb3 max_credits 10 < credits < 60000 */
        unsigned int max_channels;
        unsigned int max_cached_dirs;
-       __u16 compression; /* compression algorithm 0xFFFF default 0=disabled */
+       bool compress; /* enable SMB2 messages (READ/WRITE) de/compression */
        bool rootfs:1; /* if it's a SMB root file system */
        bool witness:1; /* use witness protocol */
        char *leaf_fullpath;

diff --git a/fs/smb/client/smb2pdu.c b/fs/smb/client/smb2pdu.c
index 7d0157e0061e070f23d8d72d487c887cf4b9bb98..e5e6b14f8cae37bb6ac470c457e34fcf437458a1 100644 (file)
--- a/fs/smb/client/smb2pdu.c
+++ b/fs/smb/client/smb2pdu.c
@@ -731,7 +731,7 @@ assemble_neg_contexts(struct smb2_negotiate_req *req,
        pneg_ctxt += sizeof(struct smb2_posix_neg_context);
        neg_context_count++;
 
-       if (server->compress_algorithm) {
+       if (server->compression.requested) {
                build_compression_ctxt((struct smb2_compression_capabilities_context *)
                                pneg_ctxt);
                ctxt_len = ALIGN(sizeof(struct smb2_compression_capabilities_context), 8);
@@ -779,6 +779,9 @@ static void decode_compress_ctx(struct TCP_Server_Info *server,
                         struct smb2_compression_capabilities_context *ctxt)
 {
        unsigned int len = le16_to_cpu(ctxt->DataLength);
+       __le16 alg;
+
+       server->compression.enabled = false;
 
        /*
         * Caller checked that DataLength remains within SMB boundary. We still
@@ -789,15 +792,22 @@ static void decode_compress_ctx(struct TCP_Server_Info *server,
                pr_warn_once("server sent bad compression cntxt\n");
                return;
        }
+
        if (le16_to_cpu(ctxt->CompressionAlgorithmCount) != 1) {
-               pr_warn_once("Invalid SMB3 compress algorithm count\n");
+               pr_warn_once("invalid SMB3 compress algorithm count\n");
                return;
        }
-       if (le16_to_cpu(ctxt->CompressionAlgorithms[0]) > 3) {
-               pr_warn_once("unknown compression algorithm\n");
+
+       alg = ctxt->CompressionAlgorithms[0];
+
+       /* 'NONE' (0) compressor type is never negotiated */
+       if (alg == 0 || le16_to_cpu(alg) > 3) {
+               pr_warn_once("invalid compression algorithm '%u'\n", alg);
                return;
        }
-       server->compress_algorithm = ctxt->CompressionAlgorithms[0];
+
+       server->compression.alg = alg;
+       server->compression.enabled = true;
 }
 
 static int decode_encrypt_ctx(struct TCP_Server_Info *server,