smb: add SMB2 compression support for ksmbd
Subsystems (2)
Namjae Jeon
maintainercover smb: add SMB2 compression support for ksmbd
This series adds SMB 3.1.1 compression support to ksmbd and moves the existing client LZ77 encoder into fs/smb/common so both cifs and ksmbd can use the same codec.
cifs.ko advertises and decodes chained compression capabilities, including LZ77 and Pattern_V1, but this series does not set SMB2_READFLAG_REQUEST_COMPRESSED or add a compressed transform receive path. Receiving compressed SMB2 transforms remains a TODO for CIFS client developers.
ksmbd negotiates LZ77 and optional chained Pattern_V1 support, advertises SMB2_SHAREFLAG_COMPRESS_DATA, decodes compressed client requests, and compresses eligible READ responses when doing so reduces the wire size.
Namjae Jeon (5):
smb: move LZ77 compression into common code
smb: add common SMB2 compression transform helpers
cifs: negotiate chained SMB2 compression capabilities
ksmbd: negotiate and decode SMB2 compression
ksmbd: compress SMB2 READ responses
fs/smb/client/Makefile | 2 +-
fs/smb/client/cifsglob.h | 2 +
fs/smb/client/compress.c | 12 +-
fs/smb/client/compress.h | 28 +-
fs/smb/client/smb2pdu.c | 44 ++-
fs/smb/common/Makefile | 3 +
fs/smb/common/compress/compress.c | 399 ++++++++++++++++++++++
fs/smb/common/compress/compress.h | 28 ++
fs/smb/{client => common}/compress/lz77.c | 136 +++++++-
fs/smb/{client => common}/compress/lz77.h | 17 +-
fs/smb/common/smb2pdu.h | 11 +-
fs/smb/server/Makefile | 2 +-
fs/smb/server/compress.c | 209 ++++++++++++
fs/smb/server/compress.h | 16 +
fs/smb/server/connection.c | 12 +
fs/smb/server/connection.h | 3 +
fs/smb/server/ksmbd_work.c | 1 +
fs/smb/server/ksmbd_work.h | 4 +
fs/smb/server/server.c | 10 +
fs/smb/server/smb2pdu.c | 118 ++++++-
fs/smb/server/smb_common.c | 5 -
21 files changed, 989 insertions(+), 73 deletions(-)
create mode 100644 fs/smb/common/compress/compress.c
create mode 100644 fs/smb/common/compress/compress.h
rename fs/smb/{client => common}/compress/lz77.c (75%)
rename fs/smb/{client => common}/compress/lz77.h (65%)
create mode 100644 fs/smb/server/compress.c
create mode 100644 fs/smb/server/compress.hSignature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 1/5 smb: move LZ77 compression into common code
Move the LZ77 codec in cifs.ko to smb/common/ so both the SMB client and ksmbd can use it.
---
fs/smb/client/Makefile | 2 +-
fs/smb/client/compress.c | 12 +-
fs/smb/client/compress.h | 28 +----
fs/smb/common/Makefile | 3 +
fs/smb/common/compress/compress.h | 22 ++++
fs/smb/{client => common}/compress/lz77.c | 136 +++++++++++++++++++++-
fs/smb/{client => common}/compress/lz77.h | 17 +--
7 files changed, 176 insertions(+), 44 deletions(-)
create mode 100644 fs/smb/common/compress/compress.h
rename fs/smb/{client => common}/compress/lz77.c (75%)
rename fs/smb/{client => common}/compress/lz77.h (65%)fs/smb/client/Makefile +1 -1
@@ -42,7 +42,7 @@ cifs-$(CONFIG_CIFS_ALLOW_INSECURE_LEGACY) += \ smb1session.o \ smb1transport.o -cifs-$(CONFIG_CIFS_COMPRESSION) += compress.o compress/lz77.o +cifs-$(CONFIG_CIFS_COMPRESSION) += compress.o ifneq ($(CONFIG_CIFS_ALLOW_INSECURE_LEGACY),) #
fs/smb/client/compress.c +8 -4
@@ -22,7 +22,7 @@#include "cifsproto.h" #include "smb2proto.h" -#include "compress/lz77.h" +#include "../common/compress/lz77.h" #include "compress.h" /*
@@ -44,6 +44,11 @@ struct bucket {unsigned int count; }; +static inline size_t pow4 (size_t n) +{ +return n * n * n * n; +} +/* * has_low_entropy() - Compute Shannon entropy of the sampled data. * @bkt: Bytes counts of the sample.
@@ -65,7 +70,6 @@ static bool has_low_entropy(struct bucket *bkt, size_t slen)const size_t threshold =65 , max_entropy =8 *ilog2 (16 );size_t i, p, p2, len, sum =0 ; -#define pow4 (n) (n * n * n * n) len =ilog2 (pow4 (slen));for (i =0 ; i <256 && bkt[i].count >0 ; i++) {
@@ -329,14 +333,14 @@ int smb_compress(struct TCP_Server_Info *server, struct smb_rqst *rq, compress_s goto err_free; } - dlen =lz77_compressed_alloc_size (slen); + dlen =smb_lz77_compressed_alloc_size (slen); dst =kvzalloc (dlen,GFP_KERNEL );if (!dst) { ret = -ENOMEM ; goto err_free; } - ret =lz77_compress (src, slen, dst, &dlen); + ret =smb_lz77_compress (src, slen, dst, &dlen);if (!ret) {struct smb2_compression_hdr hdr = {0 };struct smb_rqst comp_rq = { .rq_nvec =3 , };
fs/smb/client/compress.h +1 -27
@@ -18,6 +18,7 @@#include <linux/uio.h> #include <linux/kernel.h> #include "../common/smb2pdu.h" +#include "../common/compress/compress.h" #include "cifsglob.h" /* sizeof(smb2_compression_hdr) - sizeof(OriginalPayloadSize) */
@@ -34,29 +35,6 @@ int smb_compress(struct TCP_Server_Info *server, struct smb_rqst *rq, compress_send_fn send_fn);bool should_compress (const struct cifs_tcon *tcon,const struct smb_rqst *rq); -/* -* smb_compress_alg_valid() - Validate a compression algorithm. -* @alg: Compression algorithm to check. -* @valid_none: Conditional check whether NONE algorithm should be -* considered valid or not. -* -* If @alg is SMB3_COMPRESS_NONE, this function returns @valid_none. -* -* Note that 'NONE' (0) compressor type is considered invalid in protocol -* negotiation, as it's never requested to/returned from the server. -* -* Return: true if @alg is valid/supported, false otherwise. -*/ -static __always_inline int smb_compress_alg_valid(__le16 alg, bool valid_none) -{ -if (alg ==SMB3_COMPRESS_NONE ) -return valid_none; - -if (alg ==SMB3_COMPRESS_LZ77 || alg ==SMB3_COMPRESS_PATTERN ) -return true; - -return false; -}#else /* !CONFIG_CIFS_COMPRESSION */ static inline int smb_compress (void *unused1,void *unused2,void *unused3) {
@@ -68,9 +46,5 @@ static inline bool should_compress(void *unused1, void *unused2)return false; } -static inline int smb_compress_alg_valid (__le16 unused1,bool unused2) -{ -return -EOPNOTSUPP ; -}#endif /* !CONFIG_CIFS_COMPRESSION */ #endif /* _SMB_COMPRESS_H */
fs/smb/common/Makefile +3 -0
@@ -4,3 +4,6 @@ # obj-$(CONFIG_SMBFS) += cifs_md4.o +obj-$(CONFIG_SMBFS) += smb_compress.o + +smb_compress-y := compress/lz77.o
fs/smb/common/compress/compress.h new file +22 -0
@@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2026 Namjae Jeon <[email protected]> +*/ +#ifndef _COMMON_SMB_COMPRESS_H +#define _COMMON_SMB_COMPRESS_H + +#include "../smb2pdu.h" + +/* +* SMB3_COMPRESS_NONE is valid only in chained payload headers. It is never +* negotiated as a compression algorithm. +*/ +static __always_inline bool smb_compress_alg_valid(__le16 alg, bool valid_none) +{ +if (alg ==SMB3_COMPRESS_NONE ) +return valid_none; + +return alg ==SMB3_COMPRESS_LZ77 || alg ==SMB3_COMPRESS_PATTERN ; +} + +#endif /* _COMMON_SMB_COMPRESS_H */
fs/smb/common/compress/lz77.c renamed from fs/smb/client/compress/lz77.c +131 -5
179 lines not on this page · raw message
fs/smb/common/compress/lz77.h renamed from fs/smb/client/compress/lz77.h +10 -7
@@ -12,7 +12,7 @@#include <linux/kernel.h> /** -* lz77_compressed_alloc_size() - Compute compressed buffer size. +* smb_lz77_compressed_alloc_size() - Compute compressed buffer size. * @size: uncompressed (src) size * * Compute allocation size for the compressed buffer based on uncompressed size.
@@ -26,18 +26,21 @@* Worst case scenario is an all-literal compression, which means: * metadata bytes = 4 + ((@size / 32) * 4) + 4, or, simplified, (@size >> 3) + 8 * -* The worst case scenario rarely happens, but such overprovisioning also allows lz77_compress() -* main loop to run without ever bound checking dst, which is a huge perf improvement, while also -* being safe when compression goes bad. +* The worst case scenario rarely happens, but such overprovisioning also +* allows smb_lz77_compress() main loop to run without ever bound checking dst, +* which is a huge perf improvement, while also being safe when compression goes +* bad. * * Return: required (*) allocation size for compressed buffer. * -* (*) checked once in the beginning of lz77_compress() +* (*) checked once in the beginning of smb_lz77_compress() */ -static __always_inline u32 lz77_compressed_alloc_size(const u32 size) +static __always_inline u32 smb_lz77_compressed_alloc_size(const u32 size) {return size + (size >>3 ) +8 ; } -int lz77_compress (const void *src,const u32 slen,void *dst,u32 *dlen); +int smb_lz77_compress (const void *src,const u32 slen,void *dst,u32 *dlen); +int smb_lz77_decompress (const void *src,const u32 slen,void *dst, +const u32 dlen);#endif /* _SMB_COMPRESS_LZ77_H */
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 2/5 smb: add common SMB2 compression transform helpers
In reply to Namjae JeonImplement common validation, compression and decompression for SMB2 compression transforms.
Support unchained LZ77 and chained NONE, LZ77 and Pattern_V1 payloads.
--- fs/smb/common/Makefile | 2 +- fs/smb/common/compress/compress.c | 399 ++++++++++++++++++++++++++++++ fs/smb/common/compress/compress.h | 6 + fs/smb/common/smb2pdu.h | 11 +- 4 files changed, 410 insertions(+), 8 deletions(-) create mode 100644 fs/smb/common/compress/compress.c
fs/smb/common/Makefile +1 -1
@@ -6,4 +6,4 @@ obj-$(CONFIG_SMBFS) += cifs_md4.o obj-$(CONFIG_SMBFS) += smb_compress.o -smb_compress-y := compress/lz77.o +smb_compress-y := compress/compress.o compress/lz77.o
fs/smb/common/compress/compress.c new file +399 -0
399 lines not on this page · raw message
fs/smb/common/compress/compress.h +6 -0
@@ -19,4 +19,10 @@ static __always_inline bool smb_compress_alg_valid(__le16 alg, bool valid_none) return alg == SMB3_COMPRESS_LZ77 || alg == SMB3_COMPRESS_PATTERN; } +int smb_compression_decompress (__le16 alg,bool allow_chained, +const void *src,u32 slen,void *dst,u32 dlen); +int smb_compression_compress_chained (__le16 alg,bool allow_pattern, +const void *src,u32 slen, +void *dst,u32 *dlen); +#endif /* _COMMON_SMB_COMPRESS_H */
fs/smb/common/smb2pdu.h +4 -7
@@ -218,10 +218,9 @@ struct smb2_transform_hdr {* These are simplified versions from the spec, as we don't need a fully fledged * form of both unchained and chained structs. * -* Moreover, even in chained compressed payloads, the initial compression header -* has the form of the unchained one -- i.e. it never has the -* OriginalPayloadSize field and ::Offset field always represent an offset -* (instead of a length, as it is in the chained header). +* For chained payloads, only the first 8 bytes belong to the transform header. +* CompressionAlgorithm, Flags and Offset below overlay the first chained +* payload header, where Offset represents Length. * * See MS-SMB2 2.2.42 for more details. */
@@ -524,9 +523,7 @@ struct smb2_compression_capabilities_context {__le16 CompressionAlgorithmCount;__le16 Padding;__le32 Flags; -__le16 CompressionAlgorithms[3 ]; -__u16 Pad;/* Some servers require pad to DataLen multiple of 8 */ -/* Check if pad needed */ +__le16 CompressionAlgorithms[4 ]; } __packed;/*
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 3/5 cifs: negotiate chained SMB2 compression capabilities
In reply to Namjae JeonAdvertise LZ77 and Pattern_V1 with chained transform support in the SMB 3.1.1 compression negotiate context. Validate the server's returned algorithm list and flags, then retain the negotiated capabilities for a future compressed transform receive implementation.
This patch only negotiates capabilities. It does not request compressed READ responses or add a compressed transform receive path.
--- fs/smb/client/cifsglob.h | 2 ++ fs/smb/client/smb2pdu.c | 44 ++++++++++++++++++++++++++++++++-------- 2 files changed, 37 insertions(+), 9 deletions(-)
fs/smb/client/cifsglob.h +2 -0
@@ -789,6 +789,8 @@ struct TCP_Server_Info {struct {bool requested;/* "compress" mount option set*/ bool enabled;/* actually negotiated with server */ +bool chained;/* chained transforms were negotiated */ +bool pattern;/* Pattern_V1 chained payloads were negotiated */ __le16 alg;/* preferred alg negotiated with server */ } compression;__u16 signing_algorithm;
fs/smb/client/smb2pdu.c +35 -9
74 lines not on this page · raw message
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 4/5 ksmbd: negotiate and decode SMB2 compression
In reply to Namjae JeonParse the SMB 3.1.1 compression capabilities context and negotiate LZ77 with optional chained Pattern_V1 support.
Advertise compression on tree connections and decode compressed requests before normal SMB dispatch.
--- fs/smb/server/Makefile | 2 +- fs/smb/server/compress.c | 77 ++++++++++++++++++++++++++ fs/smb/server/compress.h | 15 +++++ fs/smb/server/connection.c | 12 ++++ fs/smb/server/connection.h | 3 + fs/smb/server/smb2pdu.c | 109 ++++++++++++++++++++++++++++++++++--- fs/smb/server/smb_common.c | 5 -- 7 files changed, 210 insertions(+), 13 deletions(-) create mode 100644 fs/smb/server/compress.c create mode 100644 fs/smb/server/compress.h
fs/smb/server/Makefile +1 -1
@@ -10,7 +10,7 @@ ksmbd-y := unicode.o auth.o vfs.o vfs_cache.o server.o ndr.o \ mgmt/tree_connect.o mgmt/user_session.o smb_common.o \ transport_tcp.o transport_ipc.o smbacl.o smb2pdu.o \ smb2ops.o smb2misc.o ksmbd_spnego_negtokeninit.asn1.o \ - ksmbd_spnego_negtokentarg.asn1.o asn1.o + ksmbd_spnego_negtokentarg.asn1.o asn1.o compress.o $(obj)/asn1.o: $(obj)/ksmbd_spnego_negtokeninit.asn1.h $(obj)/ksmbd_spnego_negtokentarg.asn1.h
fs/smb/server/compress.c new file +77 -0
77 lines not on this page · raw message
fs/smb/server/compress.h new file +15 -0
@@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* +* SMB2 compression support for ksmbd. +* +* Copyright (C) 2026 Namjae Jeon <[email protected]> +*/ +#ifndef __KSMBD_COMPRESS_H__ +#define __KSMBD_COMPRESS_H__ + +#include "connection.h" +#include "../common/compress/compress.h" + +int ksmbd_decompress_request (struct ksmbd_conn *conn); + +#endif /* __KSMBD_COMPRESS_H__ */
fs/smb/server/connection.c +12 -0
@@ -12,6 +12,7 @@#include "smb_common.h" #include "mgmt/ksmbd_ida.h" #include "connection.h" +#include "compress.h" #include "transport_tcp.h" #include "transport_rdma.h" #include "misc.h"
@@ -531,6 +532,17 @@ int ksmbd_conn_handler_loop(void *p)continue ; } +if (((struct smb2_hdr *)smb_get_msg (conn->request_buf))->ProtocolId == +SMB2_COMPRESSION_TRANSFORM_ID ) { +/* +* Convert the transform into a normal RFC1002-framed SMB2 +* request before protocol validation and work allocation. +*/ +if (ksmbd_decompress_request (conn)) +break ; + pdu_size =get_rfc1002_len (conn->request_buf); + } +if (!ksmbd_smb_request (conn))break ;
fs/smb/server/connection.h +3 -0
@@ -115,6 +115,9 @@ struct ksmbd_conn {__le16 cipher_type;__le16 compress_algorithm; +/* Negotiated SMB 3.1.1 compression capabilities. */ +bool compress_chained; +bool compress_pattern;bool posix_ext_supported;bool signing_negotiated;__le16 signing_algorithm;
fs/smb/server/smb2pdu.c +102 -7
155 lines not on this page · raw message
fs/smb/server/smb_common.c +0 -5
@@ -185,11 +185,6 @@ bool ksmbd_smb_request(struct ksmbd_conn *conn)return false; proto = (__le32 *)smb_get_msg (conn->request_buf); -if (*proto ==SMB2_COMPRESSION_TRANSFORM_ID ) { -pr_err_ratelimited ("smb2 compression not support yet" ); -return false; - } -if (*proto !=SMB1_PROTO_NUMBER && *proto !=SMB2_PROTO_NUMBER && *proto !=SMB2_TRANSFORM_PROTO_NUM )
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 5/5 ksmbd: compress SMB2 READ responses
In reply to Namjae JeonHandle SMB2_READFLAG_REQUEST_COMPRESSED for non-RDMA reads.
Flatten the response iov, emit chained or unchained LZ77 transforms when compression is beneficial, and retain the generated buffer until the work item is released.
--- fs/smb/server/compress.c | 132 +++++++++++++++++++++++++++++++++++++ fs/smb/server/compress.h | 1 + fs/smb/server/ksmbd_work.c | 1 + fs/smb/server/ksmbd_work.h | 4 ++ fs/smb/server/server.c | 10 +++ fs/smb/server/smb2pdu.c | 9 +++ 6 files changed, 157 insertions(+)
fs/smb/server/compress.c +132 -0
@@ -10,6 +10,9 @@#include "compress.h" #include "smb_common.h" +#include "../common/compress/lz77.h" + +#define SMB_COMPRESS_MIN_LEN PAGE_SIZE/** * ksmbd_decompress_request() - replace a compressed request with its SMB2 PDU
@@ -75,3 +78,132 @@ int ksmbd_decompress_request(struct ksmbd_conn *conn) conn->request_buf = out;return 0 ; } + +/** +* ksmbd_compress_response() - compress an eligible ksmbd response +* @work: request work item containing the response iov +* +* Compression transforms describe one contiguous SMB2 message, while ksmbd +* builds responses from multiple iov entries. Flatten the response first, +* produce the negotiated transform, and replace the response iov only when the +* result is smaller than the original message. +* +* Encrypted and compound responses are intentionally left unchanged. The +* caller may still continue sending the original response when this function +* returns zero. +* +* Return: 1 if the response was replaced, 0 if compression was skipped, or a +* negative errno on failure. +*/ +int ksmbd_compress_response (struct ksmbd_work *work) +{ +struct smb2_compression_hdr *chdr; +struct smb2_hdr *req_hdr; +u32 src_len, dst_len, compressed_pdu_len, max_dst_len; +u8 *src =NULL , *out =NULL , *p; +int i, rc; + +if (!work->compress_response || work->encrypted || + work->conn->compress_algorithm !=SMB3_COMPRESS_LZ77 ) +return 0 ; + + req_hdr =smb_get_msg (work->request_buf); +if (req_hdr->NextCommand || work->next_smb2_rcv_hdr_off || + work->next_smb2_rsp_hdr_off) +return 0 ; + + src_len =get_rfc1002_len (work->iov[0 ].iov_base); +if (src_len <SMB_COMPRESS_MIN_LEN ) +return 0 ; + + src =kvmalloc (src_len,KSMBD_DEFAULT_GFP ); +if (!src) +return -ENOMEM ; + + p = src; +/* iov[0] contains only the RFC1002 length; the SMB2 PDU starts at iov[1]. */ +for (i =1 ; i < work->iov_cnt; i++) { +if (work->iov[i].iov_len > src + src_len - p) { + rc = -EINVAL ; + goto out; + } +memcpy (p, work->iov[i].iov_base, work->iov[i].iov_len); + p += work->iov[i].iov_len; + } +if (p != src + src_len) { + rc = -EINVAL ; + goto out; + } + + max_dst_len =smb_lz77_compressed_alloc_size (src_len) + +sizeof (struct smb2_compression_hdr ) + +3 *sizeof (struct smb2_compression_payload_hdr ) + +2 *sizeof (struct smb2_compression_pattern_v1 ); + out =kvzalloc (sizeof (__be32) + max_dst_len, +KSMBD_DEFAULT_GFP ); +if (!out) { + rc = -ENOMEM ; + goto out; + } + +if (work->conn->compress_chained) { + dst_len = max_dst_len; + rc =smb_compression_compress_chained (SMB3_COMPRESS_LZ77 , + work->conn->compress_pattern, + src, src_len, + out +sizeof (__be32), + &dst_len); +if (rc == -EMSGSIZE || dst_len >= src_len) { + rc =0 ; + goto out; + } +if (rc) + goto out; + compressed_pdu_len = dst_len; + }else { +/* +* Peers which did not negotiate chained compression still use +* the original 16-byte unchained transform format. +*/ + dst_len =smb_lz77_compressed_alloc_size (src_len); + rc =smb_lz77_compress (src, src_len, + out +sizeof (__be32) +sizeof (*chdr), + &dst_len); +if (rc == -EMSGSIZE || + dst_len +sizeof (*chdr) >= src_len) { + rc =0 ; + goto out; + } +if (rc) + goto out; + + compressed_pdu_len =sizeof (*chdr) + dst_len; + chdr = (struct smb2_compression_hdr *)(out +sizeof (__be32)); + chdr->ProtocolId =SMB2_COMPRESSION_TRANSFORM_ID ; + chdr->OriginalCompressedSegmentSize =cpu_to_le32 (src_len); + chdr->CompressionAlgorithm =SMB3_COMPRESS_LZ77 ; + chdr->Flags =cpu_to_le16 (SMB2_COMPRESSION_FLAG_NONE ); + chdr->Offset =0 ; + } + + *(__be32 *)out =cpu_to_be32 (compressed_pdu_len); + +/* +* Keep the transform in work->compress_buf until send completion. +* Existing response iovs can then be replaced without changing their +* individual ownership rules. +*/ + work->compress_buf = out; + work->iov[0 ].iov_base = out; + work->iov[0 ].iov_len =sizeof (__be32); + work->iov[1 ].iov_base = out +sizeof (__be32); + work->iov[1 ].iov_len = compressed_pdu_len; + work->iov_cnt =2 ; + work->iov_idx =1 ; + out =NULL ; + rc =1 ; +out: +kvfree (out); +kvfree (src); +return rc; +}
fs/smb/server/compress.h +1 -0
@@ -11,5 +11,6 @@#include "../common/compress/compress.h" int ksmbd_decompress_request (struct ksmbd_conn *conn); +int ksmbd_compress_response (struct ksmbd_work *work);#endif /* __KSMBD_COMPRESS_H__ */
fs/smb/server/ksmbd_work.c +1 -0
@@ -53,6 +53,7 @@ void ksmbd_free_work_struct(struct ksmbd_work *work) }kfree (work->tr_buf); +kvfree (work->compress_buf);kvfree (work->request_buf);kfree (work->iov);
fs/smb/server/ksmbd_work.h +4 -0
@@ -67,12 +67,16 @@ struct ksmbd_work {unsigned int response_sz;void *tr_buf; +/* Contiguous SMB2 compression transform owned by this work item. */ +void *compress_buf;unsigned char state;/* No response for cancelled request */ bool send_no_response:1;/* Request is encrypted */ bool encrypted:1; +/* READ response should be wrapped in a compression transform. */ + bool compress_response:1;/* Is this SYNC or ASYNC ksmbd_work */ bool asynchronous:1; bool need_invalidate_rkey:1;
fs/smb/server/server.c +10 -0
@@ -22,6 +22,7 @@#include "crypto_ctx.h" #include "auth.h" #include "stats.h" +#include "compress.h" int ksmbd_debug_types;
@@ -244,6 +245,15 @@ static void __handle_ksmbd_work(struct ksmbd_work *work,if (work->tcon)ksmbd_tree_connect_put (work->tcon);smb3_preauth_hash_rsp (work); +/* +* Preauthentication hashes cover the original SMB2 response. Apply the +* transport compression wrapper only after updating the hash. +*/ +if (work->compress_response) { + rc =ksmbd_compress_response (work); +if (rc <0 ) +ksmbd_debug (CONN ,"Failed to compress response: %d\n" , rc); + }if (work->sess && work->sess->enc && work->encrypted && conn->ops->encrypt_resp) { rc = conn->ops->encrypt_resp (work);
fs/smb/server/smb2pdu.c +9 -0
@@ -7097,6 +7097,15 @@ int smb2_read(struct ksmbd_work *work)kvfree (aux_payload_buf); goto out; } +/* +* RDMA responses are transferred through channel buffers and encrypted +* responses use the encryption transform, so only normal SMB transport +* responses are candidates for compression. +*/ +if (!is_rdma_channel && nbytes && + (req->Flags &SMB2_READFLAG_REQUEST_COMPRESSED ) && + conn->compress_algorithm !=SMB3_COMPRESS_NONE ) + work->compress_response = true;ksmbd_fd_put (work, fp);return 0 ;
Signature · 1 line
2.25.1