perf/x86/intel: Rename DMR offcore_rsp attribute to offmodule_rspgrafted

DMR introduces Offmodule Response events in place of the legacy
Offcore Response events, but it still exposes the inherited
offcore_rsp PMU attribute for programming the corresponding MSR data.

Rename the DMR PMU attribute to offmodule_rsp so the sysfs interface
matches the underlying event name and avoids user & tooling confusion.

Signed-off-by: Dapeng Mi <dapeng1.mi@linux.intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Link: https://patch.msgid.link/20260917015234.981153-12-dapeng1.mi@linux.intel.com

14 files changed, 5827 insertions, 0 deletions

diff --git a/fs/smb/common/Makefile b/fs/smb/common/Makefile
new file mode 100644
index 000000000..f2c6e09d4
--- /dev/null
+++ b/fs/smb/common/Makefile
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-2.0-only
+#
+# Makefile for Linux filesystem routines that are shared by client and server.
+#
+
+obj-$(CONFIG_SMBFS) += cifs_md4.o
+obj-$(CONFIG_SMBFS) += smb_compress.o
+
+smb_compress-y := compress/compress.o compress/lz77.o
diff --git a/fs/smb/common/cifs_md4.c b/fs/smb/common/cifs_md4.c
new file mode 100644
index 000000000..7ee7f4dad
--- /dev/null
+++ b/fs/smb/common/cifs_md4.c
@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Cryptographic API.
+ *
+ * MD4 Message Digest Algorithm (RFC1320).
+ *
+ * Implementation derived from Andrew Tridgell and Steve French's
+ * CIFS MD4 implementation, and the cryptoapi implementation
+ * originally based on the public domain implementation written
+ * by Colin Plumb in 1993.
+ *
+ * Copyright (c) Andrew Tridgell 1997-1998.
+ * Modified by Steve French (sfrench@us.ibm.com) 2002
+ * Copyright (c) Cryptoapi developers.
+ * Copyright (c) 2002 David S. Miller (davem@redhat.com)
+ * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
+ *
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <asm/byteorder.h>
+#include "md4.h"
+
+MODULE_DESCRIPTION("MD4 Message Digest Algorithm (RFC1320)");
+MODULE_LICENSE("GPL");
+
+static inline u32 lshift(u32 x, unsigned int s)
+{
+	x &= 0xFFFFFFFF;
+	return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
+}
+
+static inline u32 F(u32 x, u32 y, u32 z)
+{
+	return (x & y) | ((~x) & z);
+}
+
+static inline u32 G(u32 x, u32 y, u32 z)
+{
+	return (x & y) | (x & z) | (y & z);
+}
+
+static inline u32 H(u32 x, u32 y, u32 z)
+{
+	return x ^ y ^ z;
+}
+
+#define ROUND1(a,b,c,d,k,s) (a = lshift(a + F(b,c,d) + k, s))
+#define ROUND2(a,b,c,d,k,s) (a = lshift(a + G(b,c,d) + k + (u32)0x5A827999,s))
+#define ROUND3(a,b,c,d,k,s) (a = lshift(a + H(b,c,d) + k + (u32)0x6ED9EBA1,s))
+
+static void md4_transform(u32 *hash, u32 const *in)
+{
+	u32 a, b, c, d;
+
+	a = hash[0];
+	b = hash[1];
+	c = hash[2];
+	d = hash[3];
+
+	ROUND1(a, b, c, d, in[0], 3);
+	ROUND1(d, a, b, c, in[1], 7);
+	ROUND1(c, d, a, b, in[2], 11);
+	ROUND1(b, c, d, a, in[3], 19);
+	ROUND1(a, b, c, d, in[4], 3);
+	ROUND1(d, a, b, c, in[5], 7);
+	ROUND1(c, d, a, b, in[6], 11);
+	ROUND1(b, c, d, a, in[7], 19);
+	ROUND1(a, b, c, d, in[8], 3);
+	ROUND1(d, a, b, c, in[9], 7);
+	ROUND1(c, d, a, b, in[10], 11);
+	ROUND1(b, c, d, a, in[11], 19);
+	ROUND1(a, b, c, d, in[12], 3);
+	ROUND1(d, a, b, c, in[13], 7);
+	ROUND1(c, d, a, b, in[14], 11);
+	ROUND1(b, c, d, a, in[15], 19);
+
+	ROUND2(a, b, c, d, in[0], 3);
+	ROUND2(d, a, b, c, in[4], 5);
+	ROUND2(c, d, a, b, in[8], 9);
+	ROUND2(b, c, d, a, in[12], 13);
+	ROUND2(a, b, c, d, in[1], 3);
+	ROUND2(d, a, b, c, in[5], 5);
+	ROUND2(c, d, a, b, in[9], 9);
+	ROUND2(b, c, d, a, in[13], 13);
+	ROUND2(a, b, c, d, in[2], 3);
+	ROUND2(d, a, b, c, in[6], 5);
+	ROUND2(c, d, a, b, in[10], 9);
+	ROUND2(b, c, d, a, in[14], 13);
+	ROUND2(a, b, c, d, in[3], 3);
+	ROUND2(d, a, b, c, in[7], 5);
+	ROUND2(c, d, a, b, in[11], 9);
+	ROUND2(b, c, d, a, in[15], 13);
+
+	ROUND3(a, b, c, d, in[0], 3);
+	ROUND3(d, a, b, c, in[8], 9);
+	ROUND3(c, d, a, b, in[4], 11);
+	ROUND3(b, c, d, a, in[12], 15);
+	ROUND3(a, b, c, d, in[2], 3);
+	ROUND3(d, a, b, c, in[10], 9);
+	ROUND3(c, d, a, b, in[6], 11);
+	ROUND3(b, c, d, a, in[14], 15);
+	ROUND3(a, b, c, d, in[1], 3);
+	ROUND3(d, a, b, c, in[9], 9);
+	ROUND3(c, d, a, b, in[5], 11);
+	ROUND3(b, c, d, a, in[13], 15);
+	ROUND3(a, b, c, d, in[3], 3);
+	ROUND3(d, a, b, c, in[11], 9);
+	ROUND3(c, d, a, b, in[7], 11);
+	ROUND3(b, c, d, a, in[15], 15);
+
+	hash[0] += a;
+	hash[1] += b;
+	hash[2] += c;
+	hash[3] += d;
+}
+
+static inline void md4_transform_helper(struct md4_ctx *ctx)
+{
+	le32_to_cpu_array(ctx->block, ARRAY_SIZE(ctx->block));
+	md4_transform(ctx->hash, ctx->block);
+}
+
+int cifs_md4_init(struct md4_ctx *mctx)
+{
+	memset(mctx, 0, sizeof(struct md4_ctx));
+	mctx->hash[0] = 0x67452301;
+	mctx->hash[1] = 0xefcdab89;
+	mctx->hash[2] = 0x98badcfe;
+	mctx->hash[3] = 0x10325476;
+	mctx->byte_count = 0;
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(cifs_md4_init);
+
+int cifs_md4_update(struct md4_ctx *mctx, const u8 *data, unsigned int len)
+{
+	const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
+
+	mctx->byte_count += len;
+
+	if (avail > len) {
+		memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
+		       data, len);
+		return 0;
+	}
+
+	memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
+	       data, avail);
+
+	md4_transform_helper(mctx);
+	data += avail;
+	len -= avail;
+
+	while (len >= sizeof(mctx->block)) {
+		memcpy(mctx->block, data, sizeof(mctx->block));
+		md4_transform_helper(mctx);
+		data += sizeof(mctx->block);
+		len -= sizeof(mctx->block);
+	}
+
+	memcpy(mctx->block, data, len);
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(cifs_md4_update);
+
+int cifs_md4_final(struct md4_ctx *mctx, u8 *out)
+{
+	const unsigned int offset = mctx->byte_count & 0x3f;
+	char *p = (char *)mctx->block + offset;
+	int padding = 56 - (offset + 1);
+
+	*p++ = 0x80;
+	if (padding < 0) {
+		memset(p, 0x00, padding + sizeof(u64));
+		md4_transform_helper(mctx);
+		p = (char *)mctx->block;
+		padding = 56;
+	}
+
+	memset(p, 0, padding);
+	mctx->block[14] = mctx->byte_count << 3;
+	mctx->block[15] = mctx->byte_count >> 29;
+	le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
+			  sizeof(u64)) / sizeof(u32));
+	md4_transform(mctx->hash, mctx->block);
+	cpu_to_le32_array(mctx->hash, ARRAY_SIZE(mctx->hash));
+	memcpy(out, mctx->hash, sizeof(mctx->hash));
+	memset(mctx, 0, sizeof(*mctx));
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(cifs_md4_final);
diff --git a/fs/smb/common/compress/compress.c b/fs/smb/common/compress/compress.c
new file mode 100644
index 000000000..a4123c8f1
--- /dev/null
+++ b/fs/smb/common/compress/compress.c
@@ -0,0 +1,404 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * SMB2 compression transform helpers.
+ *
+ * Copyright (C) 2026 Namjae Jeon <linkinjeon@kernel.org>
+ */
+#include <linux/module.h>
+#include <linux/overflow.h>
+#include <linux/string.h>
+#include <linux/unaligned.h>
+
+#include "compress.h"
+#include "lz77.h"
+
+#define SMB2_COMPRESSION_CHAINED_HDR_LEN \
+	offsetof(struct smb2_compression_hdr, CompressionAlgorithm)
+#define SMB2_COMPRESSION_PAYLOAD_BASE_LEN \
+	(sizeof(struct smb2_compression_payload_hdr) - sizeof(__le32))
+
+/*
+ * A NONE payload carries bytes verbatim. Keep both cursors and remaining
+ * lengths together so every chained payload handler applies identical bounds
+ * accounting.
+ */
+static int smb_decompress_none(const u8 **src, u32 *slen, u8 **dst, u32 *dlen,
+			       u32 len)
+{
+	if (len > *slen || len > *dlen)
+		return -EINVAL;
+
+	memcpy(*dst, *src, len);
+	*src += len;
+	*slen -= len;
+	*dst += len;
+	*dlen -= len;
+	return 0;
+}
+
+/*
+ * Pattern_V1 represents a run of one byte. Its wire payload is always the
+ * fixed-size smb2_compression_pattern_v1 structure.
+ */
+static int smb_decompress_pattern(const u8 **src, u32 *slen, u8 **dst,
+				  u32 *dlen, u32 len)
+{
+	const struct smb2_compression_pattern_v1 *pattern;
+	u32 repetitions;
+
+	if (len != sizeof(*pattern) || len > *slen)
+		return -EINVAL;
+
+	pattern = (const struct smb2_compression_pattern_v1 *)*src;
+	repetitions = le32_to_cpu(pattern->Repetitions);
+	if (repetitions > *dlen)
+		return -EINVAL;
+
+	memset(*dst, pattern->Pattern, repetitions);
+	*src += len;
+	*slen -= len;
+	*dst += repetitions;
+	*dlen -= repetitions;
+	return 0;
+}
+
+/*
+ * LZ77 payload Length includes the four-byte OriginalPayloadSize field.
+ * Consume that field before passing the compressed stream to the raw codec.
+ */
+static int smb_decompress_lz77_payload(const u8 **src, u32 *slen, u8 **dst,
+				       u32 *dlen, u32 len)
+{
+	u32 orig_size;
+	int rc;
+
+	if (len < sizeof(__le32) || len > *slen)
+		return -EINVAL;
+
+	orig_size = get_unaligned_le32(*src);
+	if (orig_size > *dlen)
+		return -EINVAL;
+
+	*src += sizeof(__le32);
+	*slen -= sizeof(__le32);
+	len -= sizeof(__le32);
+
+	rc = smb_lz77_decompress(*src, len, *dst, orig_size);
+	if (rc)
+		return rc;
+
+	*src += len;
+	*slen -= len;
+	*dst += orig_size;
+	*dlen -= orig_size;
+	return 0;
+}
+
+static int smb_decompress_chained(__le16 alg, bool allow_chained,
+				  bool allow_pattern,
+				  const struct smb2_compression_hdr *hdr,
+				  u32 slen, void *dst, u32 dlen)
+{
+	const struct smb2_compression_payload_hdr *payload;
+	const u8 *src = (const u8 *)hdr + SMB2_COMPRESSION_CHAINED_HDR_LEN;
+	u32 orig_size = le32_to_cpu(hdr->OriginalCompressedSegmentSize);
+	u32 remaining = slen - SMB2_COMPRESSION_CHAINED_HDR_LEN;
+	u8 *out = dst;
+	u32 out_remaining = dlen;
+	bool first = true;
+	int rc;
+
+	if (!allow_chained || orig_size != dlen)
+		return -EINVAL;
+
+	/*
+	 * The chained transform has an eight-byte top-level header. The next
+	 * bytes are a sequence of payload headers whose Length fields account
+	 * for payload data, including OriginalPayloadSize where applicable.
+	 */
+	while (remaining) {
+		__le16 payload_alg;
+		__le16 flags;
+		u32 len;
+
+		if (remaining < SMB2_COMPRESSION_PAYLOAD_BASE_LEN)
+			return -EINVAL;
+
+		payload = (const struct smb2_compression_payload_hdr *)src;
+		payload_alg = payload->CompressionAlgorithm;
+		flags = payload->Flags;
+		len = le32_to_cpu(payload->Length);
+
+		/*
+		 * CHAINED marks only the first payload. Requiring NONE on every
+		 * later payload rejects ambiguous or independently chained data.
+		 */
+		if ((first && flags != cpu_to_le16(SMB2_COMPRESSION_FLAG_CHAINED)) ||
+		    (!first && flags != cpu_to_le16(SMB2_COMPRESSION_FLAG_NONE)))
+			return -EINVAL;
+
+		src += SMB2_COMPRESSION_PAYLOAD_BASE_LEN;
+		remaining -= SMB2_COMPRESSION_PAYLOAD_BASE_LEN;
+
+		if (payload_alg == SMB3_COMPRESS_NONE) {
+			rc = smb_decompress_none(&src, &remaining, &out,
+						 &out_remaining, len);
+		} else if (payload_alg == SMB3_COMPRESS_PATTERN) {
+			if (!allow_pattern)
+				return -EINVAL;
+			rc = smb_decompress_pattern(&src, &remaining, &out,
+						    &out_remaining, len);
+		} else if (payload_alg == alg && alg == SMB3_COMPRESS_LZ77) {
+			rc = smb_decompress_lz77_payload(&src, &remaining, &out,
+							 &out_remaining, len);
+		} else {
+			return -EINVAL;
+		}
+		if (rc)
+			return rc;
+		first = false;
+	}
+
+	return out_remaining ? -EINVAL : 0;
+}
+
+static int smb_decompress_unchained(__le16 alg,
+				    const struct smb2_compression_hdr *hdr,
+				    u32 slen, void *dst, u32 dlen)
+{
+	u32 orig_size, offset, comp_size;
+
+	if (hdr->CompressionAlgorithm != alg ||
+	    !smb_compress_alg_valid(hdr->CompressionAlgorithm, false))
+		return -EINVAL;
+
+	orig_size = le32_to_cpu(hdr->OriginalCompressedSegmentSize);
+	offset = le32_to_cpu(hdr->Offset);
+	if (offset > slen - sizeof(*hdr) || offset > dlen ||
+	    orig_size > dlen - offset || orig_size + offset != dlen)
+		return -EINVAL;
+
+	memcpy(dst, (const u8 *)hdr + sizeof(*hdr), offset);
+	comp_size = slen - sizeof(*hdr) - offset;
+	return smb_lz77_decompress((const u8 *)hdr + sizeof(*hdr) + offset,
+				   comp_size, (u8 *)dst + offset, orig_size);
+}
+
+/**
+ * smb_compression_decompress() - decode an SMB2 compression transform
+ * @alg: negotiated general-purpose compression algorithm
+ * @allow_chained: whether chained transforms were negotiated
+ * @allow_pattern: whether Pattern_V1 payloads were negotiated
+ * @src: transform header followed by compressed payload data
+ * @slen: total number of bytes available at @src
+ * @dst: output buffer for the reconstructed SMB2 message
+ * @dlen: exact expected size of the reconstructed SMB2 message
+ *
+ * Validate the transform type and negotiated capabilities before dispatching
+ * to the chained or unchained decoder. The caller supplies the expected output
+ * size after applying its transport-specific message size limits.
+ *
+ * Return: 0 on success, otherwise a negative errno.
+ */
+int smb_compression_decompress(__le16 alg, bool allow_chained,
+			       bool allow_pattern, const void *src, u32 slen,
+			       void *dst, u32 dlen)
+{
+	const struct smb2_compression_hdr *hdr = src;
+
+	if (!src || !dst || slen < sizeof(*hdr) ||
+	    hdr->ProtocolId != SMB2_COMPRESSION_TRANSFORM_ID ||
+	    alg == SMB3_COMPRESS_NONE)
+		return -EINVAL;
+
+	if (hdr->Flags == cpu_to_le16(SMB2_COMPRESSION_FLAG_CHAINED))
+		return smb_decompress_chained(alg, allow_chained, allow_pattern,
+					      hdr, slen, dst, dlen);
+
+	if (hdr->Flags != cpu_to_le16(SMB2_COMPRESSION_FLAG_NONE))
+		return -EINVAL;
+
+	return smb_decompress_unchained(alg, hdr, slen, dst, dlen);
+}
+EXPORT_SYMBOL_GPL(smb_compression_decompress);
+
+struct smb_compression_builder {
+	u8 *pos;
+	u32 remaining;
+	bool first;
+};
+
+/*
+ * Reserve one chained payload header and initialize its common fields.
+ * OriginalPayloadSize is present only for LZNT1/LZ77/LZ77+Huffman payloads.
+ */
+static struct smb2_compression_payload_hdr *
+smb_compression_add_payload(struct smb_compression_builder *builder,
+			    __le16 alg, u32 payload_len, bool orig_size)
+{
+	struct smb2_compression_payload_hdr *payload;
+	u32 hdr_len = SMB2_COMPRESSION_PAYLOAD_BASE_LEN;
+	u32 total_len;
+
+	if (orig_size)
+		hdr_len += sizeof(payload->OriginalPayloadSize);
+	if (check_add_overflow(hdr_len, payload_len, &total_len) ||
+	    total_len > builder->remaining)
+		return NULL;
+
+	payload = (struct smb2_compression_payload_hdr *)builder->pos;
+	payload->CompressionAlgorithm = alg;
+	payload->Flags = cpu_to_le16(builder->first ?
+		SMB2_COMPRESSION_FLAG_CHAINED : SMB2_COMPRESSION_FLAG_NONE);
+	payload->Length = cpu_to_le32(payload_len +
+		(orig_size ? sizeof(payload->OriginalPayloadSize) : 0));
+
+	builder->pos += hdr_len;
+	builder->remaining -= hdr_len;
+	builder->first = false;
+	return payload;
+}
+
+static int smb_compression_add_pattern(struct smb_compression_builder *builder,
+				       u8 pattern, u32 repetitions)
+{
+	struct smb2_compression_pattern_v1 *payload;
+
+	if (!smb_compression_add_payload(builder, SMB3_COMPRESS_PATTERN,
+					 sizeof(*payload), false))
+		return -ENOSPC;
+
+	payload = (struct smb2_compression_pattern_v1 *)builder->pos;
+	payload->Pattern = pattern;
+	payload->Reserved1 = 0;
+	payload->Reserved2 = 0;
+	payload->Repetitions = cpu_to_le32(repetitions);
+	builder->pos += sizeof(*payload);
+	builder->remaining -= sizeof(*payload);
+	return 0;
+}
+
+static int smb_compression_add_none(struct smb_compression_builder *builder,
+				    const u8 *src, u32 len)
+{
+	if (!smb_compression_add_payload(builder, SMB3_COMPRESS_NONE, len, false))
+		return -ENOSPC;
+
+	memcpy(builder->pos, src, len);
+	builder->pos += len;
+	builder->remaining -= len;
+	return 0;
+}
+
+static int smb_compression_add_lz77(struct smb_compression_builder *builder,
+				    const u8 *src, u32 len)
+{
+	struct smb2_compression_payload_hdr *payload;
+	u32 comp_len;
+	int rc;
+
+	if (builder->remaining <= sizeof(*payload))
+		return -ENOSPC;
+
+	comp_len = builder->remaining - sizeof(*payload);
+	payload = smb_compression_add_payload(builder, SMB3_COMPRESS_LZ77,
+					      comp_len, true);
+	if (!payload)
+		return -ENOSPC;
+
+	rc = smb_lz77_compress(src, len, builder->pos, &comp_len);
+	if (rc)
+		return rc;
+
+	payload->Length = cpu_to_le32(comp_len +
+				      sizeof(payload->OriginalPayloadSize));
+	payload->OriginalPayloadSize = cpu_to_le32(len);
+	builder->pos += comp_len;
+	builder->remaining -= comp_len;
+	return 0;
+}
+
+/**
+ * smb_compression_compress_chained() - build a chained SMB2 transform
+ * @alg: negotiated general-purpose compression algorithm
+ * @allow_pattern: whether Pattern_V1 was negotiated
+ * @src: complete uncompressed SMB2 message
+ * @slen: size of @src
+ * @dst: output buffer for the transform
+ * @dlen: input capacity of @dst and output transform size
+ *
+ * Following the algorithm in [MS-SMB2] 3.1.4.4, encode sufficiently long
+ * repeated runs at the front and back as Pattern_V1 payloads. Compress a
+ * middle region larger than 1 KiB with LZ77; smaller middle regions are
+ * represented by a chained NONE payload.
+ *
+ * This helper does not decide whether the final transform is smaller than the
+ * original message. The transport caller owns that policy decision.
+ *
+ * Return: 0 on success, otherwise a negative errno.
+ */
+int smb_compression_compress_chained(__le16 alg, bool allow_pattern,
+				     const void *src, u32 slen,
+				     void *dst, u32 *dlen)
+{
+	struct smb2_compression_hdr *hdr = dst;
+	struct smb_compression_builder builder;
+	const u8 *input = src;
+	u32 forward = 0, backward = 0, middle_len;
+	int rc;
+
+	if (!src || !dst || !dlen || alg != SMB3_COMPRESS_LZ77 ||
+	    *dlen <= SMB2_COMPRESSION_CHAINED_HDR_LEN || !slen)
+		return -EINVAL;
+
+	hdr->ProtocolId = SMB2_COMPRESSION_TRANSFORM_ID;
+	hdr->OriginalCompressedSegmentSize = cpu_to_le32(slen);
+	builder.pos = (u8 *)dst + SMB2_COMPRESSION_CHAINED_HDR_LEN;
+	builder.remaining = *dlen - SMB2_COMPRESSION_CHAINED_HDR_LEN;
+	builder.first = true;
+
+	if (allow_pattern && slen > 32) {
+		for (forward = 1; forward < slen; forward++) {
+			if (input[forward] != input[0])
+				break;
+		}
+		if (forward <= 32)
+			forward = 0;
+
+		for (backward = 1; backward < slen - forward; backward++) {
+			if (input[slen - backward - 1] != input[slen - 1])
+				break;
+		}
+		if (backward <= 32)
+			backward = 0;
+	}
+
+	if (forward) {
+		rc = smb_compression_add_pattern(&builder, input[0], forward);
+		if (rc)
+			return rc;
+	}
+
+	middle_len = slen - forward - backward;
+	if (middle_len > 1024)
+		rc = smb_compression_add_lz77(&builder, input + forward,
+					      middle_len);
+	else if (middle_len)
+		rc = smb_compression_add_none(&builder,
+					      input + forward, middle_len);
+	else
+		rc = 0;
+	if (rc)
+		return rc;
+
+	if (backward) {
+		rc = smb_compression_add_pattern(&builder, input[slen - 1],
+						 backward);
+		if (rc)
+			return rc;
+	}
+
+	*dlen = builder.pos - (u8 *)dst;
+	return 0;
+}
+EXPORT_SYMBOL_GPL(smb_compression_compress_chained);
diff --git a/fs/smb/common/compress/compress.h b/fs/smb/common/compress/compress.h
new file mode 100644
index 000000000..d6916669f
--- /dev/null
+++ b/fs/smb/common/compress/compress.h
@@ -0,0 +1,29 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2026 Namjae Jeon <linkinjeon@kernel.org>
+ */
+#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;
+}
+
+int smb_compression_decompress(__le16 alg, bool allow_chained,
+			       bool allow_pattern, 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 */
diff --git a/fs/smb/common/compress/lz77.c b/fs/smb/common/compress/lz77.c
new file mode 100644
index 000000000..9216d973d
--- /dev/null
+++ b/fs/smb/common/compress/lz77.c
@@ -0,0 +1,461 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2024-2026, SUSE LLC
+ * Copyright (C) 2026 Namjae Jeon <linkinjeon@kernel.org>
+ *
+ * Authors: Enzo Matsumiya <ematsumiya@suse.de>
+ *          Namjae Jeon <linkinjeon@kernel.org>
+ *
+ * Implementation of the LZ77 "plain" compression algorithm, as per MS-XCA spec.
+ */
+#include <linux/slab.h>
+#include <linux/sizes.h>
+#include <linux/count_zeros.h>
+#include <linux/unaligned.h>
+#include <linux/module.h>
+#include <linux/overflow.h>
+
+#include "lz77.h"
+
+/*
+ * Compression parameters.
+ *
+ * LZ77_MATCH_MAX_DIST:		Farthest back a match can be from current position (can be 1 - 8K).
+ * LZ77_HASH_LOG:
+ * LZ77_HASH_SIZE:		ilog2 hash size (recommended to be 13 - 18, default 15 (hash size
+ *				32k)).
+ * LZ77_RSTEP_SIZE:		Number of bytes to read from input buffer for hashing and initial
+ *				match check (default 4 bytes, this effectivelly makes this the min
+ *				match len).
+ * LZ77_MSTEP_SIZE:		Number of bytes to extend-compare a found match (default 8 bytes).
+ * LZ77_SKIP_TRIGGER:		ilog2 value for adaptive skipping, i.e. to progressively skip input
+ *				bytes when we can't find matches.  Default is 4.
+ *				Higher values (>0) will decrease compression time, but will result
+ *				in worse compression ratio.  Lower values will give better
+ *				compression ratio (more matches found), but will increase time.
+ */
+#define LZ77_MATCH_MAX_DIST	SZ_8K
+#define LZ77_HASH_LOG		15
+#define LZ77_HASH_SIZE		BIT(LZ77_HASH_LOG)
+#define LZ77_RSTEP_SIZE		sizeof(u32)
+#define LZ77_MSTEP_SIZE		sizeof(u64)
+#define LZ77_SKIP_TRIGGER	4
+
+#define LZ77_PREFETCH(ptr)	__builtin_prefetch((ptr), 0, 3)
+#define LZ77_FLAG_MAX		32
+
+static __always_inline u8 lz77_read8(const u8 *ptr)
+{
+	return get_unaligned(ptr);
+}
+
+static __always_inline u32 lz77_read32(const u32 *ptr)
+{
+	return get_unaligned(ptr);
+}
+
+static __always_inline u64 lz77_read64(const u64 *ptr)
+{
+	return get_unaligned(ptr);
+}
+
+static __always_inline void lz77_write8(u8 *ptr, u8 v)
+{
+	put_unaligned(v, ptr);
+}
+
+static __always_inline void lz77_write16(u16 *ptr, u16 v)
+{
+	put_unaligned_le16(v, ptr);
+}
+
+static __always_inline void lz77_write32(u32 *ptr, u32 v)
+{
+	put_unaligned_le32(v, ptr);
+}
+
+static __always_inline u32 lz77_match_len(const void *match, const void *cur, const void *end)
+{
+	const void *start = cur;
+
+	/* Safe for a do/while because otherwise we wouldn't reach here from the main loop. */
+	do {
+		const u64 diff = lz77_read64(cur) ^ lz77_read64(match);
+
+		if (!diff) {
+			cur += LZ77_MSTEP_SIZE;
+			match += LZ77_MSTEP_SIZE;
+
+			continue;
+		}
+
+		/* This computes the number of common bytes in @diff. */
+		cur += count_trailing_zeros(diff) >> 3;
+
+		return (cur - start);
+	} while (likely(cur + LZ77_MSTEP_SIZE <= end));
+
+	/* Fallback to byte-by-byte comparison for last <8 bytes. */
+	while (cur < end && lz77_read8(cur) == lz77_read8(match)) {
+		cur++;
+		match++;
+	}
+
+	return (cur - start);
+}
+
+/**
+ * lz77_encode_match() - Match encoding.
+ * @dst:	compressed buffer
+ * @nib:	pointer to an address in @dst
+ * @dist:	match distance
+ * @len:	match length
+ *
+ * Assumes all args were previously checked.
+ *
+ * Return: @dst advanced to new position
+ *
+ * Ref: MS-XCA 2.3.4 "Plain LZ77 Compression Algorithm Details" - "Processing"
+ */
+static __always_inline void *lz77_encode_match(void *dst, void **nib, u16 dist, u32 len)
+{
+	len -= 3;
+	dist--;
+	dist <<= 3;
+
+	if (len < 7) {
+		lz77_write16(dst, dist + len);
+
+		return dst + sizeof(u16);
+	}
+
+	dist |= 7;
+	lz77_write16(dst, dist);
+	dst += sizeof(u16);
+	len -= 7;
+
+	if (!*nib) {
+		lz77_write8(dst, umin(len, 15));
+		*nib = dst;
+		dst++;
+	} else {
+		u8 *b = *nib;
+
+		lz77_write8(b, *b | umin(len, 15) << 4);
+		*nib = NULL;
+	}
+
+	if (len < 15)
+		return dst;
+
+	len -= 15;
+	if (len < 255) {
+		lz77_write8(dst, len);
+
+		return dst + 1;
+	}
+
+	lz77_write8(dst, 0xff);
+	dst++;
+	len += 7 + 15;
+	if (len <= 0xffff) {
+		lz77_write16(dst, len);
+
+		return dst + sizeof(u16);
+	}
+
+	lz77_write16(dst, 0);
+	dst += sizeof(u16);
+	lz77_write32(dst, len);
+
+	return dst + sizeof(u32);
+}
+
+/**
+ * lz77_encode_literals() - Literals encoding.
+ * @start:	where to start copying literals (uncompressed buffer)
+ * @end:	when to stop copying (uncompressed buffer)
+ * @dst:	compressed buffer
+ * @f:		pointer to current flag value
+ * @fc:		pointer to current flag count
+ * @fp:		pointer to current flag address
+ *
+ * Batch copy literals from @start to @dst, updating flag values accordingly.
+ * Assumes all args were previously checked.
+ *
+ * Return: @dst advanced to new position
+ *
+ * MS-XCA 2.3.4 "Plain LZ77 Compression Algorithm Details" - "Processing"
+ */
+static __always_inline void *lz77_encode_literals(const void *start, const void *end, void *dst,
+						  long *f, u32 *fc, void **fp)
+{
+	if (start >= end)
+		return dst;
+
+	do {
+		const u32 len = umin(end - start, LZ77_FLAG_MAX - *fc);
+
+		memcpy(dst, start, len);
+
+		dst += len;
+		start += len;
+
+		*f <<= len;
+		*fc += len;
+		if (*fc == LZ77_FLAG_MAX) {
+			lz77_write32(*fp, *f);
+			*fc = 0;
+			*fp = dst;
+			dst += sizeof(u32);
+		}
+	} while (start < end);
+
+	return dst;
+}
+
+static __always_inline u32 lz77_hash(const u32 v)
+{
+	return ((v ^ 0x9E3779B9) * 0x85EBCA6B) >> (32 - LZ77_HASH_LOG);
+}
+
+noinline int smb_lz77_compress(const void *src, const u32 slen,
+			       void *dst, u32 *dlen)
+{
+	const void *srcp, *rlim, *end, *anchor;
+	u32 *htable, hash, flag_count = 0;
+	void *dstp, *nib, *flag_pos;
+	long flag = 0;
+
+	/* This is probably a bug, so throw a warning. */
+	if (WARN_ON_ONCE(*dlen < smb_lz77_compressed_alloc_size(slen)))
+		return -EINVAL;
+
+	srcp = src;
+	anchor = src;
+	end = srcp + slen; /* absolute end */
+	rlim = end - LZ77_MSTEP_SIZE; /* read limit (for lz77_match_len()) */
+	dstp = dst;
+	flag_pos = dstp;
+	dstp += sizeof(u32);
+	nib = NULL;
+
+	htable = kvcalloc(LZ77_HASH_SIZE, sizeof(*htable), GFP_KERNEL);
+	if (!htable)
+		return -ENOMEM;
+
+	LZ77_PREFETCH(srcp + LZ77_RSTEP_SIZE);
+
+	/*
+	 * Adjust @srcp so we don't get a false positive match on first iteration.
+	 * Then prepare hash for first loop iteration (don't advance @srcp again).
+	 */
+	hash = lz77_hash(lz77_read32(srcp++));
+	htable[hash] = 0;
+	hash = lz77_hash(lz77_read32(srcp));
+
+	/*
+	 * Main loop.
+	 *
+	 * @dlen is >= smb_lz77_compressed_alloc_size(), so run without
+	 * bound-checking @dstp.
+	 *
+	 * This code was crafted in a way to best utilise fetch-decode-execute CPU flow.
+	 * Any attempt to optimize it, or even organize it, can lead to huge performance loss.
+	 */
+	do {
+		const void *match, *next = srcp;
+		u32 len, step = 1, skip = 1U << LZ77_SKIP_TRIGGER;
+
+		/* Match finding (hot path -- don't change the read/check/write order). */
+		do {
+			const u32 cur_hash = hash;
+
+			srcp = next;
+			next += step;
+
+			/*
+			 * Adaptive skipping.
+			 *
+			 * Increment @step every (1 << LZ77_SKIP_TRIGGER, 16 in our case) bytes
+			 * without a match.
+			 * Reset to 1 when a match is found.
+			 */
+			step = (skip++ >> LZ77_SKIP_TRIGGER);
+			if (unlikely(next > rlim))
+				goto out;
+
+			hash = lz77_hash(lz77_read32(next));
+			match = src + htable[cur_hash];
+			htable[cur_hash] = srcp - src;
+		} while (likely(match + LZ77_MATCH_MAX_DIST < srcp) ||
+			 lz77_read32(match) != lz77_read32(srcp));
+
+		/*
+		 * Match found.  Warm/cold path; begin parsing @srcp and writing to @dstp:
+		 * - flush literals
+		 * - compute match length (*)
+		 * - encode match
+		 *
+		 * (*) Current minimum match length is defined by the memory read size above, so
+		 * here we already know that we have 4 matching bytes, but it's just faster to
+		 * redundantly compute it again in lz77_match_len() than to adjust pointers/len.
+		 */
+		dstp = lz77_encode_literals(anchor, srcp, dstp, &flag, &flag_count, &flag_pos);
+		len = lz77_match_len(match, srcp, end);
+		dstp = lz77_encode_match(dstp, &nib, srcp - match, len);
+		srcp += len;
+		anchor = srcp;
+
+		LZ77_PREFETCH(srcp);
+
+		flag = (flag << 1) | 1;
+		flag_count++;
+		if (flag_count == LZ77_FLAG_MAX) {
+			lz77_write32(flag_pos, flag);
+			flag_count = 0;
+			flag_pos = dstp;
+			dstp += sizeof(u32);
+		}
+
+		if (unlikely(srcp > rlim))
+			break;
+
+		/* Prepare for next loop. */
+		hash = lz77_hash(lz77_read32(srcp));
+	} while (srcp < end);
+out:
+	dstp = lz77_encode_literals(anchor, end, dstp, &flag, &flag_count, &flag_pos);
+
+	flag_count = LZ77_FLAG_MAX - flag_count;
+	flag <<= flag_count;
+	flag |= (1UL << flag_count) - 1;
+	lz77_write32(flag_pos, flag);
+
+	*dlen = dstp - dst;
+	kvfree(htable);
+
+	if (*dlen < slen)
+		return 0;
+
+	return -EMSGSIZE;
+}
+EXPORT_SYMBOL_GPL(smb_lz77_compress);
+
+static int lz77_decode_match_len(const u8 **src, const u8 *end, u16 token,
+				 u8 *nibble, bool *have_nibble, u32 *len)
+{
+	u8 extra;
+
+	*len = (token & 0x7) + 3;
+	if ((token & 0x7) != 0x7)
+		return 0;
+
+	if (!*have_nibble) {
+		if (*src >= end)
+			return -EINVAL;
+		*nibble = *(*src)++;
+		extra = *nibble & 0xf;
+		*have_nibble = true;
+	} else {
+		extra = *nibble >> 4;
+		*have_nibble = false;
+	}
+
+	*len += extra;
+	if (extra == 0xf) {
+		u8 b;
+
+		if (*src >= end)
+			return -EINVAL;
+		b = *(*src)++;
+		if (b != 0xff) {
+			*len += b;
+		} else {
+			u16 w;
+
+			if (end - *src < 2)
+				return -EINVAL;
+			w = get_unaligned_le16(*src);
+			*src += 2;
+			if (w) {
+				*len = w + 3;
+			} else {
+				u32 long_len;
+
+				if (end - *src < 4)
+					return -EINVAL;
+				long_len = get_unaligned_le32(*src);
+				*src += 4;
+				if (check_add_overflow(long_len, 3, len))
+					return -EINVAL;
+			}
+		}
+	}
+
+	return 0;
+}
+
+int smb_lz77_decompress(const void *src, const u32 slen, void *dst,
+			const u32 dlen)
+{
+	const u8 *sp = src, *send = sp + slen;
+	u8 *dp = dst, *dend = dp + dlen;
+	u32 flags = 0;
+	int flag_count = 0;
+	u8 nibble = 0;
+	bool have_nibble = false;
+
+	while (dp < dend) {
+		u32 len, dist;
+		u16 token;
+
+		if (!flag_count) {
+			if (send - sp < 4)
+				return -EINVAL;
+			flags = get_unaligned_le32(sp);
+			sp += 4;
+			flag_count = 32;
+		}
+
+		if (!(flags & 0x80000000)) {
+			if (sp >= send)
+				return -EINVAL;
+			*dp++ = *sp++;
+			flags <<= 1;
+			flag_count--;
+			continue;
+		}
+
+		flags <<= 1;
+		flag_count--;
+
+		if (send - sp < 2)
+			return -EINVAL;
+
+		token = get_unaligned_le16(sp);
+		sp += 2;
+
+		dist = (token >> 3) + 1;
+		if (dist > dp - (u8 *)dst)
+			return -EINVAL;
+
+		if (lz77_decode_match_len(&sp, send, token, &nibble,
+					  &have_nibble, &len))
+			return -EINVAL;
+
+		if (len > dend - dp)
+			return -EINVAL;
+
+		while (len--) {
+			*dp = *(dp - dist);
+			dp++;
+		}
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(smb_lz77_decompress);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("SMB plain LZ77 compression");
diff --git a/fs/smb/common/compress/lz77.h b/fs/smb/common/compress/lz77.h
new file mode 100644
index 000000000..e032c0f1b
--- /dev/null
+++ b/fs/smb/common/compress/lz77.h
@@ -0,0 +1,46 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2024-2026, SUSE LLC
+ *
+ * Authors: Enzo Matsumiya <ematsumiya@suse.de>
+ *
+ * Implementation of the LZ77 "plain" compression algorithm, as per MS-XCA spec.
+ */
+#ifndef _SMB_COMPRESS_LZ77_H
+#define _SMB_COMPRESS_LZ77_H
+
+#include <linux/kernel.h>
+
+/**
+ * smb_lz77_compressed_alloc_size() - Compute compressed buffer size.
+ * @size:	uncompressed (src) size
+ *
+ * Compute allocation size for the compressed buffer based on uncompressed size.
+ * Accounts for metadata and overprovision for the worst case scenario.
+ *
+ * LZ77 metadata is a 4-byte flag that is written:
+ * - on dst begin (pos 0)
+ * - every 32 literals or matches
+ * - on end-of-stream (possibly, if last write was another flag)
+ *
+ * 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 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 smb_lz77_compress()
+ */
+static __always_inline u32 smb_lz77_compressed_alloc_size(const u32 size)
+{
+	return size + (size >> 3) + 8;
+}
+
+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 */
diff --git a/fs/smb/common/fscc.h b/fs/smb/common/fscc.h
new file mode 100644
index 000000000..e46d3379b
--- /dev/null
+++ b/fs/smb/common/fscc.h
@@ -0,0 +1,604 @@
+/* SPDX-License-Identifier: LGPL-2.1 */
+/*
+ *
+ *   Copyright (c) International Business Machines  Corp., 2009, 2013
+ *                 Etersoft, 2012
+ *                 2018 Samsung Electronics Co., Ltd.
+ *   Author(s): Steve French (sfrench@us.ibm.com)
+ *              Pavel Shilovsky (pshilovsky@samba.org) 2012
+ *              Namjae Jeon (linkinjeon@kernel.org)
+ *
+ */
+#ifndef _COMMON_SMB_FSCC_H
+#define _COMMON_SMB_FSCC_H
+
+/* Reparse structures - see MS-FSCC 2.1.2 */
+
+/* struct fsctl_reparse_info_req is empty, only response structs (see below) */
+struct reparse_data_buffer {
+	__le32	ReparseTag;
+	__le16	ReparseDataLength;
+	__u16	Reserved;
+	__u8	DataBuffer[]; /* Variable Length */
+} __packed;
+
+struct reparse_guid_data_buffer {
+	__le32	ReparseTag;
+	__le16	ReparseDataLength;
+	__u16	Reserved;
+	__u8	ReparseGuid[16];
+	__u8	DataBuffer[]; /* Variable Length */
+} __packed;
+
+struct reparse_mount_point_data_buffer {
+	__le32	ReparseTag;
+	__le16	ReparseDataLength;
+	__u16	Reserved;
+	__le16	SubstituteNameOffset;
+	__le16	SubstituteNameLength;
+	__le16	PrintNameOffset;
+	__le16	PrintNameLength;
+	__u8	PathBuffer[]; /* Variable Length */
+} __packed;
+
+#define SYMLINK_FLAG_RELATIVE 0x00000001
+
+struct reparse_symlink_data_buffer {
+	__le32	ReparseTag;
+	__le16	ReparseDataLength;
+	__u16	Reserved;
+	__le16	SubstituteNameOffset;
+	__le16	SubstituteNameLength;
+	__le16	PrintNameOffset;
+	__le16	PrintNameLength;
+	__le32	Flags;
+	__u8	PathBuffer[]; /* Variable Length */
+} __packed;
+
+/* For IO_REPARSE_TAG_NFS - see MS-FSCC 2.1.2.6 */
+#define NFS_SPECFILE_LNK	0x00000000014B4E4C
+#define NFS_SPECFILE_CHR	0x0000000000524843
+#define NFS_SPECFILE_BLK	0x00000000004B4C42
+#define NFS_SPECFILE_FIFO	0x000000004F464946
+#define NFS_SPECFILE_SOCK	0x000000004B434F53
+struct reparse_nfs_data_buffer {
+	__le32	ReparseTag;
+	__le16	ReparseDataLength;
+	__u16	Reserved;
+	__le64	InodeType; /* NFS_SPECFILE_* */
+	__u8	DataBuffer[];
+} __packed;
+
+/* For IO_REPARSE_TAG_LX_SYMLINK - see MS-FSCC 2.1.2.7 */
+struct reparse_wsl_symlink_data_buffer {
+	__le32	ReparseTag;
+	__le16	ReparseDataLength;
+	__u16	Reserved;
+	__le32	Version; /* Always 2 */
+	__u8	Target[]; /* Variable Length UTF-8 string without nul-term */
+} __packed;
+
+/* See MS-FSCC 2.3.7 */
+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;
+
+/* See MS-FSCC 2.3.9 */
+#define DUPLICATE_EXTENTS_DATA_EX_SOURCE_ATOMIC	0x00000001
+struct duplicate_extents_to_file_ex {
+	__le64 StructureSize; /* MUST be set to 0x30 */
+	__u64 PersistentFileHandle; /* source file handle, opaque endianness */
+	__u64 VolatileFileHandle;
+	__le64 SourceFileOffset;
+	__le64 TargetFileOffset;
+	__le64 ByteCount;  /* Bytes to be copied */
+	__le32 Flags;
+	__le32 Reserved;
+} __packed;
+
+/*
+ * compression state flags
+ * See MS-FSCC 2.3.18
+ *     MS-FSCC 2.3.67
+ *     MS-FSCC 2.4.9
+ */
+#define COMPRESSION_FORMAT_NONE	0x0000
+#define COMPRESSION_FORMAT_DEFAULT	0x0001
+#define COMPRESSION_FORMAT_LZNT1	0x0002
+
+/*
+ * See MS-FSCC 2.3.18
+ *     MS-FSCC 2.3.67
+ */
+struct compress_ioctl {
+	__le16 CompressionState;
+} __packed;
+
+/* See MS-FSCC 2.3.20 */
+struct fsctl_get_integrity_information_rsp {
+	__le16	ChecksumAlgorithm;
+	__le16	Reserved;
+	__le32	Flags;
+	__le32	ChecksumChunkSizeInBytes;
+	__le32	ClusterSizeInBytes;
+} __packed;
+
+/* See MS-FSCC 2.3.52 */
+struct file_allocated_range_buffer {
+	__le64	file_offset;
+	__le64	length;
+} __packed;
+
+/* See MS-FSCC 2.3.55 */
+struct fsctl_query_file_regions_req {
+	__le64	FileOffset;
+	__le64	Length;
+	__le32	DesiredUsage;
+	__le32	Reserved;
+} __packed;
+
+/* DesiredUsage flags see MS-FSCC 2.3.56.1 */
+#define FILE_USAGE_INVALID_RANGE	0x00000000
+#define FILE_USAGE_VALID_CACHED_DATA	0x00000001
+#define FILE_USAGE_NONCACHED_DATA	0x00000002
+struct file_region_info {
+	__le64	FileOffset;
+	__le64	Length;
+	__le32	DesiredUsage;
+	__le32	Reserved;
+} __packed;
+
+/* See MS-FSCC 2.3.56 */
+struct fsctl_query_file_region_rsp {
+	__le32 Flags;
+	__le32 TotalRegionEntryCount;
+	__le32 RegionEntryCount;
+	__u32  Reserved;
+	struct  file_region_info Regions[];
+} __packed;
+
+/* See MS-FSCC 2.3.58 */
+struct fsctl_query_on_disk_vol_info_rsp {
+	__le64	DirectoryCount;
+	__le64	FileCount;
+	__le16	FsFormatMajVersion;
+	__le16	FsFormatMinVersion;
+	__u8	FsFormatName[24];
+	__le64	FormatTime;
+	__le64	LastUpdateTime;
+	__u8	CopyrightInfo[68];
+	__u8	AbstractInfo[68];
+	__u8	FormatImplInfo[68];
+	__u8	LastModifyImplInfo[68];
+} __packed;
+
+/* See MS-FSCC 2.3.73 */
+struct fsctl_set_integrity_information_req {
+	__le16	ChecksumAlgorithm;
+	__le16	Reserved;
+	__le32	Flags;
+} __packed;
+
+/* See MS-FSCC 2.3.75 */
+struct fsctl_set_integrity_info_ex_req {
+	__u8	EnableIntegrity;
+	__u8	KeepState;
+	__u16	Reserved;
+	__le32	Flags;
+	__u8	Version;
+	__u8	Reserved2[7];
+} __packed;
+
+/*
+ * this goes in the ioctl buffer when doing FSCTL_SET_ZERO_DATA
+ * See MS-FSCC 2.3.85
+ */
+struct file_zero_data_information {
+	__le64	FileOffset;
+	__le64	BeyondFinalZero;
+} __packed;
+
+struct file_level_trim_range {
+	__le64	Offset;
+	__le64	Length;
+} __packed;
+
+struct file_level_trim {
+	__le32	Key;
+	__le32	NumRanges;
+	struct file_level_trim_range Ranges[];
+} __packed;
+
+struct file_level_trim_output {
+	__le32	NumRangesProcessed;
+} __packed;
+
+/*
+ * This level 18, although with struct with same name is different from cifs
+ * level 0x107. Level 0x107 has an extra u64 between AccessFlags and
+ * CurrentByteOffset.
+ * See MS-FSCC 2.4.2
+ */
+struct smb2_file_all_info { /* data block encoding of response to level 18 */
+	__le64 CreationTime;	/* Beginning of FILE_BASIC_INFO equivalent */
+	__le64 LastAccessTime;
+	__le64 LastWriteTime;
+	__le64 ChangeTime;
+	__le32 Attributes;
+	__u32  Pad1;		/* End of FILE_BASIC_INFO_INFO equivalent */
+	__le64 AllocationSize;	/* Beginning of FILE_STANDARD_INFO equivalent */
+	__le64 EndOfFile;	/* size ie offset to first free byte in file */
+	__le32 NumberOfLinks;	/* hard links */
+	__u8   DeletePending;
+	__u8   Directory;
+	__u16  Pad2;		/* End of FILE_STANDARD_INFO equivalent */
+	__le64 IndexNumber;
+	__le32 EASize;
+	__le32 AccessFlags;
+	__le64 CurrentByteOffset;
+	__le32 Mode;
+	__le32 AlignmentRequirement;
+	__le32 FileNameLength;
+	union {
+		char __pad;	/* Legacy structure padding */
+		DECLARE_FLEX_ARRAY(char, FileName);
+	};
+} __packed; /* level 18 Query */
+
+/* See MS-FSCC 2.4.7 */
+typedef struct file_basic_info { /* data block encoding of response to level 18 */
+	__le64 CreationTime;
+	__le64 LastAccessTime;
+	__le64 LastWriteTime;
+	__le64 ChangeTime;
+	__le32 Attributes;
+	__u32  Pad;
+} __packed FILE_BASIC_INFO;	/* size info, level 0x101 */
+
+/* See MS-FSCC 2.4.8 */
+typedef struct {
+	__le32 NextEntryOffset;
+	__u32 FileIndex;
+	__le64 CreationTime;
+	__le64 LastAccessTime;
+	__le64 LastWriteTime;
+	__le64 ChangeTime;
+	__le64 EndOfFile;
+	__le64 AllocationSize;
+	__le32 ExtFileAttributes;
+	__le32 FileNameLength;
+	__le32 EaSize; /* length of the xattrs */
+	__u8   ShortNameLength;
+	__u8   Reserved;
+	__u8   ShortName[24];
+	char FileName[];
+} __packed FILE_BOTH_DIRECTORY_INFO; /* level 0x104 FFrsp data */
+
+/* See MS-FSCC 2.4.10 */
+typedef struct {
+	__le32 NextEntryOffset;
+	__u32 FileIndex;
+	__le64 CreationTime;
+	__le64 LastAccessTime;
+	__le64 LastWriteTime;
+	__le64 ChangeTime;
+	__le64 EndOfFile;
+	__le64 AllocationSize;
+	__le32 ExtFileAttributes;
+	__le32 FileNameLength;
+	char FileName[];
+} __packed FILE_DIRECTORY_INFO;   /* level 0x101 FF resp data */
+
+/* See MS-FSCC 2.4.14 */
+struct smb2_file_eof_info { /* encoding of request for level 10 */
+	__le64 EndOfFile; /* new end of file value */
+} __packed; /* level 20 Set */
+
+/* See MS-FSCC 2.4.4 */
+struct smb2_file_alloc_info { /* encoding of request for level 19 */
+	__le64 AllocationSize;
+} __packed;
+
+/* See MS-FSCC 2.4.15 */
+typedef struct {
+	__le32 NextEntryOffset;
+	__u32 FileIndex;
+	__le64 CreationTime;
+	__le64 LastAccessTime;
+	__le64 LastWriteTime;
+	__le64 ChangeTime;
+	__le64 EndOfFile;
+	__le64 AllocationSize;
+	__le32 ExtFileAttributes;
+	__le32 FileNameLength;
+	__le32 EaSize; /* length of the xattrs */
+	char FileName[];
+} __packed FILE_FULL_DIRECTORY_INFO; /* level 0x102 rsp data */
+
+/* See MS-FSCC 2.4.24 */
+typedef struct {
+	__le32 NextEntryOffset;
+	__u32 FileIndex;
+	__le64 CreationTime;
+	__le64 LastAccessTime;
+	__le64 LastWriteTime;
+	__le64 ChangeTime;
+	__le64 EndOfFile;
+	__le64 AllocationSize;
+	__le32 ExtFileAttributes;
+	__le32 FileNameLength;
+	__le32 EaSize; /* EA size */
+	__le32 Reserved;
+	__le64 UniqueId; /* inode num - le since Samba puts ino in low 32 bit*/
+	char FileName[];
+} __packed FILE_ID_FULL_DIR_INFO; /* level 0x105 FF rsp data */
+
+/* See MS-FSCC 2.4.27 */
+struct smb2_file_internal_info {
+	__le64 IndexNumber;
+} __packed; /* level 6 Query */
+
+/* See MS-FSCC 2.4.28.2 */
+struct smb2_file_link_info { /* encoding of request for level 11 */
+	/* New members MUST be added within the struct_group() macro below. */
+	__struct_group(smb2_file_link_info_hdr, __hdr, __packed,
+		__u8   ReplaceIfExists; /* 1 = replace existing link with new */
+					/* 0 = fail if link already exists */
+		__u8   Reserved[7];
+		__u64  RootDirectory;  /* MBZ for network operations (why says spec?) */
+		__le32 FileNameLength;
+	);
+	char   FileName[];     /* Name to be assigned to new link */
+} __packed; /* level 11 Set */
+static_assert(offsetof(struct smb2_file_link_info, FileName) == sizeof(struct smb2_file_link_info_hdr),
+	      "struct member likely outside of __struct_group()");
+
+/* See MS-FSCC 2.4.34 */
+struct smb2_file_network_open_info {
+	struct_group_attr(network_open_info, __packed,
+		__le64 CreationTime;
+		__le64 LastAccessTime;
+		__le64 LastWriteTime;
+		__le64 ChangeTime;
+		__le64 AllocationSize;
+		__le64 EndOfFile;
+		__le32 Attributes;
+	);
+	__le32 Reserved;
+} __packed; /* level 34 Query also similar returned in close rsp and open rsp */
+
+/* See MS-FSCC 2.4.42.2 */
+struct smb2_file_rename_info { /* encoding of request for level 10 */
+	/* New members MUST be added within the struct_group() macro below. */
+	__struct_group(smb2_file_rename_info_hdr, __hdr, __packed,
+		__u8   ReplaceIfExists; /* 1 = replace existing target with new */
+					/* 0 = fail if target already exists */
+		__u8   Reserved[7];
+		__u64  RootDirectory;  /* MBZ for network operations (why says spec?) */
+		__le32 FileNameLength;
+	);
+	char   FileName[];     /* New name to be assigned */
+	/* padding - overall struct size must be >= 24 so filename + pad >= 6 */
+} __packed; /* level 10 Set */
+static_assert(offsetof(struct smb2_file_rename_info, FileName) == sizeof(struct smb2_file_rename_info_hdr),
+	      "struct member likely outside of __struct_group()");
+
+/* File System Information Classes */
+/* See MS-FSCC 2.5 */
+#define FS_VOLUME_INFORMATION		1 /* Query */
+#define FS_LABEL_INFORMATION		2 /* Set */
+#define FS_SIZE_INFORMATION		3 /* Query */
+#define FS_DEVICE_INFORMATION		4 /* Query */
+#define FS_ATTRIBUTE_INFORMATION	5 /* Query */
+#define FS_CONTROL_INFORMATION		6 /* Query, Set */
+#define FS_FULL_SIZE_INFORMATION	7 /* Query */
+#define FS_OBJECT_ID_INFORMATION	8 /* Query, Set */
+#define FS_DRIVER_PATH_INFORMATION	9 /* Query */
+#define FS_SECTOR_SIZE_INFORMATION	11 /* SMB3 or later. Query */
+/* See POSIX Extensions to MS-FSCC 2.3.1.1 */
+#define FS_POSIX_INFORMATION		100 /* SMB3.1.1 POSIX. Query */
+
+/* See MS-FSCC 2.5.1 */
+#define MAX_FS_NAME_LEN		52
+typedef struct {
+	__le32 Attributes;
+	__le32 MaxPathNameComponentLength;
+	__le32 FileSystemNameLen;
+	__le16 FileSystemName[]; /* do not have to save this - get subset? */
+} __packed FILE_SYSTEM_ATTRIBUTE_INFO;
+
+/* List of FileSystemAttributes - see MS-FSCC 2.5.1 */
+#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
+#define FILE_SUPPORTS_EXTENDED_ATTRIBUTES 0x00800000
+#define FILE_SUPPORTS_HARD_LINKS	0x00400000
+#define FILE_SUPPORTS_TRANSACTIONS	0x00200000
+#define FILE_SEQUENTIAL_WRITE_ONCE	0x00100000
+#define FILE_READ_ONLY_VOLUME		0x00080000
+#define FILE_NAMED_STREAMS		0x00040000
+#define FILE_SUPPORTS_ENCRYPTION	0x00020000
+#define FILE_SUPPORTS_OBJECT_IDS	0x00010000
+#define FILE_VOLUME_IS_COMPRESSED	0x00008000
+#define FILE_SUPPORTS_POSIX_UNLINK_RENAME 0x00000400
+#define FILE_RETURNS_CLEANUP_RESULT_INFO  0x00000200
+#define FILE_SUPPORTS_REMOTE_STORAGE	0x00000100
+#define FILE_SUPPORTS_REPARSE_POINTS	0x00000080
+#define FILE_SUPPORTS_SPARSE_FILES	0x00000040
+#define FILE_VOLUME_QUOTAS		0x00000020
+#define FILE_FILE_COMPRESSION		0x00000010
+#define FILE_PERSISTENT_ACLS		0x00000008
+#define FILE_UNICODE_ON_DISK		0x00000004
+#define FILE_CASE_PRESERVED_NAMES	0x00000002
+#define FILE_CASE_SENSITIVE_SEARCH	0x00000001
+
+/*
+ * File System Control Information
+ * See MS-FSCC 2.5.2
+ */
+struct smb2_fs_control_info {
+	__le64 FreeSpaceStartFiltering;
+	__le64 FreeSpaceThreshold;
+	__le64 FreeSpaceStopFiltering;
+	__le64 DefaultQuotaThreshold;
+	__le64 DefaultQuotaLimit;
+	__le32 FileSystemControlFlags;
+	__le32 Padding;
+} __packed;
+
+/* See MS-FSCC 2.5.4 */
+struct smb2_fs_full_size_info {
+	__le64 TotalAllocationUnits;
+	__le64 CallerAvailableAllocationUnits;
+	__le64 ActualAvailableAllocationUnits;
+	__le32 SectorsPerAllocationUnit;
+	__le32 BytesPerSector;
+} __packed;
+
+/* See MS-FSCC 2.5.7 */
+#define SSINFO_FLAGS_ALIGNED_DEVICE		0x00000001
+#define SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE 0x00000002
+#define SSINFO_FLAGS_NO_SEEK_PENALTY		0x00000004
+#define SSINFO_FLAGS_TRIM_ENABLED		0x00000008
+/* sector size info struct */
+struct smb3_fs_ss_info {
+	__le32 LogicalBytesPerSector;
+	__le32 PhysicalBytesPerSectorForAtomicity;
+	__le32 PhysicalBytesPerSectorForPerf;
+	__le32 FSEffPhysicalBytesPerSectorForAtomicity;
+	__le32 Flags;
+	__le32 ByteOffsetForSectorAlignment;
+	__le32 ByteOffsetForPartitionAlignment;
+} __packed;
+
+/* See MS-FSCC 2.5.8 */
+typedef struct {
+	__le64 TotalAllocationUnits;
+	__le64 AvailableAllocationUnits;
+	__le32 SectorsPerAllocationUnit;
+	__le32 BytesPerSector;
+} __packed FILE_SYSTEM_SIZE_INFO;	/* size info, level 0x103 */
+
+/* volume info struct - see MS-FSCC 2.5.9 */
+#define MAX_VOL_LABEL_LEN	32
+struct filesystem_vol_info {
+	__le64	VolumeCreationTime;
+	__le32	VolumeSerialNumber;
+	__le32	VolumeLabelLength; /* includes trailing null */
+	__u8	SupportsObjects; /* True if eg like NTFS, supports objects */
+	__u8	Reserved;
+	__u8	VolumeLabel[]; /* variable len */
+} __packed;
+
+/* See MS-FSCC 2.5.10 */
+typedef struct {
+	__le32 DeviceType;
+	__le32 DeviceCharacteristics;
+} __packed FILE_SYSTEM_DEVICE_INFO; /* device info level 0x104 */
+
+/*
+ * File Attributes
+ * See MS-FSCC 2.6
+ */
+#define FILE_ATTRIBUTE_READONLY			0x00000001
+#define FILE_ATTRIBUTE_HIDDEN			0x00000002
+#define FILE_ATTRIBUTE_SYSTEM			0x00000004
+#define FILE_ATTRIBUTE_DIRECTORY		0x00000010
+#define FILE_ATTRIBUTE_ARCHIVE			0x00000020
+#define FILE_ATTRIBUTE_NORMAL			0x00000080
+#define FILE_ATTRIBUTE_TEMPORARY		0x00000100
+#define FILE_ATTRIBUTE_SPARSE_FILE		0x00000200
+#define FILE_ATTRIBUTE_REPARSE_POINT		0x00000400
+#define FILE_ATTRIBUTE_COMPRESSED		0x00000800
+#define FILE_ATTRIBUTE_OFFLINE			0x00001000
+#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED	0x00002000
+#define FILE_ATTRIBUTE_ENCRYPTED		0x00004000
+#define FILE_ATTRIBUTE_INTEGRITY_STREAM		0x00008000
+#define FILE_ATTRIBUTE_NO_SCRUB_DATA		0x00020000
+#define FILE_ATTRIBUTE_MASK (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | \
+		FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY | \
+		FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_NORMAL | \
+		FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_SPARSE_FILE | \
+		FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_COMPRESSED | \
+		FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED | \
+		FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_INTEGRITY_STREAM | \
+		FILE_ATTRIBUTE_NO_SCRUB_DATA)
+
+#define FILE_ATTRIBUTE_READONLY_LE		cpu_to_le32(FILE_ATTRIBUTE_READONLY)
+#define FILE_ATTRIBUTE_HIDDEN_LE		cpu_to_le32(FILE_ATTRIBUTE_HIDDEN)
+#define FILE_ATTRIBUTE_SYSTEM_LE		cpu_to_le32(FILE_ATTRIBUTE_SYSTEM)
+#define FILE_ATTRIBUTE_DIRECTORY_LE		cpu_to_le32(FILE_ATTRIBUTE_DIRECTORY)
+#define FILE_ATTRIBUTE_ARCHIVE_LE		cpu_to_le32(FILE_ATTRIBUTE_ARCHIVE)
+#define FILE_ATTRIBUTE_NORMAL_LE		cpu_to_le32(FILE_ATTRIBUTE_NORMAL)
+#define FILE_ATTRIBUTE_TEMPORARY_LE		cpu_to_le32(FILE_ATTRIBUTE_TEMPORARY)
+#define FILE_ATTRIBUTE_SPARSE_FILE_LE		cpu_to_le32(FILE_ATTRIBUTE_SPARSE_FILE)
+#define FILE_ATTRIBUTE_REPARSE_POINT_LE		cpu_to_le32(FILE_ATTRIBUTE_REPARSE_POINT)
+#define FILE_ATTRIBUTE_COMPRESSED_LE		cpu_to_le32(FILE_ATTRIBUTE_COMPRESSED)
+#define FILE_ATTRIBUTE_OFFLINE_LE		cpu_to_le32(FILE_ATTRIBUTE_OFFLINE)
+#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED_LE	cpu_to_le32(FILE_ATTRIBUTE_NOT_CONTENT_INDEXED)
+#define FILE_ATTRIBUTE_ENCRYPTED_LE		cpu_to_le32(FILE_ATTRIBUTE_ENCRYPTED)
+#define FILE_ATTRIBUTE_INTEGRITY_STREAM_LE	cpu_to_le32(FILE_ATTRIBUTE_INTEGRITY_STREAM)
+#define FILE_ATTRIBUTE_NO_SCRUB_DATA_LE		cpu_to_le32(FILE_ATTRIBUTE_NO_SCRUB_DATA)
+#define FILE_ATTRIBUTE_MASK_LE			cpu_to_le32(FILE_ATTRIBUTE_MASK)
+
+/*
+ * SMB2 Notify Action Flags
+ * See MS-FSCC 2.7.1
+ */
+#define FILE_ACTION_ADDED                       0x00000001
+#define FILE_ACTION_REMOVED                     0x00000002
+#define FILE_ACTION_MODIFIED                    0x00000003
+#define FILE_ACTION_RENAMED_OLD_NAME            0x00000004
+#define FILE_ACTION_RENAMED_NEW_NAME            0x00000005
+#define FILE_ACTION_ADDED_STREAM                0x00000006
+#define FILE_ACTION_REMOVED_STREAM              0x00000007
+#define FILE_ACTION_MODIFIED_STREAM             0x00000008
+#define FILE_ACTION_REMOVED_BY_DELETE           0x00000009
+#define FILE_ACTION_ID_NOT_TUNNELLED            0x0000000A
+#define FILE_ACTION_TUNNELLED_ID_COLLISION      0x0000000B
+
+/*
+ * Response contains array of the following structures
+ * See MS-FSCC 2.7.1
+ */
+struct file_notify_information {
+	__le32 NextEntryOffset;
+	__le32 Action;
+	__le32 FileNameLength;
+	__u8  FileName[];
+} __packed;
+
+/*
+ * See POSIX Extensions to MS-FSCC 2.3.2.1
+ * Link: https://gitlab.com/samba-team/smb3-posix-spec/-/blob/master/fscc_posix_extensions.md
+ */
+typedef struct {
+	/* For undefined recommended transfer size return -1 in that field */
+	__le32 OptimalTransferSize;  /* bsize on some os, iosize on other os */
+	__le32 BlockSize;
+	/* The next three fields are in terms of the block size.
+	 * (above). If block size is unknown, 4096 would be a
+	 * reasonable block size for a server to report.
+	 * Note that returning the blocks/blocksavail removes need
+	 * to make a second call (to QFSInfo level 0x103 to get this info.
+	 * UserBlockAvail is typically less than or equal to BlocksAvail,
+	 * if no distinction is made return the same value in each
+	 */
+	__le64 TotalBlocks;
+	__le64 BlocksAvail;       /* bfree */
+	__le64 UserBlocksAvail;   /* bavail */
+	/* For undefined Node fields or FSID return -1 */
+	__le64 TotalFileNodes;
+	__le64 FreeFileNodes;
+	__le64 FileSysIdentifier;   /* fsid */
+	/* NB Namelen comes from FILE_SYSTEM_ATTRIBUTE_INFO call */
+	/* NB flags can come from FILE_SYSTEM_DEVICE_INFO call   */
+} __packed FILE_SYSTEM_POSIX_INFO;
+
+#endif /* _COMMON_SMB_FSCC_H */
diff --git a/fs/smb/common/md4.h b/fs/smb/common/md4.h
new file mode 100644
index 000000000..5337becc6
--- /dev/null
+++ b/fs/smb/common/md4.h
@@ -0,0 +1,27 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Common values for ARC4 Cipher Algorithm
+ */
+
+#ifndef _CIFS_MD4_H
+#define _CIFS_MD4_H
+
+#include <linux/types.h>
+
+#define MD4_DIGEST_SIZE		16
+#define MD4_HMAC_BLOCK_SIZE	64
+#define MD4_BLOCK_WORDS		16
+#define MD4_HASH_WORDS		4
+
+struct md4_ctx {
+	u32 hash[MD4_HASH_WORDS];
+	u32 block[MD4_BLOCK_WORDS];
+	u64 byte_count;
+};
+
+
+int cifs_md4_init(struct md4_ctx *mctx);
+int cifs_md4_update(struct md4_ctx *mctx, const u8 *data, unsigned int len);
+int cifs_md4_final(struct md4_ctx *mctx, u8 *out);
+
+#endif /* _CIFS_MD4_H */
diff --git a/fs/smb/common/smb1pdu.h b/fs/smb/common/smb1pdu.h
new file mode 100644
index 000000000..df6d4e11a
--- /dev/null
+++ b/fs/smb/common/smb1pdu.h
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: LGPL-2.1 */
+/*
+ *
+ *   Copyright (C) International Business Machines  Corp., 2002,2009
+ *                 2018 Samsung Electronics Co., Ltd.
+ *   Author(s): Steve French <sfrench@us.ibm.com>
+ *              Namjae Jeon <linkinjeon@kernel.org>
+ *
+ */
+
+#ifndef _COMMON_SMB1_PDU_H
+#define _COMMON_SMB1_PDU_H
+
+#define SMB1_PROTO_NUMBER		cpu_to_le32(0x424d53ff)
+
+/*
+ * See MS-CIFS 2.2.3.1
+ *     MS-SMB 2.2.3.1
+ */
+struct smb_hdr {
+	__u8 Protocol[4];
+	__u8 Command;
+	union {
+		struct {
+			__u8 ErrorClass;
+			__u8 Reserved;
+			__le16 Error;
+		} __packed DosError;
+		__le32 CifsError;
+	} __packed Status;
+	__u8 Flags;
+	__le16 Flags2;		/* note: le */
+	__le16 PidHigh;
+	union {
+		struct {
+			__le32 SequenceNumber;  /* le */
+			__u32 Reserved; /* zero */
+		} __packed Sequence;
+		__u8 SecuritySignature[8];	/* le */
+	} __packed Signature;
+	__u8 pad[2];
+	__u16 Tid;
+	__le16 Pid;
+	__u16 Uid;
+	__le16 Mid;
+	__u8 WordCount;
+} __packed;
+
+/* See MS-CIFS 2.2.4.52.1 */
+typedef struct smb_negotiate_req {
+	struct smb_hdr hdr;	/* wct = 0 */
+	__le16 ByteCount;
+	unsigned char DialectsArray[];
+} __packed SMB_NEGOTIATE_REQ;
+
+#endif /* _COMMON_SMB1_PDU_H */
diff --git a/fs/smb/common/smb2pdu.h b/fs/smb/common/smb2pdu.h
new file mode 100644
index 000000000..f9a8862cb
--- /dev/null
+++ b/fs/smb/common/smb2pdu.h
@@ -0,0 +1,1836 @@
+/* SPDX-License-Identifier: LGPL-2.1 */
+#ifndef _COMMON_SMB2PDU_H
+#define _COMMON_SMB2PDU_H
+
+#include <linux/types.h>
+#include <linux/build_bug.h>
+
+/*
+ * Note that, due to trying to use names similar to the protocol specifications,
+ * there are many mixed case field names in the structures below.  Although
+ * this does not match typical Linux kernel style, it is necessary to be
+ * able to match against the protocol specification.
+ *
+ * SMB2 commands
+ * Some commands have minimal (wct=0,bcc=0), or uninteresting, responses
+ * (ie no useful data other than the SMB error code itself) and are marked such.
+ * Knowing this helps avoid response buffer allocations and copy in some cases.
+ */
+
+/* List of commands in host endian */
+#define SMB2_NEGOTIATE_HE	0x0000
+#define SMB2_SESSION_SETUP_HE	0x0001
+#define SMB2_LOGOFF_HE		0x0002 /* trivial request/resp */
+#define SMB2_TREE_CONNECT_HE	0x0003
+#define SMB2_TREE_DISCONNECT_HE	0x0004 /* trivial req/resp */
+#define SMB2_CREATE_HE		0x0005
+#define SMB2_CLOSE_HE		0x0006
+#define SMB2_FLUSH_HE		0x0007 /* trivial resp */
+#define SMB2_READ_HE		0x0008
+#define SMB2_WRITE_HE		0x0009
+#define SMB2_LOCK_HE		0x000A
+#define SMB2_IOCTL_HE		0x000B
+#define SMB2_CANCEL_HE		0x000C
+#define SMB2_ECHO_HE		0x000D
+#define SMB2_QUERY_DIRECTORY_HE	0x000E
+#define SMB2_CHANGE_NOTIFY_HE	0x000F
+#define SMB2_QUERY_INFO_HE	0x0010
+#define SMB2_SET_INFO_HE	0x0011
+#define SMB2_OPLOCK_BREAK_HE	0x0012
+#define SMB2_SERVER_TO_CLIENT_NOTIFICATION 0x0013
+
+/* The same list in little endian */
+#define SMB2_NEGOTIATE		cpu_to_le16(SMB2_NEGOTIATE_HE)
+#define SMB2_SESSION_SETUP	cpu_to_le16(SMB2_SESSION_SETUP_HE)
+#define SMB2_LOGOFF		cpu_to_le16(SMB2_LOGOFF_HE)
+#define SMB2_TREE_CONNECT	cpu_to_le16(SMB2_TREE_CONNECT_HE)
+#define SMB2_TREE_DISCONNECT	cpu_to_le16(SMB2_TREE_DISCONNECT_HE)
+#define SMB2_CREATE		cpu_to_le16(SMB2_CREATE_HE)
+#define SMB2_CLOSE		cpu_to_le16(SMB2_CLOSE_HE)
+#define SMB2_FLUSH		cpu_to_le16(SMB2_FLUSH_HE)
+#define SMB2_READ		cpu_to_le16(SMB2_READ_HE)
+#define SMB2_WRITE		cpu_to_le16(SMB2_WRITE_HE)
+#define SMB2_LOCK		cpu_to_le16(SMB2_LOCK_HE)
+#define SMB2_IOCTL		cpu_to_le16(SMB2_IOCTL_HE)
+#define SMB2_CANCEL		cpu_to_le16(SMB2_CANCEL_HE)
+#define SMB2_ECHO		cpu_to_le16(SMB2_ECHO_HE)
+#define SMB2_QUERY_DIRECTORY	cpu_to_le16(SMB2_QUERY_DIRECTORY_HE)
+#define SMB2_CHANGE_NOTIFY	cpu_to_le16(SMB2_CHANGE_NOTIFY_HE)
+#define SMB2_QUERY_INFO		cpu_to_le16(SMB2_QUERY_INFO_HE)
+#define SMB2_SET_INFO		cpu_to_le16(SMB2_SET_INFO_HE)
+#define SMB2_OPLOCK_BREAK	cpu_to_le16(SMB2_OPLOCK_BREAK_HE)
+
+#define SMB2_INTERNAL_CMD	cpu_to_le16(0xFFFF)
+
+#define NUMBER_OF_SMB2_COMMANDS	0x0013
+
+/*
+ * Size of the session key (crypto key encrypted with the password
+ */
+#define SMB2_NTLMV2_SESSKEY_SIZE	16
+#define SMB2_SIGNATURE_SIZE		16
+#define SMB2_HMACSHA256_SIZE		32
+#define SMB2_CMACAES_SIZE		16
+#define SMB3_GCM128_CRYPTKEY_SIZE	16
+#define SMB3_GCM256_CRYPTKEY_SIZE	32
+
+/*
+ * Size of the smb3 encryption/decryption keys
+ * This size is big enough to store any cipher key types.
+ */
+#define SMB3_ENC_DEC_KEY_SIZE		32
+
+/*
+ * Size of the smb3 signing key
+ */
+#define SMB3_SIGN_KEY_SIZE		16
+
+#define CIFS_CLIENT_CHALLENGE_SIZE	8
+
+/* Maximum buffer size value we can send with 1 credit */
+#define SMB2_MAX_BUFFER_SIZE 65536
+
+/*
+ * The default wsize is 1M for SMB2 (and for some CIFS cases).
+ * find_get_pages seems to return a maximum of 256
+ * pages in a single call. With PAGE_SIZE == 4k, this means we can
+ * fill a single wsize request with a single call.
+ */
+#define SMB3_DEFAULT_IOSIZE (4 * 1024 * 1024)
+
+/* According to MS-SMB2 specification The minimum recommended value is 65536.*/
+#define CIFS_MIN_DEFAULT_IOSIZE (65536)
+
+/*
+ * SMB2 Header Definition
+ *
+ * "MBZ" :  Must be Zero
+ * "BB"  :  BugBug, Something to check/review/analyze later
+ * "PDU" :  "Protocol Data Unit" (ie a network "frame")
+ *
+ */
+
+#define __SMB2_HEADER_STRUCTURE_SIZE	64
+#define SMB2_HEADER_STRUCTURE_SIZE				\
+	cpu_to_le16(__SMB2_HEADER_STRUCTURE_SIZE)
+
+#define SMB2_PROTO_NUMBER cpu_to_le32(0x424d53fe)
+#define SMB2_TRANSFORM_PROTO_NUM cpu_to_le32(0x424d53fd)
+#define SMB2_COMPRESSION_TRANSFORM_ID cpu_to_le32(0x424d53fc)
+
+/*
+ *	SMB2 flag definitions
+ */
+#define SMB2_FLAGS_SERVER_TO_REDIR	cpu_to_le32(0x00000001)
+#define SMB2_FLAGS_ASYNC_COMMAND	cpu_to_le32(0x00000002)
+#define SMB2_FLAGS_RELATED_OPERATIONS	cpu_to_le32(0x00000004)
+#define SMB2_FLAGS_SIGNED		cpu_to_le32(0x00000008)
+#define SMB2_FLAGS_PRIORITY_MASK	cpu_to_le32(0x00000070) /* SMB3.1.1 */
+#define SMB2_FLAGS_DFS_OPERATIONS	cpu_to_le32(0x10000000)
+#define SMB2_FLAGS_REPLAY_OPERATION	cpu_to_le32(0x20000000) /* SMB3 & up */
+
+/*
+ *	Definitions for SMB2 Protocol Data Units (network frames)
+ *
+ *  See MS-SMB2.PDF specification for protocol details.
+ *  The Naming convention is the lower case version of the SMB2
+ *  command code name for the struct. Note that structures must be packed.
+ *
+ */
+
+/* See MS-SMB2 section 2.2.1 */
+struct smb2_hdr {
+	__le32 ProtocolId;	/* 0xFE 'S' 'M' 'B' */
+	__le16 StructureSize;	/* 64 */
+	__le16 CreditCharge;	/* MBZ */
+	__le32 Status;		/* Error from server */
+	__le16 Command;
+	__le16 CreditRequest;	/* CreditResponse */
+	__le32 Flags;
+	__le32 NextCommand;
+	__le64 MessageId;
+	union {
+		struct {
+			__le32 ProcessId;
+			__le32  TreeId;
+		} __packed SyncId;
+		__le64  AsyncId;
+	} __packed Id;
+	__le64  SessionId;
+	__u8   Signature[16];
+} __packed;
+
+struct smb3_hdr_req {
+	__le32 ProtocolId;	/* 0xFE 'S' 'M' 'B' */
+	__le16 StructureSize;	/* 64 */
+	__le16 CreditCharge;	/* MBZ */
+	__le16 ChannelSequence; /* See MS-SMB2 3.2.4.1 and 3.2.7.1 */
+	__le16 Reserved;
+	__le16 Command;
+	__le16 CreditRequest;	/* CreditResponse */
+	__le32 Flags;
+	__le32 NextCommand;
+	__le64 MessageId;
+	union {
+		struct {
+			__le32 ProcessId;
+			__le32  TreeId;
+		} __packed SyncId;
+		__le64  AsyncId;
+	} __packed Id;
+	__le64  SessionId;
+	__u8   Signature[16];
+} __packed;
+
+struct smb2_pdu {
+	struct smb2_hdr hdr;
+	__le16 StructureSize2; /* size of wct area (varies, request specific) */
+} __packed;
+
+#define SMB2_ERROR_STRUCTURE_SIZE2	9
+#define SMB2_ERROR_STRUCTURE_SIZE2_LE	cpu_to_le16(SMB2_ERROR_STRUCTURE_SIZE2)
+
+struct smb2_err_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;
+	__u8   ErrorContextCount;
+	__u8   Reserved;
+	__le32 ByteCount;  /* even if zero, at least one byte follows */
+	__u8   ErrorData[];  /* variable length */
+} __packed;
+
+#define SMB3_AES_CCM_NONCE 11
+#define SMB3_AES_GCM_NONCE 12
+
+/* Transform flags (for 3.0 dialect this flag indicates CCM */
+#define TRANSFORM_FLAG_ENCRYPTED	0x0001
+struct smb2_transform_hdr {
+	__le32 ProtocolId;	/* 0xFD 'S' 'M' 'B' */
+	__u8   Signature[16];
+	__u8   Nonce[16];
+	__le32 OriginalMessageSize;
+	__u16  Reserved1;
+	__le16 Flags; /* EncryptionAlgorithm for 3.0, enc enabled for 3.1.1 */
+	__le64  SessionId;
+} __packed;
+
+/*
+ * These are simplified versions from the spec, as we don't need a fully fledged
+ * form of both unchained and chained structs.
+ *
+ * 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.
+ */
+#define SMB2_COMPRESSION_FLAG_NONE	0x0000
+#define SMB2_COMPRESSION_FLAG_CHAINED	0x0001
+
+struct smb2_compression_hdr {
+	__le32 ProtocolId; /* 0xFC 'S' 'M' 'B' */
+	__le32 OriginalCompressedSegmentSize;
+	__le16 CompressionAlgorithm;
+	__le16 Flags;
+	__le32 Offset; /* this is the size of the uncompressed SMB2 header below */
+	/* uncompressed SMB2 header (READ or WRITE) goes here */
+	/* compressed data goes here */
+} __packed;
+
+/*
+ * ... OTOH, set compression payload header to always have OriginalPayloadSize
+ * as it's easier to pass the struct size minus sizeof(OriginalPayloadSize)
+ * than to juggle around the header/data memory.
+ */
+struct smb2_compression_payload_hdr {
+	__le16	CompressionAlgorithm;
+	__le16	Flags;
+	__le32	Length; /* length of compressed playload including field below if present */
+	__le32 OriginalPayloadSize; /* accounted when LZNT1, LZ77, LZ77+Huffman */
+} __packed;
+
+struct smb2_compression_pattern_v1 {
+	__u8	Pattern;
+	__u8	Reserved1;
+	__le16	Reserved2;
+	__le32	Repetitions;
+} __packed;
+
+/* See MS-SMB2 section 2.2.9.2 */
+/* Context Types */
+#define SMB2_RESERVED_TREE_CONNECT_CONTEXT_ID 0x0000
+#define SMB2_REMOTED_IDENTITY_TREE_CONNECT_CONTEXT_ID cpu_to_le16(0x0001)
+
+struct tree_connect_contexts {
+	__le16 ContextType;
+	__le16 DataLength;
+	__le32 Reserved;
+	__u8   Data[];
+} __packed;
+
+/* Remoted identity tree connect context structures - see MS-SMB2 2.2.9.2.1 */
+struct smb3_blob_data {
+	__le16 BlobSize;
+	__u8   BlobData[];
+} __packed;
+
+/* Valid values for Attr */
+#define SE_GROUP_MANDATORY		0x00000001
+#define SE_GROUP_ENABLED_BY_DEFAULT	0x00000002
+#define SE_GROUP_ENABLED		0x00000004
+#define SE_GROUP_OWNER			0x00000008
+#define SE_GROUP_USE_FOR_DENY_ONLY	0x00000010
+#define SE_GROUP_INTEGRITY		0x00000020
+#define SE_GROUP_INTEGRITY_ENABLED	0x00000040
+#define SE_GROUP_RESOURCE		0x20000000
+#define SE_GROUP_LOGON_ID		0xC0000000
+
+struct sid_array_data {
+	__le16 SidAttrCount;
+	/* SidAttrList - array of sid_attr_data structs */
+} __packed;
+
+/* struct sid_attr_data is SidData array in BlobData format then le32 Attr */
+struct sid_attr_data {
+	__le16 BlobSize;
+	__u8 BlobData[];
+	/* __le32 Attr */
+} __packed;
+
+/*
+ * struct privilege_data is the same as BLOB_DATA - see MS-SMB2 2.2.9.2.1.5
+ * but with size of LUID_ATTR_DATA struct and BlobData set to LUID_ATTR DATA
+ */
+
+struct privilege_array_data {
+	__le16 PrivilegeCount;
+	/* array of privilege_data structs */
+} __packed;
+
+struct remoted_identity_tcon_context {
+	__le16 TicketType; /* must be 0x0001 */
+	__le16 TicketSize; /* total size of this struct */
+	__le16 User; /* offset to SID_ATTR_DATA struct with user info */
+	__le16 UserName; /* offset to null terminated Unicode username string */
+	__le16 Domain; /* offset to null terminated Unicode domain name */
+	__le16 Groups; /* offset to SID_ARRAY_DATA struct with group info */
+	__le16 RestrictedGroups; /* similar to above */
+	__le16 Privileges; /* offset to PRIVILEGE_ARRAY_DATA struct */
+	__le16 PrimaryGroup; /* offset to SID_ARRAY_DATA struct */
+	__le16 Owner; /* offset to BLOB_DATA struct */
+	__le16 DefaultDacl; /* offset to BLOB_DATA struct */
+	__le16 DeviceGroups; /* offset to SID_ARRAY_DATA struct */
+	__le16 UserClaims; /* offset to BLOB_DATA struct */
+	__le16 DeviceClaims; /* offset to BLOB_DATA struct */
+	__u8   TicketInfo[]; /* variable length buf - remoted identity data */
+} __packed;
+
+struct smb2_tree_connect_req_extension {
+	__le32 TreeConnectContextOffset;
+	__le16 TreeConnectContextCount;
+	__u8  Reserved[10];
+	__u8  PathName[]; /* variable sized array */
+	/* followed by array of TreeConnectContexts */
+} __packed;
+
+/* Flags/Reserved for SMB3.1.1 */
+#define SMB2_TREE_CONNECT_FLAG_CLUSTER_RECONNECT cpu_to_le16(0x0001)
+#define SMB2_TREE_CONNECT_FLAG_REDIRECT_TO_OWNER cpu_to_le16(0x0002)
+#define SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT cpu_to_le16(0x0004)
+
+struct smb2_tree_connect_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 9 */
+	__le16 Flags;		/* Flags in SMB3.1.1 */
+	__le16 PathOffset;
+	__le16 PathLength;
+	__u8   Buffer[];	/* variable length */
+} __packed;
+
+/* Possible ShareType values */
+#define SMB2_SHARE_TYPE_DISK	0x01
+#define SMB2_SHARE_TYPE_PIPE	0x02
+#define	SMB2_SHARE_TYPE_PRINT	0x03
+
+/*
+ * Possible ShareFlags - exactly one and only one of the first 4 caching flags
+ * must be set (any of the remaining, SHI1005, flags may be set individually
+ * or in combination.
+ */
+#define SMB2_SHAREFLAG_MANUAL_CACHING			0x00000000
+#define SMB2_SHAREFLAG_AUTO_CACHING			0x00000010
+#define SMB2_SHAREFLAG_VDO_CACHING			0x00000020
+#define SMB2_SHAREFLAG_NO_CACHING			0x00000030
+#define SHI1005_FLAGS_DFS				0x00000001
+#define SHI1005_FLAGS_DFS_ROOT				0x00000002
+#define SMB2_SHAREFLAG_RESTRICT_EXCLUSIVE_OPENS		0x00000100
+#define SMB2_SHAREFLAG_FORCE_SHARED_DELETE		0x00000200
+#define SMB2_SHAREFLAG_ALLOW_NAMESPACE_CACHING		0x00000400
+#define SMB2_SHAREFLAG_ACCESS_BASED_DIRECTORY_ENUM	0x00000800
+#define SMB2_SHAREFLAG_FORCE_LEVELII_OPLOCK		0x00001000
+#define SMB2_SHAREFLAG_ENABLE_HASH_V1			0x00002000
+#define SMB2_SHAREFLAG_ENABLE_HASH_V2			0x00004000
+#define SMB2_SHAREFLAG_ENCRYPT_DATA			0x00008000
+#define SHI1005_FLAGS_ENCRYPT_DATA			SMB2_SHAREFLAG_ENCRYPT_DATA
+#define SMB2_SHAREFLAG_IDENTITY_REMOTING		0x00040000 /* 3.1.1 */
+#define SMB2_SHAREFLAG_COMPRESS_DATA			0x00100000 /* 3.1.1 */
+#define SMB2_SHAREFLAG_ISOLATED_TRANSPORT		0x00200000
+#define SHI1005_FLAGS_ALL				0x0034FF33
+
+/* Possible share capabilities */
+#define SMB2_SHARE_CAP_DFS	cpu_to_le32(0x00000008) /* all dialects */
+#define SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY cpu_to_le32(0x00000010) /* 3.0 */
+#define SMB2_SHARE_CAP_SCALEOUT	cpu_to_le32(0x00000020) /* 3.0 */
+#define SMB2_SHARE_CAP_CLUSTER	cpu_to_le32(0x00000040) /* 3.0 */
+#define SMB2_SHARE_CAP_ASYMMETRIC cpu_to_le32(0x00000080) /* 3.02 */
+#define SMB2_SHARE_CAP_REDIRECT_TO_OWNER cpu_to_le32(0x00000100) /* 3.1.1 */
+
+struct smb2_tree_connect_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 16 */
+	__u8   ShareType;	/* see below */
+	__u8   Reserved;
+	__le32 ShareFlags;	/* see below */
+	__le32 Capabilities;	/* see below */
+	__le32 MaximalAccess;
+} __packed;
+
+struct smb2_tree_disconnect_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 4 */
+	__le16 Reserved;
+} __packed;
+
+struct smb2_tree_disconnect_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 4 */
+	__le16 Reserved;
+} __packed;
+
+
+/*
+ * SMB2_NEGOTIATE_PROTOCOL  See MS-SMB2 section 2.2.3
+ */
+/* SecurityMode flags */
+#define	SMB2_NEGOTIATE_SIGNING_ENABLED     0x0001
+#define	SMB2_NEGOTIATE_SIGNING_ENABLED_LE  cpu_to_le16(0x0001)
+#define SMB2_NEGOTIATE_SIGNING_REQUIRED	   0x0002
+#define SMB2_NEGOTIATE_SIGNING_REQUIRED_LE cpu_to_le16(0x0002)
+#define SMB2_SEC_MODE_FLAGS_ALL            0x0003
+
+/* Capabilities flags */
+#define SMB2_GLOBAL_CAP_DFS		0x00000001
+#define SMB2_GLOBAL_CAP_LEASING		0x00000002 /* Resp only New to SMB2.1 */
+#define SMB2_GLOBAL_CAP_LARGE_MTU	0x00000004 /* Resp only New to SMB2.1 */
+#define SMB2_GLOBAL_CAP_MULTI_CHANNEL	0x00000008 /* New to SMB3 */
+#define SMB2_GLOBAL_CAP_PERSISTENT_HANDLES 0x00000010 /* New to SMB3 */
+#define SMB2_GLOBAL_CAP_DIRECTORY_LEASING  0x00000020 /* New to SMB3 */
+#define SMB2_GLOBAL_CAP_ENCRYPTION	0x00000040 /* New to SMB3 */
+#define SMB2_GLOBAL_CAP_NOTIFICATIONS	0x00000080 /* New to SMB3.1.1 */
+/* Internal types */
+#define SMB2_NT_FIND			0x00100000
+#define SMB2_LARGE_FILES		0x00200000
+
+#define SMB2_CLIENT_GUID_SIZE		16
+#define SMB2_CREATE_GUID_SIZE		16
+
+/* Dialects */
+#define SMB10_PROT_ID  0x0000 /* local only, not sent on wire w/CIFS negprot */
+#define SMB20_PROT_ID  0x0202
+#define SMB21_PROT_ID  0x0210
+#define SMB2X_PROT_ID  0x02FF
+#define SMB30_PROT_ID  0x0300
+#define SMB302_PROT_ID 0x0302
+#define SMB311_PROT_ID 0x0311
+#define BAD_PROT_ID    0xFFFF
+
+#define SMB311_SALT_SIZE			32
+/* Hash Algorithm Types */
+#define SMB2_PREAUTH_INTEGRITY_SHA512	cpu_to_le16(0x0001)
+#define SMB2_PREAUTH_HASH_SIZE 64
+
+/* Negotiate Contexts - ContextTypes. See MS-SMB2 section 2.2.3.1 for details */
+#define SMB2_PREAUTH_INTEGRITY_CAPABILITIES	cpu_to_le16(1)
+#define SMB2_ENCRYPTION_CAPABILITIES		cpu_to_le16(2)
+#define SMB2_COMPRESSION_CAPABILITIES		cpu_to_le16(3)
+#define SMB2_NETNAME_NEGOTIATE_CONTEXT_ID	cpu_to_le16(5)
+#define SMB2_TRANSPORT_CAPABILITIES		cpu_to_le16(6)
+#define SMB2_RDMA_TRANSFORM_CAPABILITIES	cpu_to_le16(7)
+#define SMB2_SIGNING_CAPABILITIES		cpu_to_le16(8)
+#define SMB2_POSIX_EXTENSIONS_AVAILABLE		cpu_to_le16(0x100)
+
+struct smb2_neg_context {
+	__le16	ContextType;
+	__le16	DataLength;
+	__le32	Reserved;
+	/* Followed by array of data. NOTE: some servers require padding to 8 byte boundary */
+} __packed;
+
+/*
+ * SaltLength that the server send can be zero, so the only three required
+ * fields (all __le16) end up six bytes total, so the minimum context data len
+ * in the response is six bytes which accounts for
+ *
+ *      HashAlgorithmCount, SaltLength, and 1 HashAlgorithm.
+ */
+#define MIN_PREAUTH_CTXT_DATA_LEN 6
+
+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)
+#define SMB2_ENCRYPTION_AES256_CCM      cpu_to_le16(0x0003)
+#define SMB2_ENCRYPTION_AES256_GCM      cpu_to_le16(0x0004)
+
+/* Min encrypt context data is one cipher so 2 bytes + 2 byte count field */
+#define MIN_ENCRYPT_CTXT_DATA_LEN	4
+struct smb2_encryption_neg_context {
+	__le16	ContextType; /* 2 */
+	__le16	DataLength;
+	__le32	Reserved;
+	/* CipherCount usually 2, but can be 3 when AES256-GCM enabled */
+	__le16	CipherCount; /* AES128-GCM and AES128-CCM by default */
+	__le16	Ciphers[];
+} __packed;
+
+/* See MS-SMB2 2.2.3.1.3 */
+#define SMB3_COMPRESS_NONE	cpu_to_le16(0x0000)
+#define SMB3_COMPRESS_LZNT1	cpu_to_le16(0x0001)
+#define SMB3_COMPRESS_LZ77	cpu_to_le16(0x0002)
+#define SMB3_COMPRESS_LZ77_HUFF	cpu_to_le16(0x0003)
+/* Pattern scanning algorithm See MS-SMB2 3.1.4.4.1 */
+#define SMB3_COMPRESS_PATTERN	cpu_to_le16(0x0004) /* Pattern_V1 */
+#define SMB3_COMPRESS_LZ4	cpu_to_le16(0x0005)
+/* Account for NONE for easier array indexing */
+#define SMB3_COMPRESS_MAX_ALGS	6
+
+/* Compression Flags */
+#define SMB2_COMPRESSION_CAPABILITIES_FLAG_NONE		cpu_to_le32(0x00000000)
+#define SMB2_COMPRESSION_CAPABILITIES_FLAG_CHAINED	cpu_to_le32(0x00000001)
+
+struct smb2_compression_capabilities_context {
+	__le16	ContextType; /* 3 */
+	__le16  DataLength;
+	__le32	Reserved;
+	__le16	CompressionAlgorithmCount;
+	__le16	Padding;
+	__le32	Flags;
+	__le16	CompressionAlgorithms[4];
+} __packed;
+
+/*
+ * For smb2_netname_negotiate_context_id See MS-SMB2 2.2.3.1.4.
+ * Its struct simply contains NetName, an array of Unicode characters
+ */
+struct smb2_netname_neg_context {
+	__le16	ContextType; /* 5 */
+	__le16	DataLength;
+	__le32	Reserved;
+	__le16	NetName[]; /* hostname of target converted to UCS-2 */
+} __packed;
+
+/*
+ * For smb2_transport_capabilities context see MS-SMB2 2.2.3.1.5
+ * and 2.2.4.1.5
+ */
+
+/* Flags */
+#define SMB2_ACCEPT_TRANSPORT_LEVEL_SECURITY	0x00000001
+
+struct smb2_transport_capabilities_context {
+	__le16	ContextType; /* 6 */
+	__le16  DataLength;
+	__u32	Reserved;
+	__le32	Flags;
+	__u32	Pad;
+} __packed;
+
+/*
+ * For rdma transform capabilities context see MS-SMB2 2.2.3.1.6
+ * and 2.2.4.1.6
+ */
+
+/* RDMA Transform IDs */
+#define SMB2_RDMA_TRANSFORM_NONE	0x0000
+#define SMB2_RDMA_TRANSFORM_ENCRYPTION	0x0001
+#define SMB2_RDMA_TRANSFORM_SIGNING	0x0002
+
+struct smb2_rdma_transform_capabilities_context {
+	__le16	ContextType; /* 7 */
+	__le16  DataLength;
+	__u32	Reserved;
+	__le16	TransformCount;
+	__u16	Reserved1;
+	__u32	Reserved2;
+	__le16	RDMATransformIds[];
+} __packed;
+
+/*
+ * For signing capabilities context see MS-SMB2 2.2.3.1.7
+ * and 2.2.4.1.7
+ */
+
+/* Signing algorithms */
+#define SIGNING_ALG_HMAC_SHA256    0
+#define SIGNING_ALG_HMAC_SHA256_LE cpu_to_le16(0)
+#define SIGNING_ALG_AES_CMAC       1
+#define SIGNING_ALG_AES_CMAC_LE    cpu_to_le16(1)
+#define SIGNING_ALG_AES_GMAC       2
+#define SIGNING_ALG_AES_GMAC_LE    cpu_to_le16(2)
+
+struct smb2_signing_capabilities {
+	__le16	ContextType; /* 8 */
+	__le16	DataLength;
+	__le32	Reserved;
+	__le16	SigningAlgorithmCount;
+	__le16	SigningAlgorithms[];
+	/*  Followed by padding to 8 byte boundary (required by some servers) */
+} __packed;
+
+#define POSIX_CTXT_DATA_LEN	16
+struct smb2_posix_neg_context {
+	__le16	ContextType; /* 0x100 */
+	__le16	DataLength;
+	__le32	Reserved;
+	__u8	Name[16]; /* POSIX ctxt GUID 93AD25509CB411E7B42383DE968BCD7C */
+} __packed;
+
+struct smb2_negotiate_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 36 */
+	__le16 DialectCount;
+	__le16 SecurityMode;
+	__le16 Reserved;	/* MBZ */
+	__le32 Capabilities;
+	__u8   ClientGUID[SMB2_CLIENT_GUID_SIZE];
+	/* 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[];
+} __packed;
+
+struct smb2_negotiate_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 65 */
+	__le16 SecurityMode;
+	__le16 DialectRevision;
+	__le16 NegotiateContextCount;	/* Prior to SMB3.1.1 was Reserved & MBZ */
+	__u8   ServerGUID[16];
+	__le32 Capabilities;
+	__le32 MaxTransactSize;
+	__le32 MaxReadSize;
+	__le32 MaxWriteSize;
+	__le64 SystemTime;	/* MBZ */
+	__le64 ServerStartTime;
+	__le16 SecurityBufferOffset;
+	__le16 SecurityBufferLength;
+	__le32 NegotiateContextOffset;	/* Pre:SMB3.1.1 was reserved/ignored */
+	__u8   Buffer[];	/* variable length GSS security buffer */
+} __packed;
+
+
+/*
+ * SMB2_SESSION_SETUP  See MS-SMB2 section 2.2.5
+ */
+/* 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   Flags;
+	__u8   SecurityMode;
+	__le32 Capabilities;
+	__le32 Channel;
+	__le16 SecurityBufferOffset;
+	__le16 SecurityBufferLength;
+	__le64 PreviousSessionId;
+	__u8   Buffer[];	/* variable length GSS security buffer */
+} __packed;
+
+/* Currently defined SessionFlags */
+#define SMB2_SESSION_FLAG_IS_GUEST        0x0001
+#define SMB2_SESSION_FLAG_IS_GUEST_LE     cpu_to_le16(0x0001)
+#define SMB2_SESSION_FLAG_IS_NULL         0x0002
+#define SMB2_SESSION_FLAG_IS_NULL_LE      cpu_to_le16(0x0002)
+#define SMB2_SESSION_FLAG_ENCRYPT_DATA    0x0004
+#define SMB2_SESSION_FLAG_ENCRYPT_DATA_LE cpu_to_le16(0x0004)
+
+struct smb2_sess_setup_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 9 */
+	__le16 SessionFlags;
+	__le16 SecurityBufferOffset;
+	__le16 SecurityBufferLength;
+	__u8   Buffer[];	/* variable length GSS security buffer */
+} __packed;
+
+
+/*
+ * SMB2_LOGOFF  See MS-SMB2 section 2.2.7
+ */
+struct smb2_logoff_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 4 */
+	__le16 Reserved;
+} __packed;
+
+struct smb2_logoff_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 4 */
+	__le16 Reserved;
+} __packed;
+
+
+/*
+ * SMB2_CLOSE  See MS-SMB2 section 2.2.15
+ */
+/* Currently defined values for close flags */
+#define SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB	cpu_to_le16(0x0001)
+struct smb2_close_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 24 */
+	__le16 Flags;
+	__le32 Reserved;
+	__u64  PersistentFileId; /* opaque endianness */
+	__u64  VolatileFileId; /* opaque endianness */
+} __packed;
+
+/*
+ * Maximum size of a SMB2_CLOSE response is 64 (smb2 header) + 60 (data)
+ */
+#define MAX_SMB2_CLOSE_RESPONSE_SIZE 124
+
+struct smb2_close_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* 60 */
+	__le16 Flags;
+	__le32 Reserved;
+	struct_group_attr(network_open_info, __packed,
+		__le64 CreationTime;
+		__le64 LastAccessTime;
+		__le64 LastWriteTime;
+		__le64 ChangeTime;
+		/* Beginning of FILE_STANDARD_INFO equivalent */
+		__le64 AllocationSize;
+		__le64 EndOfFile;
+		__le32 Attributes;
+	);
+} __packed;
+
+
+/*
+ * SMB2_READ  See MS-SMB2 section 2.2.19
+ */
+/* For read request Flags field below, following flag is defined for SMB3.02 */
+#define SMB2_READFLAG_READ_UNBUFFERED	0x01
+#define SMB2_READFLAG_REQUEST_COMPRESSED 0x02 /* See MS-SMB2 2.2.19 */
+
+/* Channel field for read and write: exactly one of following flags can be set*/
+#define SMB2_CHANNEL_NONE               cpu_to_le32(0x00000000)
+#define SMB2_CHANNEL_RDMA_V1            cpu_to_le32(0x00000001)
+#define SMB2_CHANNEL_RDMA_V1_INVALIDATE cpu_to_le32(0x00000002)
+#define SMB2_CHANNEL_RDMA_TRANSFORM     cpu_to_le32(0x00000003)
+
+/* See MS-SMB2 2.2.43. */
+struct smb2_rdma_transform {
+	__le16 RdmaDescriptorOffset;
+	__le16 RdmaDescriptorLength;
+	__le32 Channel;
+	__le16 TransformCount;
+	__le16 Reserved1;
+	__le32 Reserved2;
+} __packed;
+
+#define SMB2_RDMA_TRANSFORM_TYPE_ENCRYPTION	0x0001
+#define SMB2_RDMA_TRANSFORM_TYPE_SIGNING	0x0002
+
+struct smb2_rdma_crypto_transform {
+	__le16 TransformType;
+	__le16 SignatureLength;
+	__le16 NonceLength;
+	__le16 Reserved;
+	__u8 Signature[];
+	/* Followed by Nonce[] and optional alignment padding. */
+} __packed;
+
+/* SMB2 read request without RFC1001 length at the beginning */
+struct smb2_read_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 49 */
+	__u8   Padding; /* offset from start of SMB2 header to place read */
+	__u8   Flags; /* MBZ unless SMB3.02 or later */
+	__le32 Length;
+	__le64 Offset;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+	__le32 MinimumCount;
+	__le32 Channel; /* MBZ except for SMB3 or later */
+	__le32 RemainingBytes;
+	__le16 ReadChannelInfoOffset;
+	__le16 ReadChannelInfoLength;
+	__u8   Buffer[];
+} __packed;
+
+/* Read flags */
+#define SMB2_READFLAG_RESPONSE_NONE            cpu_to_le32(0x00000000)
+#define SMB2_READFLAG_RESPONSE_RDMA_TRANSFORM  cpu_to_le32(0x00000001)
+
+struct smb2_read_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 17 */
+	__u8   DataOffset;
+	__u8   Reserved;
+	__le32 DataLength;
+	__le32 DataRemaining;
+	__le32 Flags;
+	__u8   Buffer[];
+} __packed;
+
+
+/*
+ * SMB2_WRITE  See MS-SMB2 section 2.2.21
+ */
+/* For write request Flags field below the following flags are defined: */
+#define SMB2_WRITEFLAG_WRITE_THROUGH	0x00000001	/* SMB2.1 or later */
+#define SMB2_WRITEFLAG_WRITE_UNBUFFERED	0x00000002	/* SMB3.02 or later */
+
+struct smb2_write_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 49 */
+	__le16 DataOffset; /* offset from start of SMB2 header to write data */
+	__le32 Length;
+	__le64 Offset;
+	__u64  PersistentFileId; /* opaque endianness */
+	__u64  VolatileFileId; /* opaque endianness */
+	__le32 Channel; /* MBZ unless SMB3.02 or later */
+	__le32 RemainingBytes;
+	__le16 WriteChannelInfoOffset;
+	__le16 WriteChannelInfoLength;
+	__le32 Flags;
+	__u8   Buffer[];
+} __packed;
+
+struct smb2_write_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 17 */
+	__u8   DataOffset;
+	__u8   Reserved;
+	__le32 DataLength;
+	__le32 DataRemaining;
+	__u32  Reserved2;
+	__u8   Buffer[];
+} __packed;
+
+
+/*
+ * SMB2_FLUSH  See MS-SMB2 section 2.2.17
+ */
+struct smb2_flush_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 24 */
+	__le16 Reserved1;
+	__le32 Reserved2;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+} __packed;
+
+struct smb2_flush_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;
+	__le16 Reserved;
+} __packed;
+
+#define SMB2_LOCKFLAG_SHARED		0x0001
+#define SMB2_LOCKFLAG_EXCLUSIVE		0x0002
+#define SMB2_LOCKFLAG_UNLOCK		0x0004
+#define SMB2_LOCKFLAG_FAIL_IMMEDIATELY	0x0010
+#define SMB2_LOCKFLAG_MASK		0x0007
+
+struct smb2_lock_element {
+	__le64 Offset;
+	__le64 Length;
+	__le32 Flags;
+	__le32 Reserved;
+} __packed;
+
+struct smb2_lock_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 48 */
+	__le16 LockCount;
+	/*
+	 * The least significant four bits are the lock sequence number. The
+	 * other 28 bits are the index (0 to 64). See MS-SMB2 2.2.26.
+	 */
+	__le32 LockSequenceNumber;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+	/* Followed by at least one */
+	union {
+		struct smb2_lock_element lock;
+		DECLARE_FLEX_ARRAY(struct smb2_lock_element, locks);
+	};
+} __packed;
+
+struct smb2_lock_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 4 */
+	__le16 Reserved;
+} __packed;
+
+struct smb2_echo_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 4 */
+	__u16  Reserved;
+} __packed;
+
+struct smb2_echo_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 4 */
+	__u16  Reserved;
+} __packed;
+
+/*
+ * Valid FileInformation classes for query directory
+ *
+ * Note that these are a subset of the (file) QUERY_INFO levels defined
+ * later in this file (but since QUERY_DIRECTORY uses equivalent numbers
+ * we do not redefine them here)
+ *
+ * FileDirectoryInfomation		0x01
+ * FileFullDirectoryInformation		0x02
+ * FileIdFullDirectoryInformation	0x26
+ * FileBothDirectoryInformation		0x03
+ * FileIdBothDirectoryInformation	0x25
+ * FileNamesInformation			0x0C
+ * FileIdExtdDirectoryInformation	0x3C
+ */
+
+/* search (query_directory) Flags field */
+#define SMB2_RESTART_SCANS		0x01
+#define SMB2_RETURN_SINGLE_ENTRY	0x02
+#define SMB2_INDEX_SPECIFIED		0x04
+#define SMB2_REOPEN			0x10
+
+struct smb2_query_directory_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 33 */
+	__u8   FileInformationClass;
+	__u8   Flags;
+	__le32 FileIndex;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+	__le16 FileNameOffset;
+	__le16 FileNameLength;
+	__le32 OutputBufferLength;
+	__u8   Buffer[];
+} __packed;
+
+struct smb2_query_directory_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 9 */
+	__le16 OutputBufferOffset;
+	__le32 OutputBufferLength;
+	__u8   Buffer[];
+} __packed;
+
+/* DeviceType Flags */
+#define FILE_DEVICE_CD_ROM              0x00000002
+#define FILE_DEVICE_CD_ROM_FILE_SYSTEM  0x00000003
+#define FILE_DEVICE_DFS                 0x00000006
+#define FILE_DEVICE_DISK                0x00000007
+#define FILE_DEVICE_DISK_FILE_SYSTEM    0x00000008
+#define FILE_DEVICE_FILE_SYSTEM         0x00000009
+#define FILE_DEVICE_NAMED_PIPE          0x00000011
+#define FILE_DEVICE_NETWORK             0x00000012
+#define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014
+#define FILE_DEVICE_NULL                0x00000015
+#define FILE_DEVICE_PARALLEL_PORT       0x00000016
+#define FILE_DEVICE_PRINTER             0x00000018
+#define FILE_DEVICE_SERIAL_PORT         0x0000001b
+#define FILE_DEVICE_STREAMS             0x0000001e
+#define FILE_DEVICE_TAPE                0x0000001f
+#define FILE_DEVICE_TAPE_FILE_SYSTEM    0x00000020
+#define FILE_DEVICE_VIRTUAL_DISK        0x00000024
+#define FILE_DEVICE_NETWORK_REDIRECTOR  0x00000028
+
+/* Device Characteristics */
+#define FILE_REMOVABLE_MEDIA			0x00000001
+#define FILE_READ_ONLY_DEVICE			0x00000002
+#define FILE_FLOPPY_DISKETTE			0x00000004
+#define FILE_WRITE_ONCE_MEDIA			0x00000008
+#define FILE_REMOTE_DEVICE			0x00000010
+#define FILE_DEVICE_IS_MOUNTED			0x00000020
+#define FILE_VIRTUAL_VOLUME			0x00000040
+#define FILE_DEVICE_SECURE_OPEN			0x00000100
+#define FILE_CHARACTERISTIC_TS_DEVICE		0x00001000
+#define FILE_CHARACTERISTIC_WEBDAV_DEVICE	0x00002000
+#define FILE_PORTABLE_DEVICE			0x00004000
+#define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL 0x00020000
+
+/*
+ * Maximum number of iovs we need for a set-info request.
+ * The largest one is rename/hardlink
+ * [0] : struct smb2_set_info_req + smb2_file_[rename|link]_info
+ * [1] : path
+ * [2] : compound padding
+ */
+#define SMB2_SET_INFO_IOV_SIZE 3
+
+struct smb2_set_info_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 33 */
+	__u8   InfoType;
+	__u8   FileInfoClass;
+	__le32 BufferLength;
+	__le16 BufferOffset;
+	__u16  Reserved;
+	__le32 AdditionalInformation;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+	__u8   Buffer[];
+} __packed;
+
+struct smb2_set_info_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 2 */
+} __packed;
+
+/*
+ * SMB2_NOTIFY  See MS-SMB2 section 2.2.35
+ */
+/* notify flags */
+#define SMB2_WATCH_TREE			0x0001
+
+/* notify completion filter flags. See MS-FSCC 2.6 and MS-SMB2 2.2.35 */
+#define FILE_NOTIFY_CHANGE_FILE_NAME		0x00000001
+#define FILE_NOTIFY_CHANGE_DIR_NAME		0x00000002
+#define FILE_NOTIFY_CHANGE_NAME			0x00000003
+#define FILE_NOTIFY_CHANGE_ATTRIBUTES		0x00000004
+#define FILE_NOTIFY_CHANGE_SIZE			0x00000008
+#define FILE_NOTIFY_CHANGE_LAST_WRITE		0x00000010
+#define FILE_NOTIFY_CHANGE_LAST_ACCESS		0x00000020
+#define FILE_NOTIFY_CHANGE_CREATION		0x00000040
+#define FILE_NOTIFY_CHANGE_EA			0x00000080
+#define FILE_NOTIFY_CHANGE_SECURITY		0x00000100
+#define FILE_NOTIFY_CHANGE_STREAM_NAME		0x00000200
+#define FILE_NOTIFY_CHANGE_STREAM_SIZE		0x00000400
+#define FILE_NOTIFY_CHANGE_STREAM_WRITE		0x00000800
+
+/* See MS-SMB2 2.2.35 */
+struct smb2_change_notify_req {
+	struct smb2_hdr hdr;
+	__le16	StructureSize;
+	__le16	Flags;
+	__le32	OutputBufferLength;
+	__u64	PersistentFileId; /* opaque endianness */
+	__u64	VolatileFileId; /* opaque endianness */
+	__le32	CompletionFilter;
+	__u32	Reserved;
+} __packed;
+
+/* See MS-SMB2 2.2.36 */
+struct smb2_change_notify_rsp {
+	struct smb2_hdr hdr;
+	__le16	StructureSize;  /* Must be 9 */
+	__le16	OutputBufferOffset;
+	__le32	OutputBufferLength;
+	__u8	Buffer[]; /* array of file notify structs */
+} __packed;
+
+/*
+ * SMB2_SERVER_TO_CLIENT_NOTIFICATION: See MS-SMB2 section 2.2.44
+ */
+
+#define SMB2_NOTIFY_SESSION_CLOSED	0x0000
+
+struct smb2_server_client_notification {
+	struct smb2_hdr hdr;
+	__le16	StructureSize;
+	__u16	Reserved; /* MBZ */
+	__le32	NotificationType;
+	__u8	NotificationBuffer[4]; /* MBZ */
+} __packed;
+
+/*
+ * SMB2_CREATE  See MS-SMB2 section 2.2.13
+ */
+/* Oplock levels */
+#define SMB2_OPLOCK_LEVEL_NONE		0x00
+#define SMB2_OPLOCK_LEVEL_II		0x01
+#define SMB2_OPLOCK_LEVEL_EXCLUSIVE	0x08
+#define SMB2_OPLOCK_LEVEL_BATCH		0x09
+#define SMB2_OPLOCK_LEVEL_LEASE		0xFF
+/* Non-spec internal type */
+#define SMB2_OPLOCK_LEVEL_NOCHANGE	0x99
+
+/* Impersonation Levels. See MS-WPO section 9.7 and MSDN-IMPERS */
+#define IL_ANONYMOUS		cpu_to_le32(0x00000000)
+#define IL_IDENTIFICATION	cpu_to_le32(0x00000001)
+#define IL_IMPERSONATION	cpu_to_le32(0x00000002)
+#define IL_DELEGATE		cpu_to_le32(0x00000003)
+
+/* Desired Access Flags */
+#define FILE_READ_DATA_LE		cpu_to_le32(0x00000001)
+#define FILE_LIST_DIRECTORY_LE		cpu_to_le32(0x00000001)
+#define FILE_WRITE_DATA_LE		cpu_to_le32(0x00000002)
+#define FILE_APPEND_DATA_LE		cpu_to_le32(0x00000004)
+#define FILE_ADD_SUBDIRECTORY_LE	cpu_to_le32(0x00000004)
+#define FILE_READ_EA_LE			cpu_to_le32(0x00000008)
+#define FILE_WRITE_EA_LE		cpu_to_le32(0x00000010)
+#define FILE_EXECUTE_LE			cpu_to_le32(0x00000020)
+#define FILE_DELETE_CHILD_LE		cpu_to_le32(0x00000040)
+#define FILE_READ_ATTRIBUTES_LE		cpu_to_le32(0x00000080)
+#define FILE_WRITE_ATTRIBUTES_LE	cpu_to_le32(0x00000100)
+#define FILE_DELETE_LE			cpu_to_le32(0x00010000)
+#define FILE_READ_CONTROL_LE		cpu_to_le32(0x00020000)
+#define FILE_WRITE_DAC_LE		cpu_to_le32(0x00040000)
+#define FILE_WRITE_OWNER_LE		cpu_to_le32(0x00080000)
+#define FILE_SYNCHRONIZE_LE		cpu_to_le32(0x00100000)
+#define FILE_ACCESS_SYSTEM_SECURITY_LE	cpu_to_le32(0x01000000)
+#define FILE_MAXIMAL_ACCESS_LE		cpu_to_le32(0x02000000)
+#define FILE_GENERIC_ALL_LE		cpu_to_le32(0x10000000)
+#define FILE_GENERIC_EXECUTE_LE		cpu_to_le32(0x20000000)
+#define FILE_GENERIC_WRITE_LE		cpu_to_le32(0x40000000)
+#define FILE_GENERIC_READ_LE		cpu_to_le32(0x80000000)
+#define DESIRED_ACCESS_MASK             cpu_to_le32(0xF21F01FF)
+
+
+#define FILE_READ_DESIRED_ACCESS_LE     (FILE_READ_DATA_LE        |	\
+					 FILE_READ_EA_LE          |     \
+					 FILE_GENERIC_READ_LE)
+#define FILE_WRITE_DESIRE_ACCESS_LE     (FILE_WRITE_DATA_LE       |	\
+					 FILE_APPEND_DATA_LE      |	\
+					 FILE_WRITE_EA_LE         |	\
+					 FILE_WRITE_ATTRIBUTES_LE |	\
+					 FILE_GENERIC_WRITE_LE)
+
+/* ShareAccess Flags */
+#define FILE_SHARE_READ_LE		cpu_to_le32(0x00000001)
+#define FILE_SHARE_WRITE_LE		cpu_to_le32(0x00000002)
+#define FILE_SHARE_DELETE_LE		cpu_to_le32(0x00000004)
+#define FILE_SHARE_ALL_LE		cpu_to_le32(0x00000007)
+
+/* CreateDisposition Flags */
+#define FILE_SUPERSEDE_LE		cpu_to_le32(0x00000000)
+#define FILE_OPEN_LE			cpu_to_le32(0x00000001)
+#define FILE_CREATE_LE			cpu_to_le32(0x00000002)
+#define	FILE_OPEN_IF_LE			cpu_to_le32(0x00000003)
+#define FILE_OVERWRITE_LE		cpu_to_le32(0x00000004)
+#define FILE_OVERWRITE_IF_LE		cpu_to_le32(0x00000005)
+#define FILE_CREATE_MASK_LE             cpu_to_le32(0x00000007)
+
+/* CreateOptions Flags */
+#define FILE_DIRECTORY_FILE_LE		cpu_to_le32(0x00000001)
+/* same as #define CREATE_NOT_FILE_LE	cpu_to_le32(0x00000001) */
+#define FILE_WRITE_THROUGH_LE		cpu_to_le32(0x00000002)
+#define FILE_SEQUENTIAL_ONLY_LE		cpu_to_le32(0x00000004)
+#define FILE_NO_INTERMEDIATE_BUFFERING_LE cpu_to_le32(0x00000008)
+/* FILE_SYNCHRONOUS_IO_ALERT_LE		cpu_to_le32(0x00000010) should be zero, ignored */
+/* FILE_SYNCHRONOUS_IO_NONALERT		cpu_to_le32(0x00000020) should be zero, ignored */
+#define FILE_NON_DIRECTORY_FILE_LE	cpu_to_le32(0x00000040)
+#define FILE_COMPLETE_IF_OPLOCKED_LE	cpu_to_le32(0x00000100)
+#define FILE_NO_EA_KNOWLEDGE_LE		cpu_to_le32(0x00000200)
+/* FILE_OPEN_REMOTE_INSTANCE		cpu_to_le32(0x00000400) should be zero, ignored */
+#define FILE_RANDOM_ACCESS_LE		cpu_to_le32(0x00000800)
+#define FILE_DELETE_ON_CLOSE_LE		cpu_to_le32(0x00001000) /* MBZ */
+#define FILE_OPEN_BY_FILE_ID_LE		cpu_to_le32(0x00002000)
+#define FILE_OPEN_FOR_BACKUP_INTENT_LE	cpu_to_le32(0x00004000)
+#define FILE_NO_COMPRESSION_LE		cpu_to_le32(0x00008000)
+/* FILE_OPEN_REQUIRING_OPLOCK		cpu_to_le32(0x00010000) should be zero, ignored */
+/* FILE_DISALLOW_EXCLUSIVE		cpu_to_le32(0x00020000) should be zero, ignored */
+/* FILE_RESERVE_OPFILTER		cpu_to_le32(0x00100000) MBZ */
+#define FILE_OPEN_REPARSE_POINT_LE	cpu_to_le32(0x00200000)
+#define FILE_OPEN_NO_RECALL_LE		cpu_to_le32(0x00400000)
+/* #define FILE_OPEN_FOR_FREE_SPACE_QUERY cpu_to_le32(0x00800000) should be zero, ignored */
+#define CREATE_OPTIONS_MASK_LE          cpu_to_le32(0x00FFFFFF)
+
+#define FILE_READ_RIGHTS_LE (FILE_READ_DATA_LE | FILE_READ_EA_LE \
+			| FILE_READ_ATTRIBUTES_LE)
+#define FILE_WRITE_RIGHTS_LE (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE \
+			| FILE_WRITE_EA_LE | FILE_WRITE_ATTRIBUTES_LE)
+#define FILE_EXEC_RIGHTS_LE (FILE_EXECUTE_LE)
+
+/* Create Context Values */
+#define SMB2_CREATE_EA_BUFFER			"ExtA" /* extended attributes */
+#define SMB2_CREATE_SD_BUFFER			"SecD" /* security descriptor */
+#define SMB2_CREATE_DURABLE_HANDLE_REQUEST	"DHnQ"
+#define SMB2_CREATE_DURABLE_HANDLE_RECONNECT	"DHnC"
+#define SMB2_CREATE_ALLOCATION_SIZE		"AlSi"
+#define SMB2_CREATE_QUERY_MAXIMAL_ACCESS_REQUEST "MxAc"
+#define SMB2_CREATE_TIMEWARP_REQUEST		"TWrp"
+#define SMB2_CREATE_QUERY_ON_DISK_ID		"QFid"
+#define SMB2_CREATE_REQUEST_LEASE		"RqLs"
+#define SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2	"DH2Q"
+#define SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2	"DH2C"
+#define SMB2_CREATE_TAG_POSIX		"\x93\xAD\x25\x50\x9C\xB4\x11\xE7\xB4\x23\x83\xDE\x96\x8B\xCD\x7C"
+#define SMB2_CREATE_APP_INSTANCE_ID	"\x45\xBC\xA6\x6A\xEF\xA7\xF7\x4A\x90\x08\xFA\x46\x2E\x14\x4D\x74"
+#define SMB2_CREATE_APP_INSTANCE_VERSION "\xB9\x82\xD0\xB7\x3B\x56\x07\x4F\xA0\x7B\x52\x4A\x81\x16\xA0\x10"
+#define SVHDX_OPEN_DEVICE_CONTEXT	"\x9C\xCB\xCF\x9E\x04\xC1\xE6\x43\x98\x0E\x15\x8D\xA1\xF6\xEC\x83"
+#define SMB2_CREATE_TAG_AAPL			"AAPL"
+
+/* Flag (SMB3 open response) values */
+#define SMB2_CREATE_FLAG_REPARSEPOINT 0x01
+
+struct create_context {
+	/* New members must be added within the struct_group() macro below. */
+	__struct_group(create_context_hdr, hdr, __packed,
+		__le32 Next;
+		__le16 NameOffset;
+		__le16 NameLength;
+		__le16 Reserved;
+		__le16 DataOffset;
+		__le32 DataLength;
+	);
+	__u8 Buffer[];
+} __packed;
+static_assert(offsetof(struct create_context, Buffer) == sizeof(struct create_context_hdr),
+	      "struct member likely outside of __struct_group()");
+
+struct smb2_create_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 57 */
+	__u8   SecurityFlags;
+	__u8   RequestedOplockLevel;
+	__le32 ImpersonationLevel;
+	__le64 SmbCreateFlags;
+	__le64 Reserved;
+	__le32 DesiredAccess;
+	__le32 FileAttributes;
+	__le32 ShareAccess;
+	__le32 CreateDisposition;
+	__le32 CreateOptions;
+	__le16 NameOffset;
+	__le16 NameLength;
+	__le32 CreateContextsOffset;
+	__le32 CreateContextsLength;
+	__u8   Buffer[];
+} __packed;
+
+struct smb2_create_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize;	/* Must be 89 */
+	__u8   OplockLevel;
+	__u8   Flags;  /* 0x01 if reparse point */
+	__le32 CreateAction;
+	__le64 CreationTime;
+	__le64 LastAccessTime;
+	__le64 LastWriteTime;
+	__le64 ChangeTime;
+	__le64 AllocationSize;
+	__le64 EndofFile;
+	__le32 FileAttributes;
+	__le32 Reserved2;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+	__le32 CreateContextsOffset;
+	__le32 CreateContextsLength;
+	__u8   Buffer[];
+} __packed;
+
+struct create_posix {
+	struct create_context_hdr ccontext;
+	__u8    Name[16];
+	__le32  Mode;
+	__u32   Reserved;
+} __packed;
+
+/* See MS-SMB2 2.2.13.2.3 and MS-SMB2 2.2.13.2.4 */
+typedef struct {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	union {
+		__u8  Reserved[16];
+		struct {
+			__u64 PersistentFileId;
+			__u64 VolatileFileId;
+		} Fid;
+	} Data;
+} __packed create_durable_req_t, create_durable_reconn_t;
+
+/* See MS-SMB2 2.2.13.2.5 */
+struct create_mxac_req {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	__le64 Timestamp;
+} __packed;
+
+/*
+ * AAPL flags. See Samba libcli/smb/smb2_create_ctx.h
+ */
+
+/* "AAPL" Context Command Codes */
+#define SMB2_CRTCTX_AAPL_SERVER_QUERY 1
+#define SMB2_CRTCTX_AAPL_RESOLVE_ID   2
+
+/* "AAPL" Server Query request/response bitmap */
+#define SMB2_CRTCTX_AAPL_SERVER_CAPS 1
+#define SMB2_CRTCTX_AAPL_VOLUME_CAPS 2
+#define SMB2_CRTCTX_AAPL_MODEL_INFO  4
+
+/* "AAPL" Client/Server Capabilities bitmap */
+#define SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR 1
+#define SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE  2
+#define SMB2_CRTCTX_AAPL_UNIX_BASED             4
+#define SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE       8
+/*
+ * V2 extends the same inline-FinderInfo mechanism as
+ * SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR with an added flags field,
+ * confirmed byte-identical to V1 otherwise against AAPL's actual
+ * public client behavior.  Mutually exclusive with the V1 bit on
+ * the wire, not both set together.
+ */
+#define SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR_V2 16
+
+/* "AAPL" Volume Capabilities bitmap */
+#define SMB2_CRTCTX_AAPL_SUPPORT_RESOLVE_ID 1
+#define SMB2_CRTCTX_AAPL_CASE_SENSITIVE     2
+#define SMB2_CRTCTX_AAPL_FULL_SYNC          4
+
+/*
+ * Flags
+ * See MS-SMB2 2.2.13.2.11
+ *     MS-SMB2 2.2.13.2.12
+ *     MS-SMB2 2.2.14.2.12
+ */
+#define SMB2_DHANDLE_FLAG_PERSISTENT	0x00000002
+
+/* See MS-SMB2 2.2.13.2.11 */
+struct durable_context_v2_req {
+	__le32 Timeout;
+	__le32 Flags; /* see SMB2_DHANDLE_FLAG_PERSISTENT */
+	__u64 Reserved;
+	__u8 CreateGuid[16];
+} __packed;
+
+struct create_durable_req_v2 {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	struct durable_context_v2_req dcontext;
+} __packed;
+
+/* See MS-SMB2 2.2.13.2.12 */
+struct durable_reconnect_context_v2 {
+	struct {
+		__u64 PersistentFileId;
+		__u64 VolatileFileId;
+	} Fid;
+	__u8 CreateGuid[16];
+	__le32 Flags; /* see SMB2_DHANDLE_FLAG_PERSISTENT */
+} __packed;
+
+struct create_durable_handle_reconnect_v2 {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	struct durable_reconnect_context_v2 dcontext;
+	__u8 Pad[4];
+} __packed;
+
+/* See MS-SMB2 2.2.14.2.12 */
+struct durable_context_v2_rsp {
+	__le32 Timeout;
+	__le32 Flags; /* see SMB2_DHANDLE_FLAG_PERSISTENT */
+} __packed;
+
+struct create_durable_rsp_v2 {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	struct durable_context_v2_rsp dcontext;
+} __packed;
+
+/* See MS-SMB2 2.2.14.2.5 */
+struct create_mxac_rsp {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	__le32 QueryStatus;
+	__le32 MaximalAccess;
+} __packed;
+
+#define SMB2_LEASE_NONE_LE			cpu_to_le32(0x00)
+#define SMB2_LEASE_READ_CACHING_LE		cpu_to_le32(0x01)
+#define SMB2_LEASE_HANDLE_CACHING_LE		cpu_to_le32(0x02)
+#define SMB2_LEASE_WRITE_CACHING_LE		cpu_to_le32(0x04)
+
+#define SMB2_LEASE_FLAG_BREAK_IN_PROGRESS_LE	cpu_to_le32(0x02)
+#define SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET_LE	cpu_to_le32(0x04)
+
+#define SMB2_LEASE_KEY_SIZE			16
+
+/* See MS-SMB2 2.2.13.2.8 */
+struct lease_context {
+	__u8 LeaseKey[SMB2_LEASE_KEY_SIZE];
+	__le32 LeaseState;
+	__le32 LeaseFlags;
+	__le64 LeaseDuration;
+} __packed;
+
+/* See MS-SMB2 2.2.13.2.10 */
+struct lease_context_v2 {
+	__u8 LeaseKey[SMB2_LEASE_KEY_SIZE];
+	__le32 LeaseState;
+	__le32 LeaseFlags;
+	__le64 LeaseDuration;
+	__u8 ParentLeaseKey[SMB2_LEASE_KEY_SIZE];
+	__le16 Epoch;
+	__le16 Reserved;
+} __packed;
+
+struct create_lease {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	struct lease_context lcontext;
+} __packed;
+
+struct create_lease_v2 {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	struct lease_context_v2 lcontext;
+	__u8   Pad[4];
+} __packed;
+
+/* See MS-SMB2 2.2.14.2.9 */
+struct create_disk_id_rsp {
+	struct create_context_hdr ccontext;
+	__u8   Name[8];
+	__le64 DiskFileId;
+	__le64 VolumeId;
+	__u8  Reserved[16];
+} __packed;
+
+/* See MS-SMB2 2.2.13.2.13 */
+struct create_app_inst_id {
+	struct create_context_hdr ccontext;
+	__u8 Name[16];
+	__le32 StructureSize; /* Must be 20 */
+	__u16 Reserved;
+	__u8 AppInstanceId[16];
+} __packed;
+
+/* See MS-SMB2 2.2.13.2.15 */
+struct create_app_inst_id_vers {
+	struct create_context_hdr ccontext;
+	__u8 Name[16];
+	__le32 StructureSize; /* Must be 24 */
+	__u16 Reserved;
+	__u32 Padding;
+	__le64 AppInstanceVersionHigh;
+	__le64 AppInstanceVersionLow;
+} __packed;
+
+/* See MS-SMB2 2.2.31 and 2.2.32 */
+struct smb2_ioctl_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 57 */
+	__le16 Reserved; /* offset from start of SMB2 header to write data */
+	__le32 CtlCode;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+	__le32 InputOffset; /* Reserved MBZ */
+	__le32 InputCount;
+	__le32 MaxInputResponse;
+	__le32 OutputOffset;
+	__le32 OutputCount;
+	__le32 MaxOutputResponse;
+	__le32 Flags;
+	__le32 Reserved2;
+	__u8   Buffer[];
+} __packed;
+
+/* See MS-SMB2 2.2.31.1.1 */
+struct srv_copychunk {
+	__le64 SourceOffset;
+	__le64 TargetOffset;
+	__le32 Length;
+	__le32 Reserved;
+} __packed;
+
+#define COPY_CHUNK_RES_KEY_SIZE	24
+
+/* See MS-SMB2 2.2.31.1 */
+/* this goes in the ioctl buffer when doing a copychunk request */
+struct copychunk_ioctl_req {
+	union {
+		char SourceKey[COPY_CHUNK_RES_KEY_SIZE];
+		__le64 SourceKeyU64[3];
+	};
+	__le32 ChunkCount;
+	__le32 Reserved;
+	struct srv_copychunk Chunks[] __counted_by_le(ChunkCount);
+} __packed;
+
+/* See MS-SMB2 2.2.32.1 */
+struct copychunk_ioctl_rsp {
+	__le32 ChunksWritten;
+	__le32 ChunkBytesWritten;
+	__le32 TotalBytesWritten;
+} __packed;
+
+/* See MS-SMB2 2.2.32.3 */
+struct resume_key_ioctl_rsp {
+	union {
+		char ResumeKey[COPY_CHUNK_RES_KEY_SIZE];
+		__u64 ResumeKeyU64[3];
+	};
+	__le32	ContextLength;	/* MBZ */
+	char	Context[4];	/* ignored, Windows sets to 4 bytes of zero */
+} __packed;
+
+struct smb2_ioctl_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 49 */
+	__le16 Reserved;
+	__le32 CtlCode;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+	__le32 InputOffset; /* Reserved MBZ */
+	__le32 InputCount;
+	__le32 OutputOffset;
+	__le32 OutputCount;
+	__le32 Flags;
+	__le32 Reserved2;
+	__u8   Buffer[];
+} __packed;
+
+/* See MS-SMB2 2.2.32.5.1.1 */
+struct smb_sockaddr_in {
+	__be16 Port;
+	__be32 IPv4Address;
+	__u8   Reserved[8];
+} __packed;
+
+/* See MS-SMB2 2.2.32.5.1.2 */
+struct smb_sockaddr_in6 {
+	__be16 Port;
+	__be32 FlowInfo;
+	__u8   IPv6Address[16];
+	__be32 ScopeId;
+} __packed;
+
+/* See MS-SMB2 2.2.32.5 and MS-SMB2 2.2.32.5.1 */
+#define RSS_CAPABLE	cpu_to_le32(0x00000001)
+#define RDMA_CAPABLE	cpu_to_le32(0x00000002)
+#define INTERNETWORK	cpu_to_le16(0x0002)
+#define INTERNETWORKV6	cpu_to_le16(0x0017)
+struct network_interface_info_ioctl_rsp {
+	__le32 Next; /* next interface. zero if this is last one */
+	__le32 IfIndex;
+	__le32 Capability; /* RSS or RDMA Capable */
+	__le32 Reserved;
+	__le64 LinkSpeed;
+	union {
+		char	SockAddr_Storage[128];
+		struct {
+			__le16 Family;
+			__u8 Buffer[126];
+		};
+	};
+} __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];
+	__le16 SecurityMode;
+	__le16 DialectCount;
+	__le16 Dialects[4]; /* BB expand this if autonegotiate > 4 dialects */
+} __packed;
+
+struct validate_negotiate_info_rsp {
+	__le32 Capabilities;
+	__u8   Guid[SMB2_CLIENT_GUID_SIZE];
+	__le16 SecurityMode;
+	__le16 Dialect; /* Dialect in use for the connection */
+} __packed;
+
+
+/* Possible InfoType values */
+#define SMB2_O_INFO_FILE	0x01
+#define SMB2_O_INFO_FILESYSTEM	0x02
+#define SMB2_O_INFO_SECURITY	0x03
+#define SMB2_O_INFO_QUOTA	0x04
+
+/* SMB2 Query Info see MS-SMB2 (2.2.37) or MS-DTYP */
+
+/* List of QUERY INFO levels (those also valid for QUERY_DIR are noted below */
+#define FILE_DIRECTORY_INFORMATION	1	/* also for QUERY_DIR */
+#define FILE_FULL_DIRECTORY_INFORMATION 2	/* also for QUERY_DIR */
+#define FILE_BOTH_DIRECTORY_INFORMATION 3	/* also for QUERY_DIR */
+#define FILE_BASIC_INFORMATION		4
+#define FILE_STANDARD_INFORMATION	5
+#define FILE_INTERNAL_INFORMATION	6
+#define FILE_EA_INFORMATION	        7
+#define FILE_ACCESS_INFORMATION		8
+#define FILE_NAME_INFORMATION		9
+#define FILE_RENAME_INFORMATION		10
+#define FILE_LINK_INFORMATION		11
+#define FILE_NAMES_INFORMATION		12	/* also for QUERY_DIR */
+#define FILE_DISPOSITION_INFORMATION	13
+#define FILE_POSITION_INFORMATION	14
+#define FILE_FULL_EA_INFORMATION	15
+#define FILE_MODE_INFORMATION		16
+#define FILE_ALIGNMENT_INFORMATION	17
+#define FILE_ALL_INFORMATION		18
+#define FILE_ALLOCATION_INFORMATION	19
+#define FILE_END_OF_FILE_INFORMATION	20
+#define FILE_ALTERNATE_NAME_INFORMATION 21
+#define FILE_STREAM_INFORMATION		22
+#define FILE_PIPE_INFORMATION		23
+#define FILE_PIPE_LOCAL_INFORMATION	24
+#define FILE_PIPE_REMOTE_INFORMATION	25
+#define FILE_MAILSLOT_QUERY_INFORMATION 26
+#define FILE_MAILSLOT_SET_INFORMATION	27
+#define FILE_COMPRESSION_INFORMATION	28
+#define FILE_OBJECT_ID_INFORMATION	29
+/* Number 30 not defined in documents */
+#define FILE_MOVE_CLUSTER_INFORMATION	31
+#define FILE_QUOTA_INFORMATION		32
+#define FILE_REPARSE_POINT_INFORMATION	33
+#define FILE_NETWORK_OPEN_INFORMATION	34
+#define FILE_ATTRIBUTE_TAG_INFORMATION	35
+#define FILE_TRACKING_INFORMATION	36
+#define FILEID_BOTH_DIRECTORY_INFORMATION 37	/* also for QUERY_DIR */
+#define FILEID_FULL_DIRECTORY_INFORMATION 38	/* also for QUERY_DIR */
+#define FILE_VALID_DATA_LENGTH_INFORMATION 39
+#define FILE_SHORT_NAME_INFORMATION	40
+#define FILE_SFIO_RESERVE_INFORMATION	44
+#define FILE_SFIO_VOLUME_INFORMATION	45
+#define FILE_HARD_LINK_INFORMATION	46
+#define FILE_NORMALIZED_NAME_INFORMATION 48
+#define FILEID_GLOBAL_TX_DIRECTORY_INFORMATION 50
+#define FILE_STANDARD_LINK_INFORMATION	54
+#define FILE_ID_INFORMATION		59
+#define FILE_ID_EXTD_DIRECTORY_INFORMATION 60	/* also for QUERY_DIR */
+#define FileId64ExtdDirectoryInformation 78	/* also for QUERY_DIR */
+#define FileId64ExtdBothDirectoryInformation 79 /* also for QUERY_DIR */
+#define FileIdAllExtdDirectoryInformation 80	/* also for QUERY_DIR */
+#define FileIdAllExtdBothDirectoryInformation 81 /* also for QUERY_DIR */
+/* Used for Query Info and Find File POSIX Info for SMB3.1.1 and SMB1 */
+#define SMB_FIND_FILE_POSIX_INFO	0x064
+
+/* Security info type additionalinfo flags. */
+#define OWNER_SECINFO   0x00000001
+#define GROUP_SECINFO   0x00000002
+#define DACL_SECINFO   0x00000004
+#define SACL_SECINFO   0x00000008
+#define LABEL_SECINFO   0x00000010
+#define ATTRIBUTE_SECINFO   0x00000020
+#define SCOPE_SECINFO   0x00000040
+#define BACKUP_SECINFO   0x00010000
+#define UNPROTECTED_SACL_SECINFO   0x10000000
+#define UNPROTECTED_DACL_SECINFO   0x20000000
+#define PROTECTED_SACL_SECINFO   0x40000000
+#define PROTECTED_DACL_SECINFO   0x80000000
+
+/* Flags used for FileFullEAinfo */
+#define SL_RESTART_SCAN		0x00000001
+#define SL_RETURN_SINGLE_ENTRY	0x00000002
+#define SL_INDEX_SPECIFIED	0x00000004
+
+struct smb2_query_info_req {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 41 */
+	__u8   InfoType;
+	__u8   FileInfoClass;
+	__le32 OutputBufferLength;
+	__le16 InputBufferOffset;
+	__u16  Reserved;
+	__le32 InputBufferLength;
+	__le32 AdditionalInformation;
+	__le32 Flags;
+	__u64  PersistentFileId;
+	__u64  VolatileFileId;
+	__u8   Buffer[];
+} __packed;
+
+struct smb2_query_info_rsp {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 9 */
+	__le16 OutputBufferOffset;
+	__le32 OutputBufferLength;
+	__u8   Buffer[];
+} __packed;
+
+/* Level 100 query info */
+struct smb311_posix_qinfo {
+	__le64 CreationTime;
+	__le64 LastAccessTime;
+	__le64 LastWriteTime;
+	__le64 ChangeTime;
+	__le64 EndOfFile;
+	__le64 AllocationSize;
+	__le32 DosAttributes;
+	__le64 Inode;
+	__le32 DeviceId;
+	__le32 Zero;
+	/* beginning of POSIX Create Context Response */
+	__le32 HardLinks;
+	__le32 ReparseTag;
+	__le32 Mode;
+	u8     Sids[];
+	/*
+	 * var sized owner SID
+	 * var sized group SID
+	 * le32 filenamelength
+	 * u8  filename[]
+	 */
+} __packed;
+
+/* See MS-SMB2 2.2.23 through 2.2.25 */
+struct smb2_oplock_break {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 24 */
+	__u8   OplockLevel;
+	__u8   Reserved;
+	__le32 Reserved2;
+	__u64  PersistentFid;
+	__u64  VolatileFid;
+} __packed;
+
+#define SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED cpu_to_le32(0x01)
+
+struct smb2_lease_break {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 44 */
+	__le16 Epoch;
+	__le32 Flags;
+	__u8   LeaseKey[16];
+	__le32 CurrentLeaseState;
+	__le32 NewLeaseState;
+	__le32 BreakReason;
+	__le32 AccessMaskHint;
+	__le32 ShareMaskHint;
+} __packed;
+
+struct smb2_lease_ack {
+	struct smb2_hdr hdr;
+	__le16 StructureSize; /* Must be 36 */
+	__le16 Reserved;
+	__le32 Flags;
+	__u8   LeaseKey[16];
+	__le32 LeaseState;
+	__le64 LeaseDuration;
+} __packed;
+
+#define OP_BREAK_STRUCT_SIZE_20		24
+#define OP_BREAK_STRUCT_SIZE_21		36
+
+/*
+ * See MS-SMB2 2.2.13.1.1
+ *     MS-SMB 2.2.1.4.1
+ * These are the file access permission bits defined in CIFS for the
+ * NTCreateAndX as well as the level 0x107
+ * TRANS2_QUERY_PATH_INFORMATION API.  The level 0x107, SMB_QUERY_FILE_ALL_INFO
+ * responds with the AccessFlags.
+ * The AccessFlags specifies the access permissions a caller has to the
+ * file and can have any suitable combination of the following values:
+ */
+#define FILE_READ_DATA        0x00000001  /* Data can be read from the file   */
+					  /* or directory child entries can   */
+					  /* be listed together with the      */
+					  /* associated child attributes      */
+					  /* (so the FILE_READ_ATTRIBUTES on  */
+					  /* the child entry is not needed)   */
+#define FILE_WRITE_DATA       0x00000002  /* Data can be written to the file  */
+					  /* or new file can be created in    */
+					  /* the directory                    */
+#define FILE_APPEND_DATA      0x00000004  /* Data can be appended to the file */
+					  /* (for non-local files over SMB it */
+					  /* is same as FILE_WRITE_DATA)      */
+					  /* or new subdirectory can be       */
+					  /* created in the directory         */
+#define FILE_READ_EA          0x00000008  /* Extended attributes associated   */
+					  /* with the file can be read        */
+#define FILE_WRITE_EA         0x00000010  /* Extended attributes associated   */
+					  /* with the file can be written     */
+#define FILE_EXECUTE          0x00000020  /*Data can be read into memory from */
+					  /* the file using system paging I/O */
+					  /* for executing the file / script  */
+					  /* or right to traverse directory   */
+					  /* (but by default all users have   */
+					  /* directory bypass traverse        */
+					  /* privilege and do not need this   */
+					  /* permission on directories at all)*/
+#define FILE_DELETE_CHILD     0x00000040  /* Child entry can be deleted from  */
+					  /* the directory (so the DELETE on  */
+					  /* the child entry is not needed)   */
+#define FILE_READ_ATTRIBUTES  0x00000080  /* Attributes associated with the   */
+					  /* file or directory can be read    */
+#define FILE_WRITE_ATTRIBUTES 0x00000100  /* Attributes associated with the   */
+					  /* file or directory can be written */
+#define DELETE                0x00010000  /* The file or dir can be deleted   */
+#define READ_CONTROL          0x00020000  /* The discretionary access control */
+					  /* list and ownership associated    */
+					  /* with the file or dir can be read */
+#define WRITE_DAC             0x00040000  /* The discretionary access control */
+					  /* list associated with the file or */
+					  /* directory can be written         */
+#define WRITE_OWNER           0x00080000  /* Ownership information associated */
+					  /* with the file/dir can be written */
+#define SYNCHRONIZE           0x00100000  /* The file handle can waited on to */
+					  /* synchronize with the completion  */
+					  /* of an input/output request       */
+#define SYSTEM_SECURITY       0x01000000  /* The system access control list   */
+					  /* associated with the file or      */
+					  /* directory can be read or written */
+					  /* (cannot be in DACL, can in SACL) */
+#define MAXIMUM_ALLOWED       0x02000000  /* Maximal subset of GENERIC_ALL    */
+					  /* permissions which can be granted */
+					  /* (cannot be in DACL nor SACL)     */
+#define GENERIC_ALL           0x10000000  /* Same as: GENERIC_EXECUTE |       */
+					  /*          GENERIC_WRITE |         */
+					  /*          GENERIC_READ |          */
+					  /*          FILE_DELETE_CHILD |     */
+					  /*          DELETE |                */
+					  /*          WRITE_DAC |             */
+					  /*          WRITE_OWNER             */
+					  /* So GENERIC_ALL contains all bits */
+					  /* mentioned above except these two */
+					  /* SYSTEM_SECURITY  MAXIMUM_ALLOWED */
+#define GENERIC_EXECUTE       0x20000000  /* Same as: FILE_EXECUTE |          */
+					  /*          FILE_READ_ATTRIBUTES |  */
+					  /*          READ_CONTROL |          */
+					  /*          SYNCHRONIZE             */
+#define GENERIC_WRITE         0x40000000  /* Same as: FILE_WRITE_DATA |       */
+					  /*          FILE_APPEND_DATA |      */
+					  /*          FILE_WRITE_EA |         */
+					  /*          FILE_WRITE_ATTRIBUTES | */
+					  /*          READ_CONTROL |          */
+					  /*          SYNCHRONIZE             */
+#define GENERIC_READ          0x80000000  /* Same as: FILE_READ_DATA |        */
+					  /*          FILE_READ_EA |          */
+					  /*          FILE_READ_ATTRIBUTES |  */
+					  /*          READ_CONTROL |          */
+					  /*          SYNCHRONIZE             */
+
+/* Combinations of file access permission bits */
+#define FILE_READ_RIGHTS (FILE_READ_DATA | FILE_READ_EA | FILE_READ_ATTRIBUTES)
+#define FILE_WRITE_RIGHTS (FILE_WRITE_DATA | FILE_APPEND_DATA \
+			| FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES)
+#define FILE_EXEC_RIGHTS (FILE_EXECUTE)
+#define SET_FILE_EXEC_RIGHTS (FILE_READ_EA | FILE_WRITE_EA | FILE_EXECUTE \
+				| FILE_READ_ATTRIBUTES \
+				| FILE_WRITE_ATTRIBUTES \
+				| DELETE | READ_CONTROL | WRITE_DAC \
+				| WRITE_OWNER | SYNCHRONIZE)
+#define SET_MINIMUM_RIGHTS (FILE_READ_EA | FILE_READ_ATTRIBUTES \
+				| READ_CONTROL | SYNCHRONIZE)
+
+#endif				/* _COMMON_SMB2PDU_H */
diff --git a/fs/smb/common/smb2status.h b/fs/smb/common/smb2status.h
new file mode 100644
index 000000000..2989c3a5c
--- /dev/null
+++ b/fs/smb/common/smb2status.h
@@ -0,0 +1,1790 @@
+/* SPDX-License-Identifier: LGPL-2.1 */
+/*
+ *
+ *   SMB2 Status code (network error) definitions
+ *   Definitions are from MS-ERREF
+ *
+ *   Copyright (c) International Business Machines  Corp., 2009,2011
+ *   Author(s): Steve French (sfrench@us.ibm.com)
+ *
+ */
+
+#ifndef FS_SMB_COMMON_SMB2STATUS_H
+#define FS_SMB_COMMON_SMB2STATUS_H
+
+/*
+ *  0 1 2 3 4 5 6 7 8 9 0 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F
+ *  SEV C N <-------Facility--------> <------Error Status Code------>
+ *
+ *  C is set if "customer defined" error, N bit is reserved and MBZ
+ */
+
+#define STATUS_SEVERITY_SUCCESS __constant_cpu_to_le32(0x0000)
+#define STATUS_SEVERITY_INFORMATIONAL cpu_to_le32(0x0001)
+#define STATUS_SEVERITY_WARNING cpu_to_le32(0x0002)
+#define STATUS_SEVERITY_ERROR cpu_to_le32(0x0003)
+
+struct ntstatus {
+	/* Facility is the high 12 bits of the following field */
+	__le32 Facility; /* low 2 bits Severity, next is Customer, then rsrvd */
+	__le32 Code;
+};
+
+/*
+ * The comment at the end of each definition indicates `posix_error`
+ * field of `struct status_to_posix_error`, it is used to generate the
+ * `smb2_error_map_table` array.
+ */
+
+#define STATUS_SUCCESS				cpu_to_le32(0x00000000) // 0
+#define STATUS_WAIT_0				cpu_to_le32(0x00000000) // 0
+#define STATUS_WAIT_1				cpu_to_le32(0x00000001) // -EIO
+#define STATUS_WAIT_2				cpu_to_le32(0x00000002) // -EIO
+#define STATUS_WAIT_3				cpu_to_le32(0x00000003) // -EIO
+#define STATUS_WAIT_63				cpu_to_le32(0x0000003F) // -EIO
+#define STATUS_ABANDONED			cpu_to_le32(0x00000080) // -EIO
+#define STATUS_ABANDONED_WAIT_0			cpu_to_le32(0x00000080) // -EIO
+#define STATUS_ABANDONED_WAIT_63		cpu_to_le32(0x000000BF) // -EIO
+#define STATUS_USER_APC				cpu_to_le32(0x000000C0) // -EIO
+#define STATUS_KERNEL_APC			cpu_to_le32(0x00000100) // -EIO
+#define STATUS_ALERTED				cpu_to_le32(0x00000101) // -EIO
+#define STATUS_TIMEOUT				cpu_to_le32(0x00000102) // -ETIMEDOUT
+#define STATUS_PENDING				cpu_to_le32(0x00000103) // -EIO
+#define STATUS_REPARSE				cpu_to_le32(0x00000104) // -EIO
+#define STATUS_MORE_ENTRIES			cpu_to_le32(0x00000105) // -EIO
+#define STATUS_NOT_ALL_ASSIGNED			cpu_to_le32(0x00000106) // -EIO
+#define STATUS_SOME_NOT_MAPPED			cpu_to_le32(0x00000107) // -EIO
+#define STATUS_OPLOCK_BREAK_IN_PROGRESS		cpu_to_le32(0x00000108) // -EIO
+#define STATUS_VOLUME_MOUNTED			cpu_to_le32(0x00000109) // -EIO
+#define STATUS_RXACT_COMMITTED			cpu_to_le32(0x0000010A) // -EIO
+#define STATUS_NOTIFY_CLEANUP			cpu_to_le32(0x0000010B) // -EIO
+#define STATUS_NOTIFY_ENUM_DIR			cpu_to_le32(0x0000010C) // -EIO
+#define STATUS_NO_QUOTAS_FOR_ACCOUNT		cpu_to_le32(0x0000010D) // -EIO
+#define STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED	cpu_to_le32(0x0000010E) // -EIO
+#define STATUS_PAGE_FAULT_TRANSITION		cpu_to_le32(0x00000110) // -EIO
+#define STATUS_PAGE_FAULT_DEMAND_ZERO		cpu_to_le32(0x00000111) // -EIO
+#define STATUS_PAGE_FAULT_COPY_ON_WRITE		cpu_to_le32(0x00000112) // -EIO
+#define STATUS_PAGE_FAULT_GUARD_PAGE		cpu_to_le32(0x00000113) // -EIO
+#define STATUS_PAGE_FAULT_PAGING_FILE		cpu_to_le32(0x00000114) // -EIO
+#define STATUS_CACHE_PAGE_LOCKED		cpu_to_le32(0x00000115) // -EIO
+#define STATUS_CRASH_DUMP			cpu_to_le32(0x00000116) // -EIO
+#define STATUS_BUFFER_ALL_ZEROS			cpu_to_le32(0x00000117) // -EIO
+#define STATUS_REPARSE_OBJECT			cpu_to_le32(0x00000118) // -EIO
+#define STATUS_RESOURCE_REQUIREMENTS_CHANGED	cpu_to_le32(0x00000119) // -EIO
+#define STATUS_TRANSLATION_COMPLETE		cpu_to_le32(0x00000120) // -EIO
+#define STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY	cpu_to_le32(0x00000121) // -EIO
+#define STATUS_NOTHING_TO_TERMINATE		cpu_to_le32(0x00000122) // -EIO
+#define STATUS_PROCESS_NOT_IN_JOB		cpu_to_le32(0x00000123) // -EIO
+#define STATUS_PROCESS_IN_JOB			cpu_to_le32(0x00000124) // -EIO
+#define STATUS_VOLSNAP_HIBERNATE_READY		cpu_to_le32(0x00000125) // -EIO
+#define STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY cpu_to_le32(0x00000126) // -EIO
+#define STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED cpu_to_le32(0x00000127) // -EIO
+#define STATUS_INTERRUPT_STILL_CONNECTED	cpu_to_le32(0x00000128) // -EIO
+#define STATUS_PROCESS_CLONED			cpu_to_le32(0x00000129) // -EIO
+#define STATUS_FILE_LOCKED_WITH_ONLY_READERS	cpu_to_le32(0x0000012A) // -EIO
+#define STATUS_FILE_LOCKED_WITH_WRITERS		cpu_to_le32(0x0000012B) // -EIO
+#define STATUS_RESOURCEMANAGER_READ_ONLY	cpu_to_le32(0x00000202) // -EROFS
+#define STATUS_WAIT_FOR_OPLOCK			cpu_to_le32(0x00000367) // -EIO
+#define DBG_EXCEPTION_HANDLED			cpu_to_le32(0x00010001) // -EIO
+#define DBG_CONTINUE				cpu_to_le32(0x00010002) // -EIO
+#define STATUS_FLT_IO_COMPLETE			cpu_to_le32(0x001C0001) // -EIO
+#define STATUS_OBJECT_NAME_EXISTS		cpu_to_le32(0x40000000) // -EIO
+#define STATUS_THREAD_WAS_SUSPENDED		cpu_to_le32(0x40000001) // -EIO
+#define STATUS_WORKING_SET_LIMIT_RANGE		cpu_to_le32(0x40000002) // -EIO
+#define STATUS_IMAGE_NOT_AT_BASE		cpu_to_le32(0x40000003) // -EIO
+#define STATUS_RXACT_STATE_CREATED		cpu_to_le32(0x40000004) // -EIO
+#define STATUS_SEGMENT_NOTIFICATION		cpu_to_le32(0x40000005) // -EIO
+#define STATUS_LOCAL_USER_SESSION_KEY		cpu_to_le32(0x40000006) // -EIO
+#define STATUS_BAD_CURRENT_DIRECTORY		cpu_to_le32(0x40000007) // -EIO
+#define STATUS_SERIAL_MORE_WRITES		cpu_to_le32(0x40000008) // -EIO
+#define STATUS_REGISTRY_RECOVERED		cpu_to_le32(0x40000009) // -EIO
+#define STATUS_FT_READ_RECOVERY_FROM_BACKUP	cpu_to_le32(0x4000000A) // -EIO
+#define STATUS_FT_WRITE_RECOVERY		cpu_to_le32(0x4000000B) // -EIO
+#define STATUS_SERIAL_COUNTER_TIMEOUT		cpu_to_le32(0x4000000C) // -ETIMEDOUT
+#define STATUS_NULL_LM_PASSWORD			cpu_to_le32(0x4000000D) // -EIO
+#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH	cpu_to_le32(0x4000000E) // -EIO
+#define STATUS_RECEIVE_PARTIAL			cpu_to_le32(0x4000000F) // -EIO
+#define STATUS_RECEIVE_EXPEDITED		cpu_to_le32(0x40000010) // -EIO
+#define STATUS_RECEIVE_PARTIAL_EXPEDITED	cpu_to_le32(0x40000011) // -EIO
+#define STATUS_EVENT_DONE			cpu_to_le32(0x40000012) // -EIO
+#define STATUS_EVENT_PENDING			cpu_to_le32(0x40000013) // -EIO
+#define STATUS_CHECKING_FILE_SYSTEM		cpu_to_le32(0x40000014) // -EIO
+#define STATUS_FATAL_APP_EXIT			cpu_to_le32(0x40000015) // -EIO
+#define STATUS_PREDEFINED_HANDLE		cpu_to_le32(0x40000016) // -EIO
+#define STATUS_WAS_UNLOCKED			cpu_to_le32(0x40000017) // -EIO
+#define STATUS_SERVICE_NOTIFICATION		cpu_to_le32(0x40000018) // -EIO
+#define STATUS_WAS_LOCKED			cpu_to_le32(0x40000019) // -EIO
+#define STATUS_LOG_HARD_ERROR			cpu_to_le32(0x4000001A) // -EIO
+#define STATUS_ALREADY_WIN32			cpu_to_le32(0x4000001B) // -EIO
+#define STATUS_WX86_UNSIMULATE			cpu_to_le32(0x4000001C) // -EIO
+#define STATUS_WX86_CONTINUE			cpu_to_le32(0x4000001D) // -EIO
+#define STATUS_WX86_SINGLE_STEP			cpu_to_le32(0x4000001E) // -EIO
+#define STATUS_WX86_BREAKPOINT			cpu_to_le32(0x4000001F) // -EIO
+#define STATUS_WX86_EXCEPTION_CONTINUE		cpu_to_le32(0x40000020) // -EIO
+#define STATUS_WX86_EXCEPTION_LASTCHANCE	cpu_to_le32(0x40000021) // -EIO
+#define STATUS_WX86_EXCEPTION_CHAIN		cpu_to_le32(0x40000022) // -EIO
+#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE	cpu_to_le32(0x40000023) // -EIO
+#define STATUS_NO_YIELD_PERFORMED		cpu_to_le32(0x40000024) // -EIO
+#define STATUS_TIMER_RESUME_IGNORED		cpu_to_le32(0x40000025) // -EIO
+#define STATUS_ARBITRATION_UNHANDLED		cpu_to_le32(0x40000026) // -EIO
+#define STATUS_CARDBUS_NOT_SUPPORTED		cpu_to_le32(0x40000027) // -ENOSYS
+#define STATUS_WX86_CREATEWX86TIB		cpu_to_le32(0x40000028) // -EIO
+#define STATUS_MP_PROCESSOR_MISMATCH		cpu_to_le32(0x40000029) // -EIO
+#define STATUS_HIBERNATED			cpu_to_le32(0x4000002A) // -EIO
+#define STATUS_RESUME_HIBERNATION		cpu_to_le32(0x4000002B) // -EIO
+#define STATUS_FIRMWARE_UPDATED			cpu_to_le32(0x4000002C) // -EIO
+#define STATUS_DRIVERS_LEAKING_LOCKED_PAGES	cpu_to_le32(0x4000002D) // -EIO
+#define STATUS_MESSAGE_RETRIEVED		cpu_to_le32(0x4000002E) // -EIO
+#define STATUS_SYSTEM_POWERSTATE_TRANSITION	cpu_to_le32(0x4000002F) // -EIO
+#define STATUS_ALPC_CHECK_COMPLETION_LIST	cpu_to_le32(0x40000030) // -EIO
+#define STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION cpu_to_le32(0x40000031) // -EIO
+#define STATUS_ACCESS_AUDIT_BY_POLICY		cpu_to_le32(0x40000032) // -EIO
+#define STATUS_ABANDON_HIBERFILE		cpu_to_le32(0x40000033) // -EIO
+#define STATUS_BIZRULES_NOT_ENABLED		cpu_to_le32(0x40000034) // -EIO
+#define STATUS_WAKE_SYSTEM			cpu_to_le32(0x40000294) // -EIO
+#define STATUS_DS_SHUTTING_DOWN			cpu_to_le32(0x40000370) // -EIO
+#define DBG_REPLY_LATER				cpu_to_le32(0x40010001) // -EIO
+#define DBG_UNABLE_TO_PROVIDE_HANDLE		cpu_to_le32(0x40010002) // -EIO
+#define DBG_TERMINATE_THREAD			cpu_to_le32(0x40010003) // -EIO
+#define DBG_TERMINATE_PROCESS			cpu_to_le32(0x40010004) // -EIO
+#define DBG_CONTROL_C				cpu_to_le32(0x40010005) // -EIO
+#define DBG_PRINTEXCEPTION_C			cpu_to_le32(0x40010006) // -EIO
+#define DBG_RIPEXCEPTION			cpu_to_le32(0x40010007) // -EIO
+#define DBG_CONTROL_BREAK			cpu_to_le32(0x40010008) // -EIO
+#define DBG_COMMAND_EXCEPTION			cpu_to_le32(0x40010009) // -EIO
+#define RPC_NT_UUID_LOCAL_ONLY			cpu_to_le32(0x40020056) // -EIO
+#define RPC_NT_SEND_INCOMPLETE			cpu_to_le32(0x400200AF) // -EIO
+#define STATUS_CTX_CDM_CONNECT			cpu_to_le32(0x400A0004) // -EIO
+#define STATUS_CTX_CDM_DISCONNECT		cpu_to_le32(0x400A0005) // -EIO
+#define STATUS_SXS_RELEASE_ACTIVATION_CONTEXT	cpu_to_le32(0x4015000D) // -EIO
+#define STATUS_RECOVERY_NOT_NEEDED		cpu_to_le32(0x40190034) // -EIO
+#define STATUS_RM_ALREADY_STARTED		cpu_to_le32(0x40190035) // -EIO
+#define STATUS_LOG_NO_RESTART			cpu_to_le32(0x401A000C) // -EIO
+#define STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST cpu_to_le32(0x401B00EC) // -EIO
+#define STATUS_GRAPHICS_PARTIAL_DATA_POPULATED	cpu_to_le32(0x401E000A) // -EIO
+#define STATUS_GRAPHICS_DRIVER_MISMATCH		cpu_to_le32(0x401E0117) // -EIO
+#define STATUS_GRAPHICS_MODE_NOT_PINNED		cpu_to_le32(0x401E0307) // -EIO
+#define STATUS_GRAPHICS_NO_PREFERRED_MODE	cpu_to_le32(0x401E031E) // -EIO
+#define STATUS_GRAPHICS_DATASET_IS_EMPTY	cpu_to_le32(0x401E034B) // -EIO
+#define STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET cpu_to_le32(0x401E034C) // -EIO
+#define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED cpu_to_le32(0x401E0351) // -EIO
+#define STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS	cpu_to_le32(0x401E042F) // -EIO
+#define STATUS_GRAPHICS_LEADLINK_START_DEFERRED	cpu_to_le32(0x401E0437) // -EIO
+#define STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY	cpu_to_le32(0x401E0439) // -EIO
+#define STATUS_GRAPHICS_START_DEFERRED		cpu_to_le32(0x401E043A) // -EIO
+#define STATUS_NDIS_INDICATION_REQUIRED		cpu_to_le32(0x40230001) // -EIO
+#define STATUS_GUARD_PAGE_VIOLATION		cpu_to_le32(0x80000001) // -EIO
+#define STATUS_DATATYPE_MISALIGNMENT		cpu_to_le32(0x80000002) // -EIO
+#define STATUS_BREAKPOINT			cpu_to_le32(0x80000003) // -EIO
+#define STATUS_SINGLE_STEP			cpu_to_le32(0x80000004) // -EIO
+#define STATUS_BUFFER_OVERFLOW			cpu_to_le32(0x80000005) // -E2BIG
+#define STATUS_NO_MORE_FILES			cpu_to_le32(0x80000006) // -ENODATA
+#define STATUS_WAKE_SYSTEM_DEBUGGER		cpu_to_le32(0x80000007) // -EIO
+#define STATUS_HANDLES_CLOSED			cpu_to_le32(0x8000000A) // -EIO
+#define STATUS_NO_INHERITANCE			cpu_to_le32(0x8000000B) // -EIO
+#define STATUS_GUID_SUBSTITUTION_MADE		cpu_to_le32(0x8000000C) // -EIO
+#define STATUS_PARTIAL_COPY			cpu_to_le32(0x8000000D) // -EIO
+#define STATUS_DEVICE_PAPER_EMPTY		cpu_to_le32(0x8000000E) // -EIO
+#define STATUS_DEVICE_POWERED_OFF		cpu_to_le32(0x8000000F) // -EIO
+#define STATUS_DEVICE_OFF_LINE			cpu_to_le32(0x80000010) // -EIO
+#define STATUS_DEVICE_BUSY			cpu_to_le32(0x80000011) // -EBUSY
+#define STATUS_NO_MORE_EAS			cpu_to_le32(0x80000012) // -EIO
+#define STATUS_INVALID_EA_NAME			cpu_to_le32(0x80000013) // -EINVAL
+#define STATUS_EA_LIST_INCONSISTENT		cpu_to_le32(0x80000014) // -EIO
+#define STATUS_INVALID_EA_FLAG			cpu_to_le32(0x80000015) // -EINVAL
+#define STATUS_VERIFY_REQUIRED			cpu_to_le32(0x80000016) // -EIO
+#define STATUS_EXTRANEOUS_INFORMATION		cpu_to_le32(0x80000017) // -EIO
+#define STATUS_RXACT_COMMIT_NECESSARY		cpu_to_le32(0x80000018) // -EIO
+#define STATUS_NO_MORE_ENTRIES			cpu_to_le32(0x8000001A) // -EIO
+#define STATUS_FILEMARK_DETECTED		cpu_to_le32(0x8000001B) // -EIO
+#define STATUS_MEDIA_CHANGED			cpu_to_le32(0x8000001C) // -EIO
+#define STATUS_BUS_RESET			cpu_to_le32(0x8000001D) // -EIO
+#define STATUS_END_OF_MEDIA			cpu_to_le32(0x8000001E) // -EIO
+#define STATUS_BEGINNING_OF_MEDIA		cpu_to_le32(0x8000001F) // -EIO
+#define STATUS_MEDIA_CHECK			cpu_to_le32(0x80000020) // -EIO
+#define STATUS_SETMARK_DETECTED			cpu_to_le32(0x80000021) // -EIO
+#define STATUS_NO_DATA_DETECTED			cpu_to_le32(0x80000022) // -EIO
+#define STATUS_REDIRECTOR_HAS_OPEN_HANDLES	cpu_to_le32(0x80000023) // -EIO
+#define STATUS_SERVER_HAS_OPEN_HANDLES		cpu_to_le32(0x80000024) // -EIO
+#define STATUS_ALREADY_DISCONNECTED		cpu_to_le32(0x80000025) // -EIO
+#define STATUS_LONGJUMP				cpu_to_le32(0x80000026) // -EIO
+#define STATUS_CLEANER_CARTRIDGE_INSTALLED	cpu_to_le32(0x80000027) // -EIO
+#define STATUS_PLUGPLAY_QUERY_VETOED		cpu_to_le32(0x80000028) // -EIO
+#define STATUS_UNWIND_CONSOLIDATE		cpu_to_le32(0x80000029) // -EIO
+#define STATUS_REGISTRY_HIVE_RECOVERED		cpu_to_le32(0x8000002A) // -EIO
+#define STATUS_DLL_MIGHT_BE_INSECURE		cpu_to_le32(0x8000002B) // -EIO
+#define STATUS_DLL_MIGHT_BE_INCOMPATIBLE	cpu_to_le32(0x8000002C) // -EIO
+#define STATUS_STOPPED_ON_SYMLINK		cpu_to_le32(0x8000002D) // -EOPNOTSUPP
+#define STATUS_DEVICE_REQUIRES_CLEANING		cpu_to_le32(0x80000288) // -EIO
+#define STATUS_DEVICE_DOOR_OPEN			cpu_to_le32(0x80000289) // -EIO
+#define STATUS_DATA_LOST_REPAIR			cpu_to_le32(0x80000803) // -EIO
+#define DBG_EXCEPTION_NOT_HANDLED		cpu_to_le32(0x80010001) // -EIO
+#define STATUS_CLUSTER_NODE_ALREADY_UP		cpu_to_le32(0x80130001) // -EIO
+#define STATUS_CLUSTER_NODE_ALREADY_DOWN	cpu_to_le32(0x80130002) // -EIO
+#define STATUS_CLUSTER_NETWORK_ALREADY_ONLINE	cpu_to_le32(0x80130003) // -EIO
+#define STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE	cpu_to_le32(0x80130004) // -EIO
+#define STATUS_CLUSTER_NODE_ALREADY_MEMBER	cpu_to_le32(0x80130005) // -EIO
+#define STATUS_COULD_NOT_RESIZE_LOG		cpu_to_le32(0x80190009) // -EIO
+#define STATUS_NO_TXF_METADATA			cpu_to_le32(0x80190029) // -EIO
+#define STATUS_CANT_RECOVER_WITH_HANDLE_OPEN	cpu_to_le32(0x80190031) // -EIO
+#define STATUS_TXF_METADATA_ALREADY_PRESENT	cpu_to_le32(0x80190041) // -EIO
+#define STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET cpu_to_le32(0x80190042) // -EIO
+#define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED cpu_to_le32(0x801B00EB) // -EIO
+#define STATUS_FLT_BUFFER_TOO_SMALL		cpu_to_le32(0x801C0001) // -ENOBUFS
+#define STATUS_FVE_PARTIAL_METADATA		cpu_to_le32(0x80210001) // -EIO
+#define STATUS_UNSUCCESSFUL			cpu_to_le32(0xC0000001) // -EIO
+#define STATUS_NOT_IMPLEMENTED			cpu_to_le32(0xC0000002) // -EOPNOTSUPP
+#define STATUS_INVALID_INFO_CLASS		cpu_to_le32(0xC0000003) // -EIO
+#define STATUS_INFO_LENGTH_MISMATCH		cpu_to_le32(0xC0000004) // -EIO
+#define STATUS_ACCESS_VIOLATION			cpu_to_le32(0xC0000005) // -EACCES
+#define STATUS_IN_PAGE_ERROR			cpu_to_le32(0xC0000006) // -EFAULT
+#define STATUS_PAGEFILE_QUOTA			cpu_to_le32(0xC0000007) // -EDQUOT
+#define STATUS_INVALID_HANDLE			cpu_to_le32(0xC0000008) // -EBADF
+#define STATUS_BAD_INITIAL_STACK		cpu_to_le32(0xC0000009) // -EIO
+#define STATUS_BAD_INITIAL_PC			cpu_to_le32(0xC000000A) // -EIO
+#define STATUS_INVALID_CID			cpu_to_le32(0xC000000B) // -EIO
+#define STATUS_TIMER_NOT_CANCELED		cpu_to_le32(0xC000000C) // -EIO
+#define STATUS_INVALID_PARAMETER		cpu_to_le32(0xC000000D) // -EINVAL
+#define STATUS_NO_SUCH_DEVICE			cpu_to_le32(0xC000000E) // -ENODEV
+#define STATUS_NO_SUCH_FILE			cpu_to_le32(0xC000000F) // -ENOENT
+#define STATUS_INVALID_DEVICE_REQUEST		cpu_to_le32(0xC0000010) // -EOPNOTSUPP
+#define STATUS_END_OF_FILE			cpu_to_le32(0xC0000011) // -ENODATA
+#define STATUS_WRONG_VOLUME			cpu_to_le32(0xC0000012) // -EIO
+#define STATUS_NO_MEDIA_IN_DEVICE		cpu_to_le32(0xC0000013) // -EIO
+#define STATUS_UNRECOGNIZED_MEDIA		cpu_to_le32(0xC0000014) // -EIO
+#define STATUS_NONEXISTENT_SECTOR		cpu_to_le32(0xC0000015) // -EIO
+#define STATUS_MORE_PROCESSING_REQUIRED		cpu_to_le32(0xC0000016) // -EIO
+#define STATUS_NO_MEMORY			cpu_to_le32(0xC0000017) // -EREMOTEIO
+#define STATUS_CONFLICTING_ADDRESSES		cpu_to_le32(0xC0000018) // -EADDRINUSE
+#define STATUS_NOT_MAPPED_VIEW			cpu_to_le32(0xC0000019) // -EIO
+#define STATUS_UNABLE_TO_FREE_VM		cpu_to_le32(0xC000001A) // -EIO
+#define STATUS_UNABLE_TO_DELETE_SECTION		cpu_to_le32(0xC000001B) // -EIO
+#define STATUS_INVALID_SYSTEM_SERVICE		cpu_to_le32(0xC000001C) // -EIO
+#define STATUS_ILLEGAL_INSTRUCTION		cpu_to_le32(0xC000001D) // -EIO
+#define STATUS_INVALID_LOCK_SEQUENCE		cpu_to_le32(0xC000001E) // -EIO
+#define STATUS_INVALID_VIEW_SIZE		cpu_to_le32(0xC000001F) // -EIO
+#define STATUS_INVALID_FILE_FOR_SECTION		cpu_to_le32(0xC0000020) // -EIO
+#define STATUS_ALREADY_COMMITTED		cpu_to_le32(0xC0000021) // -EIO
+#define STATUS_ACCESS_DENIED			cpu_to_le32(0xC0000022) // -EACCES
+#define STATUS_BUFFER_TOO_SMALL			cpu_to_le32(0xC0000023) // -EIO
+#define STATUS_OBJECT_TYPE_MISMATCH		cpu_to_le32(0xC0000024) // -EIO
+#define STATUS_NONCONTINUABLE_EXCEPTION		cpu_to_le32(0xC0000025) // -EIO
+#define STATUS_INVALID_DISPOSITION		cpu_to_le32(0xC0000026) // -EIO
+#define STATUS_UNWIND				cpu_to_le32(0xC0000027) // -EIO
+#define STATUS_BAD_STACK			cpu_to_le32(0xC0000028) // -EIO
+#define STATUS_INVALID_UNWIND_TARGET		cpu_to_le32(0xC0000029) // -EIO
+#define STATUS_NOT_LOCKED			cpu_to_le32(0xC000002A) // -EIO
+#define STATUS_PARITY_ERROR			cpu_to_le32(0xC000002B) // -EIO
+#define STATUS_UNABLE_TO_DECOMMIT_VM		cpu_to_le32(0xC000002C) // -EIO
+#define STATUS_NOT_COMMITTED			cpu_to_le32(0xC000002D) // -EIO
+#define STATUS_INVALID_PORT_ATTRIBUTES		cpu_to_le32(0xC000002E) // -EIO
+#define STATUS_PORT_MESSAGE_TOO_LONG		cpu_to_le32(0xC000002F) // -EIO
+#define STATUS_INVALID_PARAMETER_MIX		cpu_to_le32(0xC0000030) // -EINVAL
+#define STATUS_INVALID_QUOTA_LOWER		cpu_to_le32(0xC0000031) // -EIO
+#define STATUS_DISK_CORRUPT_ERROR		cpu_to_le32(0xC0000032) // -EIO
+#define STATUS_OBJECT_NAME_INVALID		cpu_to_le32(0xC0000033) // -ENOENT
+#define STATUS_OBJECT_NAME_NOT_FOUND		cpu_to_le32(0xC0000034) // -ENOENT
+#define STATUS_OBJECT_NAME_COLLISION		cpu_to_le32(0xC0000035) // -EEXIST
+#define STATUS_PORT_DISCONNECTED		cpu_to_le32(0xC0000037) // -EIO
+#define STATUS_DEVICE_ALREADY_ATTACHED		cpu_to_le32(0xC0000038) // -EIO
+#define STATUS_OBJECT_PATH_INVALID		cpu_to_le32(0xC0000039) // -ENOTDIR
+#define STATUS_OBJECT_PATH_NOT_FOUND		cpu_to_le32(0xC000003A) // -ENOENT
+#define STATUS_OBJECT_PATH_SYNTAX_BAD		cpu_to_le32(0xC000003B) // -EIO
+#define STATUS_DATA_OVERRUN			cpu_to_le32(0xC000003C) // -EIO
+#define STATUS_DATA_LATE_ERROR			cpu_to_le32(0xC000003D) // -EIO
+#define STATUS_DATA_ERROR			cpu_to_le32(0xC000003E) // -EIO
+#define STATUS_CRC_ERROR			cpu_to_le32(0xC000003F) // -EIO
+#define STATUS_SECTION_TOO_BIG			cpu_to_le32(0xC0000040) // -EIO
+#define STATUS_PORT_CONNECTION_REFUSED		cpu_to_le32(0xC0000041) // -ECONNREFUSED
+#define STATUS_INVALID_PORT_HANDLE		cpu_to_le32(0xC0000042) // -EIO
+#define STATUS_SHARING_VIOLATION		cpu_to_le32(0xC0000043) // -EBUSY
+#define STATUS_QUOTA_EXCEEDED			cpu_to_le32(0xC0000044) // -EDQUOT
+#define STATUS_INVALID_PAGE_PROTECTION		cpu_to_le32(0xC0000045) // -EIO
+#define STATUS_MUTANT_NOT_OWNED			cpu_to_le32(0xC0000046) // -EIO
+#define STATUS_SEMAPHORE_LIMIT_EXCEEDED		cpu_to_le32(0xC0000047) // -EIO
+#define STATUS_PORT_ALREADY_SET			cpu_to_le32(0xC0000048) // -EIO
+#define STATUS_SECTION_NOT_IMAGE		cpu_to_le32(0xC0000049) // -EIO
+#define STATUS_SUSPEND_COUNT_EXCEEDED		cpu_to_le32(0xC000004A) // -EIO
+#define STATUS_THREAD_IS_TERMINATING		cpu_to_le32(0xC000004B) // -EIO
+#define STATUS_BAD_WORKING_SET_LIMIT		cpu_to_le32(0xC000004C) // -EIO
+#define STATUS_INCOMPATIBLE_FILE_MAP		cpu_to_le32(0xC000004D) // -EIO
+#define STATUS_SECTION_PROTECTION		cpu_to_le32(0xC000004E) // -EIO
+#define STATUS_EAS_NOT_SUPPORTED		cpu_to_le32(0xC000004F) // -EOPNOTSUPP
+#define STATUS_EA_TOO_LARGE			cpu_to_le32(0xC0000050) // -EIO
+#define STATUS_NONEXISTENT_EA_ENTRY		cpu_to_le32(0xC0000051) // -EIO
+#define STATUS_NO_EAS_ON_FILE			cpu_to_le32(0xC0000052) // -ENODATA
+#define STATUS_EA_CORRUPT_ERROR			cpu_to_le32(0xC0000053) // -EIO
+#define STATUS_FILE_LOCK_CONFLICT		cpu_to_le32(0xC0000054) // -EACCES
+#define STATUS_LOCK_NOT_GRANTED			cpu_to_le32(0xC0000055) // -EACCES
+#define STATUS_DELETE_PENDING			cpu_to_le32(0xC0000056) // -ENOENT
+#define STATUS_CTL_FILE_NOT_SUPPORTED		cpu_to_le32(0xC0000057) // -ENOSYS
+#define STATUS_UNKNOWN_REVISION			cpu_to_le32(0xC0000058) // -EIO
+#define STATUS_REVISION_MISMATCH		cpu_to_le32(0xC0000059) // -EIO
+#define STATUS_INVALID_OWNER			cpu_to_le32(0xC000005A) // -EIO
+#define STATUS_INVALID_PRIMARY_GROUP		cpu_to_le32(0xC000005B) // -EIO
+#define STATUS_NO_IMPERSONATION_TOKEN		cpu_to_le32(0xC000005C) // -EIO
+#define STATUS_CANT_DISABLE_MANDATORY		cpu_to_le32(0xC000005D) // -EIO
+#define STATUS_NO_LOGON_SERVERS			cpu_to_le32(0xC000005E) // -EIO
+#define STATUS_NO_SUCH_LOGON_SESSION		cpu_to_le32(0xC000005F) // -EIO
+#define STATUS_NO_SUCH_PRIVILEGE		cpu_to_le32(0xC0000060) // -EIO
+#define STATUS_PRIVILEGE_NOT_HELD		cpu_to_le32(0xC0000061) // -EPERM
+#define STATUS_INVALID_ACCOUNT_NAME		cpu_to_le32(0xC0000062) // -EIO
+#define STATUS_USER_EXISTS			cpu_to_le32(0xC0000063) // -EIO
+#define STATUS_NO_SUCH_USER			cpu_to_le32(0xC0000064) // -EIO
+#define STATUS_GROUP_EXISTS			cpu_to_le32(0xC0000065) // -EIO
+#define STATUS_NO_SUCH_GROUP			cpu_to_le32(0xC0000066) // -EIO
+#define STATUS_MEMBER_IN_GROUP			cpu_to_le32(0xC0000067) // -EIO
+#define STATUS_MEMBER_NOT_IN_GROUP		cpu_to_le32(0xC0000068) // -EIO
+#define STATUS_LAST_ADMIN			cpu_to_le32(0xC0000069) // -EIO
+#define STATUS_WRONG_PASSWORD			cpu_to_le32(0xC000006A) // -EACCES
+#define STATUS_ILL_FORMED_PASSWORD		cpu_to_le32(0xC000006B) // -EINVAL
+#define STATUS_PASSWORD_RESTRICTION		cpu_to_le32(0xC000006C) // -EACCES
+#define STATUS_LOGON_FAILURE			cpu_to_le32(0xC000006D) // -EACCES
+#define STATUS_ACCOUNT_RESTRICTION		cpu_to_le32(0xC000006E) // -EACCES
+#define STATUS_INVALID_LOGON_HOURS		cpu_to_le32(0xC000006F) // -EACCES
+#define STATUS_INVALID_WORKSTATION		cpu_to_le32(0xC0000070) // -EACCES
+#define STATUS_PASSWORD_EXPIRED			cpu_to_le32(0xC0000071) // -EKEYEXPIRED
+#define STATUS_ACCOUNT_DISABLED			cpu_to_le32(0xC0000072) // -EKEYREVOKED
+#define STATUS_NONE_MAPPED			cpu_to_le32(0xC0000073) // -EIO
+#define STATUS_TOO_MANY_LUIDS_REQUESTED		cpu_to_le32(0xC0000074) // -EIO
+#define STATUS_LUIDS_EXHAUSTED			cpu_to_le32(0xC0000075) // -EIO
+#define STATUS_INVALID_SUB_AUTHORITY		cpu_to_le32(0xC0000076) // -EIO
+#define STATUS_INVALID_ACL			cpu_to_le32(0xC0000077) // -EIO
+#define STATUS_INVALID_SID			cpu_to_le32(0xC0000078) // -EIO
+#define STATUS_INVALID_SECURITY_DESCR		cpu_to_le32(0xC0000079) // -EIO
+#define STATUS_PROCEDURE_NOT_FOUND		cpu_to_le32(0xC000007A) // -EIO
+#define STATUS_INVALID_IMAGE_FORMAT		cpu_to_le32(0xC000007B) // -EIO
+#define STATUS_NO_TOKEN				cpu_to_le32(0xC000007C) // -EIO
+#define STATUS_BAD_INHERITANCE_ACL		cpu_to_le32(0xC000007D) // -EIO
+#define STATUS_RANGE_NOT_LOCKED			cpu_to_le32(0xC000007E) // -EIO
+#define STATUS_DISK_FULL			cpu_to_le32(0xC000007F) // -ENOSPC
+#define STATUS_SERVER_DISABLED			cpu_to_le32(0xC0000080) // -EIO
+#define STATUS_SERVER_NOT_DISABLED		cpu_to_le32(0xC0000081) // -EIO
+#define STATUS_TOO_MANY_GUIDS_REQUESTED		cpu_to_le32(0xC0000082) // -EIO
+#define STATUS_GUIDS_EXHAUSTED			cpu_to_le32(0xC0000083) // -EIO
+#define STATUS_INVALID_ID_AUTHORITY		cpu_to_le32(0xC0000084) // -EIO
+#define STATUS_AGENTS_EXHAUSTED			cpu_to_le32(0xC0000085) // -EIO
+#define STATUS_INVALID_VOLUME_LABEL		cpu_to_le32(0xC0000086) // -EIO
+#define STATUS_SECTION_NOT_EXTENDED		cpu_to_le32(0xC0000087) // -EIO
+#define STATUS_NOT_MAPPED_DATA			cpu_to_le32(0xC0000088) // -EIO
+#define STATUS_RESOURCE_DATA_NOT_FOUND		cpu_to_le32(0xC0000089) // -EIO
+#define STATUS_RESOURCE_TYPE_NOT_FOUND		cpu_to_le32(0xC000008A) // -EIO
+#define STATUS_RESOURCE_NAME_NOT_FOUND		cpu_to_le32(0xC000008B) // -EIO
+#define STATUS_ARRAY_BOUNDS_EXCEEDED		cpu_to_le32(0xC000008C) // -EIO
+#define STATUS_FLOAT_DENORMAL_OPERAND		cpu_to_le32(0xC000008D) // -EIO
+#define STATUS_FLOAT_DIVIDE_BY_ZERO		cpu_to_le32(0xC000008E) // -EIO
+#define STATUS_FLOAT_INEXACT_RESULT		cpu_to_le32(0xC000008F) // -EIO
+#define STATUS_FLOAT_INVALID_OPERATION		cpu_to_le32(0xC0000090) // -EIO
+#define STATUS_FLOAT_OVERFLOW			cpu_to_le32(0xC0000091) // -EIO
+#define STATUS_FLOAT_STACK_CHECK		cpu_to_le32(0xC0000092) // -EIO
+#define STATUS_FLOAT_UNDERFLOW			cpu_to_le32(0xC0000093) // -EIO
+#define STATUS_INTEGER_DIVIDE_BY_ZERO		cpu_to_le32(0xC0000094) // -EIO
+#define STATUS_INTEGER_OVERFLOW			cpu_to_le32(0xC0000095) // -EIO
+#define STATUS_PRIVILEGED_INSTRUCTION		cpu_to_le32(0xC0000096) // -EIO
+#define STATUS_TOO_MANY_PAGING_FILES		cpu_to_le32(0xC0000097) // -EIO
+#define STATUS_FILE_INVALID			cpu_to_le32(0xC0000098) // -EIO
+#define STATUS_ALLOTTED_SPACE_EXCEEDED		cpu_to_le32(0xC0000099) // -EIO
+#define STATUS_INSUFFICIENT_RESOURCES		cpu_to_le32(0xC000009A) // -EAGAIN
+#define STATUS_DFS_EXIT_PATH_FOUND		cpu_to_le32(0xC000009B) // -EIO
+#define STATUS_DEVICE_DATA_ERROR		cpu_to_le32(0xC000009C) // -EIO
+#define STATUS_DEVICE_NOT_CONNECTED		cpu_to_le32(0xC000009D) // -EIO
+#define STATUS_DEVICE_POWER_FAILURE		cpu_to_le32(0xC000009E) // -EIO
+#define STATUS_FREE_VM_NOT_AT_BASE		cpu_to_le32(0xC000009F) // -EIO
+#define STATUS_MEMORY_NOT_ALLOCATED		cpu_to_le32(0xC00000A0) // -EFAULT
+#define STATUS_WORKING_SET_QUOTA		cpu_to_le32(0xC00000A1) // -EIO
+#define STATUS_MEDIA_WRITE_PROTECTED		cpu_to_le32(0xC00000A2) // -EROFS
+#define STATUS_DEVICE_NOT_READY			cpu_to_le32(0xC00000A3) // -EIO
+#define STATUS_INVALID_GROUP_ATTRIBUTES		cpu_to_le32(0xC00000A4) // -EIO
+#define STATUS_BAD_IMPERSONATION_LEVEL		cpu_to_le32(0xC00000A5) // -EIO
+#define STATUS_CANT_OPEN_ANONYMOUS		cpu_to_le32(0xC00000A6) // -EIO
+#define STATUS_BAD_VALIDATION_CLASS		cpu_to_le32(0xC00000A7) // -EIO
+#define STATUS_BAD_TOKEN_TYPE			cpu_to_le32(0xC00000A8) // -EIO
+#define STATUS_BAD_MASTER_BOOT_RECORD		cpu_to_le32(0xC00000A9) // -EIO
+#define STATUS_INSTRUCTION_MISALIGNMENT		cpu_to_le32(0xC00000AA) // -EIO
+#define STATUS_INSTANCE_NOT_AVAILABLE		cpu_to_le32(0xC00000AB) // -EIO
+#define STATUS_PIPE_NOT_AVAILABLE		cpu_to_le32(0xC00000AC) // -EIO
+#define STATUS_INVALID_PIPE_STATE		cpu_to_le32(0xC00000AD) // -EIO
+#define STATUS_PIPE_BUSY			cpu_to_le32(0xC00000AE) // -EBUSY
+#define STATUS_ILLEGAL_FUNCTION			cpu_to_le32(0xC00000AF) // -EIO
+#define STATUS_PIPE_DISCONNECTED		cpu_to_le32(0xC00000B0) // -EPIPE
+#define STATUS_PIPE_CLOSING			cpu_to_le32(0xC00000B1) // -EIO
+#define STATUS_PIPE_CONNECTED			cpu_to_le32(0xC00000B2) // -EIO
+#define STATUS_PIPE_LISTENING			cpu_to_le32(0xC00000B3) // -EIO
+#define STATUS_INVALID_READ_MODE		cpu_to_le32(0xC00000B4) // -EIO
+#define STATUS_IO_TIMEOUT			cpu_to_le32(0xC00000B5) // -EAGAIN
+#define STATUS_FILE_FORCED_CLOSED		cpu_to_le32(0xC00000B6) // -EIO
+#define STATUS_PROFILING_NOT_STARTED		cpu_to_le32(0xC00000B7) // -EIO
+#define STATUS_PROFILING_NOT_STOPPED		cpu_to_le32(0xC00000B8) // -EIO
+#define STATUS_COULD_NOT_INTERPRET		cpu_to_le32(0xC00000B9) // -EIO
+#define STATUS_FILE_IS_A_DIRECTORY		cpu_to_le32(0xC00000BA) // -EISDIR
+#define STATUS_NOT_SUPPORTED			cpu_to_le32(0xC00000BB) // -EOPNOTSUPP
+#define STATUS_REMOTE_NOT_LISTENING		cpu_to_le32(0xC00000BC) // -EHOSTDOWN
+#define STATUS_DUPLICATE_NAME			cpu_to_le32(0xC00000BD) // -ENOTUNIQ
+#define STATUS_BAD_NETWORK_PATH			cpu_to_le32(0xC00000BE) // -EINVAL
+#define STATUS_NETWORK_BUSY			cpu_to_le32(0xC00000BF) // -EBUSY
+#define STATUS_DEVICE_DOES_NOT_EXIST		cpu_to_le32(0xC00000C0) // -ENODEV
+#define STATUS_TOO_MANY_COMMANDS		cpu_to_le32(0xC00000C1) // -EIO
+#define STATUS_ADAPTER_HARDWARE_ERROR		cpu_to_le32(0xC00000C2) // -EIO
+#define STATUS_INVALID_NETWORK_RESPONSE		cpu_to_le32(0xC00000C3) // -EIO
+#define STATUS_UNEXPECTED_NETWORK_ERROR		cpu_to_le32(0xC00000C4) // -EIO
+#define STATUS_BAD_REMOTE_ADAPTER		cpu_to_le32(0xC00000C5) // -EIO
+#define STATUS_PRINT_QUEUE_FULL			cpu_to_le32(0xC00000C6) // -EIO
+#define STATUS_NO_SPOOL_SPACE			cpu_to_le32(0xC00000C7) // -EIO
+#define STATUS_PRINT_CANCELLED			cpu_to_le32(0xC00000C8) // -EIO
+#define STATUS_NETWORK_NAME_DELETED		cpu_to_le32(0xC00000C9) // -EREMCHG
+#define STATUS_NETWORK_ACCESS_DENIED		cpu_to_le32(0xC00000CA) // -EACCES
+#define STATUS_BAD_DEVICE_TYPE			cpu_to_le32(0xC00000CB) // -EIO
+#define STATUS_BAD_NETWORK_NAME			cpu_to_le32(0xC00000CC) // -ENOENT
+#define STATUS_TOO_MANY_NAMES			cpu_to_le32(0xC00000CD) // -EIO
+#define STATUS_TOO_MANY_SESSIONS		cpu_to_le32(0xC00000CE) // -EIO
+#define STATUS_SHARING_PAUSED			cpu_to_le32(0xC00000CF) // -EIO
+#define STATUS_REQUEST_NOT_ACCEPTED		cpu_to_le32(0xC00000D0) // -EIO
+#define STATUS_REDIRECTOR_PAUSED		cpu_to_le32(0xC00000D1) // -EIO
+#define STATUS_NET_WRITE_FAULT			cpu_to_le32(0xC00000D2) // -EIO
+#define STATUS_PROFILING_AT_LIMIT		cpu_to_le32(0xC00000D3) // -EIO
+#define STATUS_NOT_SAME_DEVICE			cpu_to_le32(0xC00000D4) // -EXDEV
+#define STATUS_FILE_RENAMED			cpu_to_le32(0xC00000D5) // -EIO
+#define STATUS_VIRTUAL_CIRCUIT_CLOSED		cpu_to_le32(0xC00000D6) // -EIO
+#define STATUS_NO_SECURITY_ON_OBJECT		cpu_to_le32(0xC00000D7) // -EIO
+#define STATUS_CANT_WAIT			cpu_to_le32(0xC00000D8) // -EIO
+#define STATUS_PIPE_EMPTY			cpu_to_le32(0xC00000D9) // -EIO
+#define STATUS_CANT_ACCESS_DOMAIN_INFO		cpu_to_le32(0xC00000DA) // -EIO
+#define STATUS_CANT_TERMINATE_SELF		cpu_to_le32(0xC00000DB) // -EIO
+#define STATUS_INVALID_SERVER_STATE		cpu_to_le32(0xC00000DC) // -EIO
+#define STATUS_INVALID_DOMAIN_STATE		cpu_to_le32(0xC00000DD) // -EIO
+#define STATUS_INVALID_DOMAIN_ROLE		cpu_to_le32(0xC00000DE) // -EIO
+#define STATUS_NO_SUCH_DOMAIN			cpu_to_le32(0xC00000DF) // -EIO
+#define STATUS_DOMAIN_EXISTS			cpu_to_le32(0xC00000E0) // -EIO
+#define STATUS_DOMAIN_LIMIT_EXCEEDED		cpu_to_le32(0xC00000E1) // -EIO
+#define STATUS_OPLOCK_NOT_GRANTED		cpu_to_le32(0xC00000E2) // -EIO
+#define STATUS_INVALID_OPLOCK_PROTOCOL		cpu_to_le32(0xC00000E3) // -EIO
+#define STATUS_INTERNAL_DB_CORRUPTION		cpu_to_le32(0xC00000E4) // -EIO
+#define STATUS_INTERNAL_ERROR			cpu_to_le32(0xC00000E5) // -EIO
+#define STATUS_GENERIC_NOT_MAPPED		cpu_to_le32(0xC00000E6) // -EIO
+#define STATUS_BAD_DESCRIPTOR_FORMAT		cpu_to_le32(0xC00000E7) // -EIO
+#define STATUS_INVALID_USER_BUFFER		cpu_to_le32(0xC00000E8) // -EIO
+#define STATUS_UNEXPECTED_IO_ERROR		cpu_to_le32(0xC00000E9) // -EIO
+#define STATUS_UNEXPECTED_MM_CREATE_ERR		cpu_to_le32(0xC00000EA) // -EIO
+#define STATUS_UNEXPECTED_MM_MAP_ERROR		cpu_to_le32(0xC00000EB) // -EIO
+#define STATUS_UNEXPECTED_MM_EXTEND_ERR		cpu_to_le32(0xC00000EC) // -EIO
+#define STATUS_NOT_LOGON_PROCESS		cpu_to_le32(0xC00000ED) // -EIO
+#define STATUS_LOGON_SESSION_EXISTS		cpu_to_le32(0xC00000EE) // -EIO
+#define STATUS_INVALID_PARAMETER_1		cpu_to_le32(0xC00000EF) // -EINVAL
+#define STATUS_INVALID_PARAMETER_2		cpu_to_le32(0xC00000F0) // -EINVAL
+#define STATUS_INVALID_PARAMETER_3		cpu_to_le32(0xC00000F1) // -EINVAL
+#define STATUS_INVALID_PARAMETER_4		cpu_to_le32(0xC00000F2) // -EINVAL
+#define STATUS_INVALID_PARAMETER_5		cpu_to_le32(0xC00000F3) // -EINVAL
+#define STATUS_INVALID_PARAMETER_6		cpu_to_le32(0xC00000F4) // -EINVAL
+#define STATUS_INVALID_PARAMETER_7		cpu_to_le32(0xC00000F5) // -EINVAL
+#define STATUS_INVALID_PARAMETER_8		cpu_to_le32(0xC00000F6) // -EINVAL
+#define STATUS_INVALID_PARAMETER_9		cpu_to_le32(0xC00000F7) // -EINVAL
+#define STATUS_INVALID_PARAMETER_10		cpu_to_le32(0xC00000F8) // -EINVAL
+#define STATUS_INVALID_PARAMETER_11		cpu_to_le32(0xC00000F9) // -EINVAL
+#define STATUS_INVALID_PARAMETER_12		cpu_to_le32(0xC00000FA) // -EINVAL
+#define STATUS_REDIRECTOR_NOT_STARTED		cpu_to_le32(0xC00000FB) // -EIO
+#define STATUS_REDIRECTOR_STARTED		cpu_to_le32(0xC00000FC) // -EIO
+#define STATUS_STACK_OVERFLOW			cpu_to_le32(0xC00000FD) // -EIO
+#define STATUS_NO_SUCH_PACKAGE			cpu_to_le32(0xC00000FE) // -EIO
+#define STATUS_BAD_FUNCTION_TABLE		cpu_to_le32(0xC00000FF) // -EIO
+#define STATUS_VARIABLE_NOT_FOUND		cpu_to_le32(0xC0000100) // -EIO
+#define STATUS_DIRECTORY_NOT_EMPTY		cpu_to_le32(0xC0000101) // -ENOTEMPTY
+#define STATUS_FILE_CORRUPT_ERROR		cpu_to_le32(0xC0000102) // -EIO
+#define STATUS_NOT_A_DIRECTORY			cpu_to_le32(0xC0000103) // -ENOTDIR
+#define STATUS_BAD_LOGON_SESSION_STATE		cpu_to_le32(0xC0000104) // -EIO
+#define STATUS_LOGON_SESSION_COLLISION		cpu_to_le32(0xC0000105) // -EIO
+#define STATUS_NAME_TOO_LONG			cpu_to_le32(0xC0000106) // -ENAMETOOLONG
+#define STATUS_FILES_OPEN			cpu_to_le32(0xC0000107) // -EIO
+#define STATUS_CONNECTION_IN_USE		cpu_to_le32(0xC0000108) // -EIO
+#define STATUS_MESSAGE_NOT_FOUND		cpu_to_le32(0xC0000109) // -EIO
+#define STATUS_PROCESS_IS_TERMINATING		cpu_to_le32(0xC000010A) // -EIO
+#define STATUS_INVALID_LOGON_TYPE		cpu_to_le32(0xC000010B) // -EIO
+#define STATUS_NO_GUID_TRANSLATION		cpu_to_le32(0xC000010C) // -EIO
+#define STATUS_CANNOT_IMPERSONATE		cpu_to_le32(0xC000010D) // -EIO
+#define STATUS_IMAGE_ALREADY_LOADED		cpu_to_le32(0xC000010E) // -EIO
+#define STATUS_ABIOS_NOT_PRESENT		cpu_to_le32(0xC000010F) // -EIO
+#define STATUS_ABIOS_LID_NOT_EXIST		cpu_to_le32(0xC0000110) // -EIO
+#define STATUS_ABIOS_LID_ALREADY_OWNED		cpu_to_le32(0xC0000111) // -EIO
+#define STATUS_ABIOS_NOT_LID_OWNER		cpu_to_le32(0xC0000112) // -EIO
+#define STATUS_ABIOS_INVALID_COMMAND		cpu_to_le32(0xC0000113) // -EIO
+#define STATUS_ABIOS_INVALID_LID		cpu_to_le32(0xC0000114) // -EIO
+#define STATUS_ABIOS_SELECTOR_NOT_AVAILABLE	cpu_to_le32(0xC0000115) // -EIO
+#define STATUS_ABIOS_INVALID_SELECTOR		cpu_to_le32(0xC0000116) // -EIO
+#define STATUS_NO_LDT				cpu_to_le32(0xC0000117) // -EIO
+#define STATUS_INVALID_LDT_SIZE			cpu_to_le32(0xC0000118) // -EIO
+#define STATUS_INVALID_LDT_OFFSET		cpu_to_le32(0xC0000119) // -EIO
+#define STATUS_INVALID_LDT_DESCRIPTOR		cpu_to_le32(0xC000011A) // -EIO
+#define STATUS_INVALID_IMAGE_NE_FORMAT		cpu_to_le32(0xC000011B) // -EIO
+#define STATUS_RXACT_INVALID_STATE		cpu_to_le32(0xC000011C) // -EIO
+#define STATUS_RXACT_COMMIT_FAILURE		cpu_to_le32(0xC000011D) // -EIO
+#define STATUS_MAPPED_FILE_SIZE_ZERO		cpu_to_le32(0xC000011E) // -EIO
+#define STATUS_TOO_MANY_OPENED_FILES		cpu_to_le32(0xC000011F) // -EMFILE
+#define STATUS_CANCELLED			cpu_to_le32(0xC0000120) // -EIO
+#define STATUS_CANNOT_DELETE			cpu_to_le32(0xC0000121) // -EACCES
+#define STATUS_INVALID_COMPUTER_NAME		cpu_to_le32(0xC0000122) // -EIO
+#define STATUS_FILE_DELETED			cpu_to_le32(0xC0000123) // -EIO
+#define STATUS_SPECIAL_ACCOUNT			cpu_to_le32(0xC0000124) // -EIO
+#define STATUS_SPECIAL_GROUP			cpu_to_le32(0xC0000125) // -EIO
+#define STATUS_SPECIAL_USER			cpu_to_le32(0xC0000126) // -EIO
+#define STATUS_MEMBERS_PRIMARY_GROUP		cpu_to_le32(0xC0000127) // -EIO
+#define STATUS_FILE_CLOSED			cpu_to_le32(0xC0000128) // -EBADF
+#define STATUS_TOO_MANY_THREADS			cpu_to_le32(0xC0000129) // -EIO
+#define STATUS_THREAD_NOT_IN_PROCESS		cpu_to_le32(0xC000012A) // -EIO
+#define STATUS_TOKEN_ALREADY_IN_USE		cpu_to_le32(0xC000012B) // -EIO
+#define STATUS_PAGEFILE_QUOTA_EXCEEDED		cpu_to_le32(0xC000012C) // -EDQUOT
+#define STATUS_COMMITMENT_LIMIT			cpu_to_le32(0xC000012D) // -EIO
+#define STATUS_INVALID_IMAGE_LE_FORMAT		cpu_to_le32(0xC000012E) // -EIO
+#define STATUS_INVALID_IMAGE_NOT_MZ		cpu_to_le32(0xC000012F) // -EIO
+#define STATUS_INVALID_IMAGE_PROTECT		cpu_to_le32(0xC0000130) // -EIO
+#define STATUS_INVALID_IMAGE_WIN_16		cpu_to_le32(0xC0000131) // -EIO
+#define STATUS_LOGON_SERVER_CONFLICT		cpu_to_le32(0xC0000132) // -EIO
+#define STATUS_TIME_DIFFERENCE_AT_DC		cpu_to_le32(0xC0000133) // -EIO
+#define STATUS_SYNCHRONIZATION_REQUIRED		cpu_to_le32(0xC0000134) // -EIO
+#define STATUS_DLL_NOT_FOUND			cpu_to_le32(0xC0000135) // -ENOENT
+#define STATUS_OPEN_FAILED			cpu_to_le32(0xC0000136) // -EIO
+#define STATUS_IO_PRIVILEGE_FAILED		cpu_to_le32(0xC0000137) // -EIO
+#define STATUS_ORDINAL_NOT_FOUND		cpu_to_le32(0xC0000138) // -EIO
+#define STATUS_ENTRYPOINT_NOT_FOUND		cpu_to_le32(0xC0000139) // -EIO
+#define STATUS_CONTROL_C_EXIT			cpu_to_le32(0xC000013A) // -EIO
+#define STATUS_LOCAL_DISCONNECT			cpu_to_le32(0xC000013B) // -EIO
+#define STATUS_REMOTE_DISCONNECT		cpu_to_le32(0xC000013C) // -ESHUTDOWN
+#define STATUS_REMOTE_RESOURCES			cpu_to_le32(0xC000013D) // -EIO
+#define STATUS_LINK_FAILED			cpu_to_le32(0xC000013E) // -EXDEV
+#define STATUS_LINK_TIMEOUT			cpu_to_le32(0xC000013F) // -ETIMEDOUT
+#define STATUS_INVALID_CONNECTION		cpu_to_le32(0xC0000140) // -EIO
+#define STATUS_INVALID_ADDRESS			cpu_to_le32(0xC0000141) // -EIO
+#define STATUS_DLL_INIT_FAILED			cpu_to_le32(0xC0000142) // -EIO
+#define STATUS_MISSING_SYSTEMFILE		cpu_to_le32(0xC0000143) // -EIO
+#define STATUS_UNHANDLED_EXCEPTION		cpu_to_le32(0xC0000144) // -EIO
+#define STATUS_APP_INIT_FAILURE			cpu_to_le32(0xC0000145) // -EIO
+#define STATUS_PAGEFILE_CREATE_FAILED		cpu_to_le32(0xC0000146) // -EIO
+#define STATUS_NO_PAGEFILE			cpu_to_le32(0xC0000147) // -EIO
+#define STATUS_INVALID_LEVEL			cpu_to_le32(0xC0000148) // -EIO
+#define STATUS_WRONG_PASSWORD_CORE		cpu_to_le32(0xC0000149) // -EIO
+#define STATUS_ILLEGAL_FLOAT_CONTEXT		cpu_to_le32(0xC000014A) // -EIO
+#define STATUS_PIPE_BROKEN			cpu_to_le32(0xC000014B) // -EPIPE
+#define STATUS_REGISTRY_CORRUPT			cpu_to_le32(0xC000014C) // -EIO
+#define STATUS_REGISTRY_IO_FAILED		cpu_to_le32(0xC000014D) // -EIO
+#define STATUS_NO_EVENT_PAIR			cpu_to_le32(0xC000014E) // -EIO
+#define STATUS_UNRECOGNIZED_VOLUME		cpu_to_le32(0xC000014F) // -EIO
+#define STATUS_SERIAL_NO_DEVICE_INITED		cpu_to_le32(0xC0000150) // -EIO
+#define STATUS_NO_SUCH_ALIAS			cpu_to_le32(0xC0000151) // -EIO
+#define STATUS_MEMBER_NOT_IN_ALIAS		cpu_to_le32(0xC0000152) // -EIO
+#define STATUS_MEMBER_IN_ALIAS			cpu_to_le32(0xC0000153) // -EIO
+#define STATUS_ALIAS_EXISTS			cpu_to_le32(0xC0000154) // -EIO
+#define STATUS_LOGON_NOT_GRANTED		cpu_to_le32(0xC0000155) // -EIO
+#define STATUS_TOO_MANY_SECRETS			cpu_to_le32(0xC0000156) // -EIO
+#define STATUS_SECRET_TOO_LONG			cpu_to_le32(0xC0000157) // -EIO
+#define STATUS_INTERNAL_DB_ERROR		cpu_to_le32(0xC0000158) // -EIO
+#define STATUS_FULLSCREEN_MODE			cpu_to_le32(0xC0000159) // -EIO
+#define STATUS_TOO_MANY_CONTEXT_IDS		cpu_to_le32(0xC000015A) // -EIO
+#define STATUS_LOGON_TYPE_NOT_GRANTED		cpu_to_le32(0xC000015B) // -EIO
+#define STATUS_NOT_REGISTRY_FILE		cpu_to_le32(0xC000015C) // -EIO
+#define STATUS_NT_CROSS_ENCRYPTION_REQUIRED	cpu_to_le32(0xC000015D) // -EIO
+#define STATUS_DOMAIN_CTRLR_CONFIG_ERROR	cpu_to_le32(0xC000015E) // -EIO
+#define STATUS_FT_MISSING_MEMBER		cpu_to_le32(0xC000015F) // -EIO
+#define STATUS_ILL_FORMED_SERVICE_ENTRY		cpu_to_le32(0xC0000160) // -EIO
+#define STATUS_ILLEGAL_CHARACTER		cpu_to_le32(0xC0000161) // -EIO
+#define STATUS_UNMAPPABLE_CHARACTER		cpu_to_le32(0xC0000162) // -EIO
+#define STATUS_UNDEFINED_CHARACTER		cpu_to_le32(0xC0000163) // -EIO
+#define STATUS_FLOPPY_VOLUME			cpu_to_le32(0xC0000164) // -EIO
+#define STATUS_FLOPPY_ID_MARK_NOT_FOUND		cpu_to_le32(0xC0000165) // -EIO
+#define STATUS_FLOPPY_WRONG_CYLINDER		cpu_to_le32(0xC0000166) // -EIO
+#define STATUS_FLOPPY_UNKNOWN_ERROR		cpu_to_le32(0xC0000167) // -EIO
+#define STATUS_FLOPPY_BAD_REGISTERS		cpu_to_le32(0xC0000168) // -EIO
+#define STATUS_DISK_RECALIBRATE_FAILED		cpu_to_le32(0xC0000169) // -EIO
+#define STATUS_DISK_OPERATION_FAILED		cpu_to_le32(0xC000016A) // -EIO
+#define STATUS_DISK_RESET_FAILED		cpu_to_le32(0xC000016B) // -EIO
+#define STATUS_SHARED_IRQ_BUSY			cpu_to_le32(0xC000016C) // -EBUSY
+#define STATUS_FT_ORPHANING			cpu_to_le32(0xC000016D) // -EIO
+#define STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT	cpu_to_le32(0xC000016E) // -EIO
+#define STATUS_PARTITION_FAILURE		cpu_to_le32(0xC0000172) // -EIO
+#define STATUS_INVALID_BLOCK_LENGTH		cpu_to_le32(0xC0000173) // -EIO
+#define STATUS_DEVICE_NOT_PARTITIONED		cpu_to_le32(0xC0000174) // -EIO
+#define STATUS_UNABLE_TO_LOCK_MEDIA		cpu_to_le32(0xC0000175) // -EIO
+#define STATUS_UNABLE_TO_UNLOAD_MEDIA		cpu_to_le32(0xC0000176) // -EIO
+#define STATUS_EOM_OVERFLOW			cpu_to_le32(0xC0000177) // -EIO
+#define STATUS_NO_MEDIA				cpu_to_le32(0xC0000178) // -EIO
+#define STATUS_NO_SUCH_MEMBER			cpu_to_le32(0xC000017A) // -EIO
+#define STATUS_INVALID_MEMBER			cpu_to_le32(0xC000017B) // -EIO
+#define STATUS_KEY_DELETED			cpu_to_le32(0xC000017C) // -EIO
+#define STATUS_NO_LOG_SPACE			cpu_to_le32(0xC000017D) // -EIO
+#define STATUS_TOO_MANY_SIDS			cpu_to_le32(0xC000017E) // -EIO
+#define STATUS_LM_CROSS_ENCRYPTION_REQUIRED	cpu_to_le32(0xC000017F) // -EIO
+#define STATUS_KEY_HAS_CHILDREN			cpu_to_le32(0xC0000180) // -EIO
+#define STATUS_CHILD_MUST_BE_VOLATILE		cpu_to_le32(0xC0000181) // -EIO
+#define STATUS_DEVICE_CONFIGURATION_ERROR	cpu_to_le32(0xC0000182) // -EIO
+#define STATUS_DRIVER_INTERNAL_ERROR		cpu_to_le32(0xC0000183) // -EIO
+#define STATUS_INVALID_DEVICE_STATE		cpu_to_le32(0xC0000184) // -EIO
+#define STATUS_IO_DEVICE_ERROR			cpu_to_le32(0xC0000185) // -EIO
+#define STATUS_DEVICE_PROTOCOL_ERROR		cpu_to_le32(0xC0000186) // -EIO
+#define STATUS_BACKUP_CONTROLLER		cpu_to_le32(0xC0000187) // -EIO
+#define STATUS_LOG_FILE_FULL			cpu_to_le32(0xC0000188) // -EIO
+#define STATUS_TOO_LATE				cpu_to_le32(0xC0000189) // -EIO
+#define STATUS_NO_TRUST_LSA_SECRET		cpu_to_le32(0xC000018A) // -EIO
+#define STATUS_NO_TRUST_SAM_ACCOUNT		cpu_to_le32(0xC000018B) // -EIO
+#define STATUS_TRUSTED_DOMAIN_FAILURE		cpu_to_le32(0xC000018C) // -EIO
+#define STATUS_TRUSTED_RELATIONSHIP_FAILURE	cpu_to_le32(0xC000018D) // -EIO
+#define STATUS_EVENTLOG_FILE_CORRUPT		cpu_to_le32(0xC000018E) // -EIO
+#define STATUS_EVENTLOG_CANT_START		cpu_to_le32(0xC000018F) // -EIO
+#define STATUS_TRUST_FAILURE			cpu_to_le32(0xC0000190) // -EIO
+#define STATUS_MUTANT_LIMIT_EXCEEDED		cpu_to_le32(0xC0000191) // -EIO
+#define STATUS_NETLOGON_NOT_STARTED		cpu_to_le32(0xC0000192) // -EIO
+#define STATUS_ACCOUNT_EXPIRED			cpu_to_le32(0xC0000193) // -EKEYEXPIRED
+#define STATUS_POSSIBLE_DEADLOCK		cpu_to_le32(0xC0000194) // -EIO
+#define STATUS_NETWORK_CREDENTIAL_CONFLICT	cpu_to_le32(0xC0000195) // -EIO
+#define STATUS_REMOTE_SESSION_LIMIT		cpu_to_le32(0xC0000196) // -EIO
+#define STATUS_EVENTLOG_FILE_CHANGED		cpu_to_le32(0xC0000197) // -EIO
+#define STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT cpu_to_le32(0xC0000198) // -EIO
+#define STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT cpu_to_le32(0xC0000199) // -EIO
+#define STATUS_NOLOGON_SERVER_TRUST_ACCOUNT	cpu_to_le32(0xC000019A) // -EIO
+#define STATUS_DOMAIN_TRUST_INCONSISTENT	cpu_to_le32(0xC000019B) // -EIO
+#define STATUS_FS_DRIVER_REQUIRED		cpu_to_le32(0xC000019C) // -EOPNOTSUPP
+#define STATUS_IMAGE_ALREADY_LOADED_AS_DLL	cpu_to_le32(0xC000019D) // -EIO
+#define STATUS_INVALID_LOCK_RANGE		cpu_to_le32(0xC00001A1) // -EIO
+#define STATUS_NETWORK_OPEN_RESTRICTION		cpu_to_le32(0xC0000201) // -EIO
+#define STATUS_NO_USER_SESSION_KEY		cpu_to_le32(0xC0000202) // -EIO
+#define STATUS_USER_SESSION_DELETED		cpu_to_le32(0xC0000203) // -EIO
+#define STATUS_RESOURCE_LANG_NOT_FOUND		cpu_to_le32(0xC0000204) // -EIO
+#define STATUS_INSUFF_SERVER_RESOURCES		cpu_to_le32(0xC0000205) // -EIO
+#define STATUS_INVALID_BUFFER_SIZE		cpu_to_le32(0xC0000206) // -EIO
+#define STATUS_INVALID_ADDRESS_COMPONENT	cpu_to_le32(0xC0000207) // -EIO
+#define STATUS_INVALID_ADDRESS_WILDCARD		cpu_to_le32(0xC0000208) // -EIO
+#define STATUS_TOO_MANY_ADDRESSES		cpu_to_le32(0xC0000209) // -EIO
+#define STATUS_ADDRESS_ALREADY_EXISTS		cpu_to_le32(0xC000020A) // -EADDRINUSE
+#define STATUS_ADDRESS_CLOSED			cpu_to_le32(0xC000020B) // -EIO
+#define STATUS_CONNECTION_DISCONNECTED		cpu_to_le32(0xC000020C) // -ECONNABORTED
+#define STATUS_CONNECTION_RESET			cpu_to_le32(0xC000020D) // -ENETRESET
+#define STATUS_TOO_MANY_NODES			cpu_to_le32(0xC000020E) // -EIO
+#define STATUS_TRANSACTION_ABORTED		cpu_to_le32(0xC000020F) // -EIO
+#define STATUS_TRANSACTION_TIMED_OUT		cpu_to_le32(0xC0000210) // -EIO
+#define STATUS_TRANSACTION_NO_RELEASE		cpu_to_le32(0xC0000211) // -EIO
+#define STATUS_TRANSACTION_NO_MATCH		cpu_to_le32(0xC0000212) // -EIO
+#define STATUS_TRANSACTION_RESPONDED		cpu_to_le32(0xC0000213) // -EIO
+#define STATUS_TRANSACTION_INVALID_ID		cpu_to_le32(0xC0000214) // -EIO
+#define STATUS_TRANSACTION_INVALID_TYPE		cpu_to_le32(0xC0000215) // -EIO
+#define STATUS_NOT_SERVER_SESSION		cpu_to_le32(0xC0000216) // -EIO
+#define STATUS_NOT_CLIENT_SESSION		cpu_to_le32(0xC0000217) // -EIO
+#define STATUS_CANNOT_LOAD_REGISTRY_FILE	cpu_to_le32(0xC0000218) // -EIO
+#define STATUS_DEBUG_ATTACH_FAILED		cpu_to_le32(0xC0000219) // -EIO
+#define STATUS_SYSTEM_PROCESS_TERMINATED	cpu_to_le32(0xC000021A) // -EIO
+#define STATUS_DATA_NOT_ACCEPTED		cpu_to_le32(0xC000021B) // -EIO
+#define STATUS_NO_BROWSER_SERVERS_FOUND		cpu_to_le32(0xC000021C) // -EIO
+#define STATUS_VDM_HARD_ERROR			cpu_to_le32(0xC000021D) // -EIO
+#define STATUS_DRIVER_CANCEL_TIMEOUT		cpu_to_le32(0xC000021E) // -EIO
+#define STATUS_REPLY_MESSAGE_MISMATCH		cpu_to_le32(0xC000021F) // -EIO
+#define STATUS_MAPPED_ALIGNMENT			cpu_to_le32(0xC0000220) // -EIO
+#define STATUS_IMAGE_CHECKSUM_MISMATCH		cpu_to_le32(0xC0000221) // -EIO
+#define STATUS_LOST_WRITEBEHIND_DATA		cpu_to_le32(0xC0000222) // -EIO
+#define STATUS_CLIENT_SERVER_PARAMETERS_INVALID	cpu_to_le32(0xC0000223) // -EIO
+#define STATUS_PASSWORD_MUST_CHANGE		cpu_to_le32(0xC0000224) // -EIO
+#define STATUS_NOT_FOUND			cpu_to_le32(0xC0000225) // -ENOENT
+#define STATUS_NOT_TINY_STREAM			cpu_to_le32(0xC0000226) // -EIO
+#define STATUS_RECOVERY_FAILURE			cpu_to_le32(0xC0000227) // -EIO
+#define STATUS_STACK_OVERFLOW_READ		cpu_to_le32(0xC0000228) // -EIO
+#define STATUS_FAIL_CHECK			cpu_to_le32(0xC0000229) // -EIO
+#define STATUS_DUPLICATE_OBJECTID		cpu_to_le32(0xC000022A) // -EIO
+#define STATUS_OBJECTID_EXISTS			cpu_to_le32(0xC000022B) // -EIO
+#define STATUS_CONVERT_TO_LARGE			cpu_to_le32(0xC000022C) // -EIO
+#define STATUS_RETRY				cpu_to_le32(0xC000022D) // -EAGAIN
+#define STATUS_FOUND_OUT_OF_SCOPE		cpu_to_le32(0xC000022E) // -EIO
+#define STATUS_ALLOCATE_BUCKET			cpu_to_le32(0xC000022F) // -EIO
+#define STATUS_PROPSET_NOT_FOUND		cpu_to_le32(0xC0000230) // -EIO
+#define STATUS_MARSHALL_OVERFLOW		cpu_to_le32(0xC0000231) // -EIO
+#define STATUS_INVALID_VARIANT			cpu_to_le32(0xC0000232) // -EIO
+#define STATUS_DOMAIN_CONTROLLER_NOT_FOUND	cpu_to_le32(0xC0000233) // -EIO
+#define STATUS_ACCOUNT_LOCKED_OUT		cpu_to_le32(0xC0000234) // -EACCES
+#define STATUS_HANDLE_NOT_CLOSABLE		cpu_to_le32(0xC0000235) // -EIO
+#define STATUS_CONNECTION_REFUSED		cpu_to_le32(0xC0000236) // -EIO
+#define STATUS_GRACEFUL_DISCONNECT		cpu_to_le32(0xC0000237) // -EIO
+#define STATUS_ADDRESS_ALREADY_ASSOCIATED	cpu_to_le32(0xC0000238) // -EIO
+#define STATUS_ADDRESS_NOT_ASSOCIATED		cpu_to_le32(0xC0000239) // -EIO
+#define STATUS_CONNECTION_INVALID		cpu_to_le32(0xC000023A) // -EIO
+#define STATUS_CONNECTION_ACTIVE		cpu_to_le32(0xC000023B) // -EIO
+#define STATUS_NETWORK_UNREACHABLE		cpu_to_le32(0xC000023C) // -ENETUNREACH
+#define STATUS_HOST_UNREACHABLE			cpu_to_le32(0xC000023D) // -EHOSTDOWN
+#define STATUS_PROTOCOL_UNREACHABLE		cpu_to_le32(0xC000023E) // -ENETUNREACH
+#define STATUS_PORT_UNREACHABLE			cpu_to_le32(0xC000023F) // -ENETUNREACH
+#define STATUS_REQUEST_ABORTED			cpu_to_le32(0xC0000240) // -EIO
+#define STATUS_CONNECTION_ABORTED		cpu_to_le32(0xC0000241) // -ECONNABORTED
+#define STATUS_BAD_COMPRESSION_BUFFER		cpu_to_le32(0xC0000242) // -EIO
+#define STATUS_USER_MAPPED_FILE			cpu_to_le32(0xC0000243) // -EIO
+#define STATUS_AUDIT_FAILED			cpu_to_le32(0xC0000244) // -EIO
+#define STATUS_TIMER_RESOLUTION_NOT_SET		cpu_to_le32(0xC0000245) // -EIO
+#define STATUS_CONNECTION_COUNT_LIMIT		cpu_to_le32(0xC0000246) // -EIO
+#define STATUS_LOGIN_TIME_RESTRICTION		cpu_to_le32(0xC0000247) // -EACCES
+#define STATUS_LOGIN_WKSTA_RESTRICTION		cpu_to_le32(0xC0000248) // -EACCES
+#define STATUS_IMAGE_MP_UP_MISMATCH		cpu_to_le32(0xC0000249) // -EIO
+#define STATUS_INSUFFICIENT_LOGON_INFO		cpu_to_le32(0xC0000250) // -EIO
+#define STATUS_BAD_DLL_ENTRYPOINT		cpu_to_le32(0xC0000251) // -EIO
+#define STATUS_BAD_SERVICE_ENTRYPOINT		cpu_to_le32(0xC0000252) // -EIO
+#define STATUS_LPC_REPLY_LOST			cpu_to_le32(0xC0000253) // -EIO
+#define STATUS_IP_ADDRESS_CONFLICT1		cpu_to_le32(0xC0000254) // -EIO
+#define STATUS_IP_ADDRESS_CONFLICT2		cpu_to_le32(0xC0000255) // -EIO
+#define STATUS_REGISTRY_QUOTA_LIMIT		cpu_to_le32(0xC0000256) // -EDQUOT
+#define STATUS_PATH_NOT_COVERED			cpu_to_le32(0xC0000257) // -EREMOTE
+#define STATUS_NO_CALLBACK_ACTIVE		cpu_to_le32(0xC0000258) // -EIO
+#define STATUS_LICENSE_QUOTA_EXCEEDED		cpu_to_le32(0xC0000259) // -EACCES
+#define STATUS_PWD_TOO_SHORT			cpu_to_le32(0xC000025A) // -EIO
+#define STATUS_PWD_TOO_RECENT			cpu_to_le32(0xC000025B) // -EIO
+#define STATUS_PWD_HISTORY_CONFLICT		cpu_to_le32(0xC000025C) // -EIO
+#define STATUS_PLUGPLAY_NO_DEVICE		cpu_to_le32(0xC000025E) // -EIO
+#define STATUS_UNSUPPORTED_COMPRESSION		cpu_to_le32(0xC000025F) // -EIO
+#define STATUS_INVALID_HW_PROFILE		cpu_to_le32(0xC0000260) // -EIO
+#define STATUS_INVALID_PLUGPLAY_DEVICE_PATH	cpu_to_le32(0xC0000261) // -EIO
+#define STATUS_DRIVER_ORDINAL_NOT_FOUND		cpu_to_le32(0xC0000262) // -EIO
+#define STATUS_DRIVER_ENTRYPOINT_NOT_FOUND	cpu_to_le32(0xC0000263) // -EIO
+#define STATUS_RESOURCE_NOT_OWNED		cpu_to_le32(0xC0000264) // -EIO
+#define STATUS_TOO_MANY_LINKS			cpu_to_le32(0xC0000265) // -EMLINK
+#define STATUS_QUOTA_LIST_INCONSISTENT		cpu_to_le32(0xC0000266) // -EIO
+#define STATUS_FILE_IS_OFFLINE			cpu_to_le32(0xC0000267) // -EIO
+#define STATUS_EVALUATION_EXPIRATION		cpu_to_le32(0xC0000268) // -EIO
+#define STATUS_ILLEGAL_DLL_RELOCATION		cpu_to_le32(0xC0000269) // -EIO
+#define STATUS_LICENSE_VIOLATION		cpu_to_le32(0xC000026A) // -EIO
+#define STATUS_DLL_INIT_FAILED_LOGOFF		cpu_to_le32(0xC000026B) // -EIO
+#define STATUS_DRIVER_UNABLE_TO_LOAD		cpu_to_le32(0xC000026C) // -EIO
+#define STATUS_DFS_UNAVAILABLE			cpu_to_le32(0xC000026D) // -EIO
+#define STATUS_VOLUME_DISMOUNTED		cpu_to_le32(0xC000026E) // -EIO
+#define STATUS_WX86_INTERNAL_ERROR		cpu_to_le32(0xC000026F) // -EIO
+#define STATUS_WX86_FLOAT_STACK_CHECK		cpu_to_le32(0xC0000270) // -EIO
+#define STATUS_VALIDATE_CONTINUE		cpu_to_le32(0xC0000271) // -EIO
+#define STATUS_NO_MATCH				cpu_to_le32(0xC0000272) // -EIO
+#define STATUS_NO_MORE_MATCHES			cpu_to_le32(0xC0000273) // -EIO
+#define STATUS_NOT_A_REPARSE_POINT		cpu_to_le32(0xC0000275) // -ENODATA
+#define STATUS_IO_REPARSE_TAG_INVALID		cpu_to_le32(0xC0000276) // -EIO
+#define STATUS_IO_REPARSE_TAG_MISMATCH		cpu_to_le32(0xC0000277) // -EIO
+#define STATUS_IO_REPARSE_DATA_INVALID		cpu_to_le32(0xC0000278) // -EIO
+#define STATUS_IO_REPARSE_TAG_NOT_HANDLED	cpu_to_le32(0xC0000279) // -EOPNOTSUPP
+#define STATUS_REPARSE_POINT_NOT_RESOLVED	cpu_to_le32(0xC0000280) // -EIO
+#define STATUS_DIRECTORY_IS_A_REPARSE_POINT	cpu_to_le32(0xC0000281) // -EIO
+#define STATUS_RANGE_LIST_CONFLICT		cpu_to_le32(0xC0000282) // -EIO
+#define STATUS_SOURCE_ELEMENT_EMPTY		cpu_to_le32(0xC0000283) // -EIO
+#define STATUS_DESTINATION_ELEMENT_FULL		cpu_to_le32(0xC0000284) // -EIO
+#define STATUS_ILLEGAL_ELEMENT_ADDRESS		cpu_to_le32(0xC0000285) // -EIO
+#define STATUS_MAGAZINE_NOT_PRESENT		cpu_to_le32(0xC0000286) // -EIO
+#define STATUS_REINITIALIZATION_NEEDED		cpu_to_le32(0xC0000287) // -EIO
+#define STATUS_ENCRYPTION_FAILED		cpu_to_le32(0xC000028A) // -EIO
+#define STATUS_DECRYPTION_FAILED		cpu_to_le32(0xC000028B) // -EIO
+#define STATUS_RANGE_NOT_FOUND			cpu_to_le32(0xC000028C) // -EIO
+#define STATUS_NO_RECOVERY_POLICY		cpu_to_le32(0xC000028D) // -EIO
+#define STATUS_NO_EFS				cpu_to_le32(0xC000028E) // -EIO
+#define STATUS_WRONG_EFS			cpu_to_le32(0xC000028F) // -EIO
+#define STATUS_NO_USER_KEYS			cpu_to_le32(0xC0000290) // -EIO
+#define STATUS_FILE_NOT_ENCRYPTED		cpu_to_le32(0xC0000291) // -EIO
+#define STATUS_NOT_EXPORT_FORMAT		cpu_to_le32(0xC0000292) // -EIO
+#define STATUS_FILE_ENCRYPTED			cpu_to_le32(0xC0000293) // -EIO
+#define STATUS_WMI_GUID_NOT_FOUND		cpu_to_le32(0xC0000295) // -EIO
+#define STATUS_WMI_INSTANCE_NOT_FOUND		cpu_to_le32(0xC0000296) // -EIO
+#define STATUS_WMI_ITEMID_NOT_FOUND		cpu_to_le32(0xC0000297) // -EIO
+#define STATUS_WMI_TRY_AGAIN			cpu_to_le32(0xC0000298) // -EIO
+#define STATUS_SHARED_POLICY			cpu_to_le32(0xC0000299) // -EIO
+#define STATUS_POLICY_OBJECT_NOT_FOUND		cpu_to_le32(0xC000029A) // -EIO
+#define STATUS_POLICY_ONLY_IN_DS		cpu_to_le32(0xC000029B) // -EIO
+#define STATUS_VOLUME_NOT_UPGRADED		cpu_to_le32(0xC000029C) // -EIO
+#define STATUS_REMOTE_STORAGE_NOT_ACTIVE	cpu_to_le32(0xC000029D) // -EIO
+#define STATUS_REMOTE_STORAGE_MEDIA_ERROR	cpu_to_le32(0xC000029E) // -EIO
+#define STATUS_NO_TRACKING_SERVICE		cpu_to_le32(0xC000029F) // -EIO
+#define STATUS_SERVER_SID_MISMATCH		cpu_to_le32(0xC00002A0) // -EIO
+#define STATUS_DS_NO_ATTRIBUTE_OR_VALUE		cpu_to_le32(0xC00002A1) // -EIO
+#define STATUS_DS_INVALID_ATTRIBUTE_SYNTAX	cpu_to_le32(0xC00002A2) // -EIO
+#define STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED	cpu_to_le32(0xC00002A3) // -EIO
+#define STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS	cpu_to_le32(0xC00002A4) // -EIO
+#define STATUS_DS_BUSY				cpu_to_le32(0xC00002A5) // -EBUSY
+#define STATUS_DS_UNAVAILABLE			cpu_to_le32(0xC00002A6) // -EIO
+#define STATUS_DS_NO_RIDS_ALLOCATED		cpu_to_le32(0xC00002A7) // -EIO
+#define STATUS_DS_NO_MORE_RIDS			cpu_to_le32(0xC00002A8) // -EIO
+#define STATUS_DS_INCORRECT_ROLE_OWNER		cpu_to_le32(0xC00002A9) // -EIO
+#define STATUS_DS_RIDMGR_INIT_ERROR		cpu_to_le32(0xC00002AA) // -EIO
+#define STATUS_DS_OBJ_CLASS_VIOLATION		cpu_to_le32(0xC00002AB) // -EIO
+#define STATUS_DS_CANT_ON_NON_LEAF		cpu_to_le32(0xC00002AC) // -EIO
+#define STATUS_DS_CANT_ON_RDN			cpu_to_le32(0xC00002AD) // -EIO
+#define STATUS_DS_CANT_MOD_OBJ_CLASS		cpu_to_le32(0xC00002AE) // -EIO
+#define STATUS_DS_CROSS_DOM_MOVE_FAILED		cpu_to_le32(0xC00002AF) // -EIO
+#define STATUS_DS_GC_NOT_AVAILABLE		cpu_to_le32(0xC00002B0) // -EIO
+#define STATUS_DIRECTORY_SERVICE_REQUIRED	cpu_to_le32(0xC00002B1) // -EIO
+#define STATUS_REPARSE_ATTRIBUTE_CONFLICT	cpu_to_le32(0xC00002B2) // -EIO
+#define STATUS_CANT_ENABLE_DENY_ONLY		cpu_to_le32(0xC00002B3) // -EIO
+#define STATUS_FLOAT_MULTIPLE_FAULTS		cpu_to_le32(0xC00002B4) // -EIO
+#define STATUS_FLOAT_MULTIPLE_TRAPS		cpu_to_le32(0xC00002B5) // -EIO
+#define STATUS_DEVICE_REMOVED			cpu_to_le32(0xC00002B6) // -EIO
+#define STATUS_JOURNAL_DELETE_IN_PROGRESS	cpu_to_le32(0xC00002B7) // -EIO
+#define STATUS_JOURNAL_NOT_ACTIVE		cpu_to_le32(0xC00002B8) // -EIO
+#define STATUS_NOINTERFACE			cpu_to_le32(0xC00002B9) // -EIO
+#define STATUS_DS_ADMIN_LIMIT_EXCEEDED		cpu_to_le32(0xC00002C1) // -EIO
+#define STATUS_DRIVER_FAILED_SLEEP		cpu_to_le32(0xC00002C2) // -EIO
+#define STATUS_MUTUAL_AUTHENTICATION_FAILED	cpu_to_le32(0xC00002C3) // -EIO
+#define STATUS_CORRUPT_SYSTEM_FILE		cpu_to_le32(0xC00002C4) // -EIO
+#define STATUS_DATATYPE_MISALIGNMENT_ERROR	cpu_to_le32(0xC00002C5) // -EIO
+#define STATUS_WMI_READ_ONLY			cpu_to_le32(0xC00002C6) // -EROFS
+#define STATUS_WMI_SET_FAILURE			cpu_to_le32(0xC00002C7) // -EIO
+#define STATUS_COMMITMENT_MINIMUM		cpu_to_le32(0xC00002C8) // -EIO
+#define STATUS_REG_NAT_CONSUMPTION		cpu_to_le32(0xC00002C9) // -EIO
+#define STATUS_TRANSPORT_FULL			cpu_to_le32(0xC00002CA) // -EIO
+#define STATUS_DS_SAM_INIT_FAILURE		cpu_to_le32(0xC00002CB) // -EIO
+#define STATUS_ONLY_IF_CONNECTED		cpu_to_le32(0xC00002CC) // -EIO
+#define STATUS_DS_SENSITIVE_GROUP_VIOLATION	cpu_to_le32(0xC00002CD) // -EIO
+#define STATUS_PNP_RESTART_ENUMERATION		cpu_to_le32(0xC00002CE) // -EIO
+#define STATUS_JOURNAL_ENTRY_DELETED		cpu_to_le32(0xC00002CF) // -EIO
+#define STATUS_DS_CANT_MOD_PRIMARYGROUPID	cpu_to_le32(0xC00002D0) // -EIO
+#define STATUS_SYSTEM_IMAGE_BAD_SIGNATURE	cpu_to_le32(0xC00002D1) // -EIO
+#define STATUS_PNP_REBOOT_REQUIRED		cpu_to_le32(0xC00002D2) // -EIO
+#define STATUS_POWER_STATE_INVALID		cpu_to_le32(0xC00002D3) // -EIO
+#define STATUS_DS_INVALID_GROUP_TYPE		cpu_to_le32(0xC00002D4) // -EIO
+#define STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN cpu_to_le32(0xC00002D5) // -EIO
+#define STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN cpu_to_le32(0xC00002D6) // -EIO
+#define STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER	cpu_to_le32(0xC00002D7) // -EIO
+#define STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER cpu_to_le32(0xC00002D8) // -EIO
+#define STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER cpu_to_le32(0xC00002D9) // -EIO
+#define STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER cpu_to_le32(0xC00002DA) // -EIO
+#define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER cpu_to_le32(0xC00002DB) // -EIO
+#define STATUS_DS_HAVE_PRIMARY_MEMBERS		cpu_to_le32(0xC00002DC) // -EIO
+#define STATUS_WMI_NOT_SUPPORTED		cpu_to_le32(0xC00002DD) // -EOPNOTSUPP
+#define STATUS_INSUFFICIENT_POWER		cpu_to_le32(0xC00002DE) // -EIO
+#define STATUS_SAM_NEED_BOOTKEY_PASSWORD	cpu_to_le32(0xC00002DF) // -EIO
+#define STATUS_SAM_NEED_BOOTKEY_FLOPPY		cpu_to_le32(0xC00002E0) // -EIO
+#define STATUS_DS_CANT_START			cpu_to_le32(0xC00002E1) // -EIO
+#define STATUS_DS_INIT_FAILURE			cpu_to_le32(0xC00002E2) // -EIO
+#define STATUS_SAM_INIT_FAILURE			cpu_to_le32(0xC00002E3) // -EIO
+#define STATUS_DS_GC_REQUIRED			cpu_to_le32(0xC00002E4) // -EIO
+#define STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY	cpu_to_le32(0xC00002E5) // -EIO
+#define STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS	cpu_to_le32(0xC00002E6) // -EIO
+#define STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED cpu_to_le32(0xC00002E7) // -EDQUOT
+#define STATUS_MULTIPLE_FAULT_VIOLATION		cpu_to_le32(0xC00002E8) // -EIO
+#define STATUS_CURRENT_DOMAIN_NOT_ALLOWED	cpu_to_le32(0xC00002E9) // -EIO
+#define STATUS_CANNOT_MAKE			cpu_to_le32(0xC00002EA) // -EIO
+#define STATUS_SYSTEM_SHUTDOWN			cpu_to_le32(0xC00002EB) // -EIO
+#define STATUS_DS_INIT_FAILURE_CONSOLE		cpu_to_le32(0xC00002EC) // -EIO
+#define STATUS_DS_SAM_INIT_FAILURE_CONSOLE	cpu_to_le32(0xC00002ED) // -EIO
+#define STATUS_UNFINISHED_CONTEXT_DELETED	cpu_to_le32(0xC00002EE) // -EIO
+#define STATUS_NO_TGT_REPLY			cpu_to_le32(0xC00002EF) // -EIO
+#define STATUS_OBJECTID_NOT_FOUND		cpu_to_le32(0xC00002F0) // -ENODATA
+#define STATUS_NO_IP_ADDRESSES			cpu_to_le32(0xC00002F1) // -EIO
+#define STATUS_WRONG_CREDENTIAL_HANDLE		cpu_to_le32(0xC00002F2) // -EIO
+#define STATUS_CRYPTO_SYSTEM_INVALID		cpu_to_le32(0xC00002F3) // -EIO
+#define STATUS_MAX_REFERRALS_EXCEEDED		cpu_to_le32(0xC00002F4) // -EIO
+#define STATUS_MUST_BE_KDC			cpu_to_le32(0xC00002F5) // -EIO
+#define STATUS_STRONG_CRYPTO_NOT_SUPPORTED	cpu_to_le32(0xC00002F6) // -EIO
+#define STATUS_TOO_MANY_PRINCIPALS		cpu_to_le32(0xC00002F7) // -EIO
+#define STATUS_NO_PA_DATA			cpu_to_le32(0xC00002F8) // -EIO
+#define STATUS_PKINIT_NAME_MISMATCH		cpu_to_le32(0xC00002F9) // -EIO
+#define STATUS_SMARTCARD_LOGON_REQUIRED		cpu_to_le32(0xC00002FA) // -EIO
+#define STATUS_KDC_INVALID_REQUEST		cpu_to_le32(0xC00002FB) // -EIO
+#define STATUS_KDC_UNABLE_TO_REFER		cpu_to_le32(0xC00002FC) // -EIO
+#define STATUS_KDC_UNKNOWN_ETYPE		cpu_to_le32(0xC00002FD) // -EIO
+#define STATUS_SHUTDOWN_IN_PROGRESS		cpu_to_le32(0xC00002FE) // -EIO
+#define STATUS_SERVER_SHUTDOWN_IN_PROGRESS	cpu_to_le32(0xC00002FF) // -EIO
+#define STATUS_NOT_SUPPORTED_ON_SBS		cpu_to_le32(0xC0000300) // -EOPNOTSUPP
+#define STATUS_WMI_GUID_DISCONNECTED		cpu_to_le32(0xC0000301) // -EIO
+#define STATUS_WMI_ALREADY_DISABLED		cpu_to_le32(0xC0000302) // -EIO
+#define STATUS_WMI_ALREADY_ENABLED		cpu_to_le32(0xC0000303) // -EIO
+#define STATUS_MFT_TOO_FRAGMENTED		cpu_to_le32(0xC0000304) // -EIO
+#define STATUS_COPY_PROTECTION_FAILURE		cpu_to_le32(0xC0000305) // -EIO
+#define STATUS_CSS_AUTHENTICATION_FAILURE	cpu_to_le32(0xC0000306) // -EIO
+#define STATUS_CSS_KEY_NOT_PRESENT		cpu_to_le32(0xC0000307) // -EIO
+#define STATUS_CSS_KEY_NOT_ESTABLISHED		cpu_to_le32(0xC0000308) // -EIO
+#define STATUS_CSS_SCRAMBLED_SECTOR		cpu_to_le32(0xC0000309) // -EIO
+#define STATUS_CSS_REGION_MISMATCH		cpu_to_le32(0xC000030A) // -EIO
+#define STATUS_CSS_RESETS_EXHAUSTED		cpu_to_le32(0xC000030B) // -EIO
+#define STATUS_PKINIT_FAILURE			cpu_to_le32(0xC0000320) // -EIO
+#define STATUS_SMARTCARD_SUBSYSTEM_FAILURE	cpu_to_le32(0xC0000321) // -EIO
+#define STATUS_NO_KERB_KEY			cpu_to_le32(0xC0000322) // -EIO
+#define STATUS_HOST_DOWN			cpu_to_le32(0xC0000350) // -EIO
+#define STATUS_UNSUPPORTED_PREAUTH		cpu_to_le32(0xC0000351) // -EIO
+#define STATUS_EFS_ALG_BLOB_TOO_BIG		cpu_to_le32(0xC0000352) // -EIO
+#define STATUS_PORT_NOT_SET			cpu_to_le32(0xC0000353) // -EIO
+#define STATUS_DEBUGGER_INACTIVE		cpu_to_le32(0xC0000354) // -EIO
+#define STATUS_DS_VERSION_CHECK_FAILURE		cpu_to_le32(0xC0000355) // -EIO
+#define STATUS_AUDITING_DISABLED		cpu_to_le32(0xC0000356) // -EIO
+#define STATUS_PRENT4_MACHINE_ACCOUNT		cpu_to_le32(0xC0000357) // -EIO
+#define STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER	cpu_to_le32(0xC0000358) // -EIO
+#define STATUS_INVALID_IMAGE_WIN_32		cpu_to_le32(0xC0000359) // -EIO
+#define STATUS_INVALID_IMAGE_WIN_64		cpu_to_le32(0xC000035A) // -EIO
+#define STATUS_BAD_BINDINGS			cpu_to_le32(0xC000035B) // -EIO
+#define STATUS_NETWORK_SESSION_EXPIRED		cpu_to_le32(0xC000035C) // -EIO
+#define STATUS_APPHELP_BLOCK			cpu_to_le32(0xC000035D) // -EIO
+#define STATUS_ALL_SIDS_FILTERED		cpu_to_le32(0xC000035E) // -EIO
+#define STATUS_NOT_SAFE_MODE_DRIVER		cpu_to_le32(0xC000035F) // -EIO
+#define STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT cpu_to_le32(0xC0000361) // -EACCES
+#define STATUS_ACCESS_DISABLED_BY_POLICY_PATH	cpu_to_le32(0xC0000362) // -EACCES
+#define STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER cpu_to_le32(0xC0000363) // -EACCES
+#define STATUS_ACCESS_DISABLED_BY_POLICY_OTHER	cpu_to_le32(0xC0000364) // -EACCES
+#define STATUS_FAILED_DRIVER_ENTRY		cpu_to_le32(0xC0000365) // -EIO
+#define STATUS_DEVICE_ENUMERATION_ERROR		cpu_to_le32(0xC0000366) // -EIO
+#define STATUS_MOUNT_POINT_NOT_RESOLVED		cpu_to_le32(0xC0000368) // -EIO
+#define STATUS_INVALID_DEVICE_OBJECT_PARAMETER	cpu_to_le32(0xC0000369) // -EIO
+/*
+ * 'OCCURED' is typo in MS-ERREF, it should be 'OCCURRED',
+ * but we'll keep it consistent with MS-ERREF.
+ */
+#define STATUS_MCA_OCCURED			cpu_to_le32(0xC000036A) // -EIO
+#define STATUS_DRIVER_BLOCKED_CRITICAL		cpu_to_le32(0xC000036B) // -EIO
+#define STATUS_DRIVER_BLOCKED			cpu_to_le32(0xC000036C) // -EIO
+#define STATUS_DRIVER_DATABASE_ERROR		cpu_to_le32(0xC000036D) // -EIO
+#define STATUS_SYSTEM_HIVE_TOO_LARGE		cpu_to_le32(0xC000036E) // -EIO
+#define STATUS_INVALID_IMPORT_OF_NON_DLL	cpu_to_le32(0xC000036F) // -EIO
+#define STATUS_NO_SECRETS			cpu_to_le32(0xC0000371) // -EIO
+#define STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY cpu_to_le32(0xC0000372) // -EACCES
+#define STATUS_FAILED_STACK_SWITCH		cpu_to_le32(0xC0000373) // -EIO
+#define STATUS_HEAP_CORRUPTION			cpu_to_le32(0xC0000374) // -EIO
+#define STATUS_SMARTCARD_WRONG_PIN		cpu_to_le32(0xC0000380) // -EIO
+#define STATUS_SMARTCARD_CARD_BLOCKED		cpu_to_le32(0xC0000381) // -EIO
+#define STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED	cpu_to_le32(0xC0000382) // -EIO
+#define STATUS_SMARTCARD_NO_CARD		cpu_to_le32(0xC0000383) // -EIO
+#define STATUS_SMARTCARD_NO_KEY_CONTAINER	cpu_to_le32(0xC0000384) // -EIO
+#define STATUS_SMARTCARD_NO_CERTIFICATE		cpu_to_le32(0xC0000385) // -EIO
+#define STATUS_SMARTCARD_NO_KEYSET		cpu_to_le32(0xC0000386) // -EIO
+#define STATUS_SMARTCARD_IO_ERROR		cpu_to_le32(0xC0000387) // -EIO
+#define STATUS_DOWNGRADE_DETECTED		cpu_to_le32(0xC0000388) // -EIO
+#define STATUS_SMARTCARD_CERT_REVOKED		cpu_to_le32(0xC0000389) // -EIO
+#define STATUS_ISSUING_CA_UNTRUSTED		cpu_to_le32(0xC000038A) // -EIO
+#define STATUS_REVOCATION_OFFLINE_C		cpu_to_le32(0xC000038B) // -EIO
+#define STATUS_PKINIT_CLIENT_FAILURE		cpu_to_le32(0xC000038C) // -EIO
+#define STATUS_SMARTCARD_CERT_EXPIRED		cpu_to_le32(0xC000038D) // -EIO
+#define STATUS_DRIVER_FAILED_PRIOR_UNLOAD	cpu_to_le32(0xC000038E) // -EIO
+#define STATUS_SMARTCARD_SILENT_CONTEXT		cpu_to_le32(0xC000038F) // -EIO
+#define STATUS_PER_USER_TRUST_QUOTA_EXCEEDED	cpu_to_le32(0xC0000401) // -EDQUOT
+#define STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED	cpu_to_le32(0xC0000402) // -EDQUOT
+#define STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED	cpu_to_le32(0xC0000403) // -EDQUOT
+#define STATUS_DS_NAME_NOT_UNIQUE		cpu_to_le32(0xC0000404) // -EIO
+#define STATUS_DS_DUPLICATE_ID_FOUND		cpu_to_le32(0xC0000405) // -EIO
+#define STATUS_DS_GROUP_CONVERSION_ERROR	cpu_to_le32(0xC0000406) // -EIO
+#define STATUS_VOLSNAP_PREPARE_HIBERNATE	cpu_to_le32(0xC0000407) // -EIO
+#define STATUS_USER2USER_REQUIRED		cpu_to_le32(0xC0000408) // -EIO
+#define STATUS_STACK_BUFFER_OVERRUN		cpu_to_le32(0xC0000409) // -EIO
+#define STATUS_NO_S4U_PROT_SUPPORT		cpu_to_le32(0xC000040A) // -EIO
+#define STATUS_CROSSREALM_DELEGATION_FAILURE	cpu_to_le32(0xC000040B) // -EIO
+#define STATUS_REVOCATION_OFFLINE_KDC		cpu_to_le32(0xC000040C) // -EIO
+#define STATUS_ISSUING_CA_UNTRUSTED_KDC		cpu_to_le32(0xC000040D) // -EIO
+#define STATUS_KDC_CERT_EXPIRED			cpu_to_le32(0xC000040E) // -EIO
+#define STATUS_KDC_CERT_REVOKED			cpu_to_le32(0xC000040F) // -EIO
+#define STATUS_PARAMETER_QUOTA_EXCEEDED		cpu_to_le32(0xC0000410) // -EDQUOT
+#define STATUS_HIBERNATION_FAILURE		cpu_to_le32(0xC0000411) // -EIO
+#define STATUS_DELAY_LOAD_FAILED		cpu_to_le32(0xC0000412) // -EIO
+#define STATUS_AUTHENTICATION_FIREWALL_FAILED	cpu_to_le32(0xC0000413) // -EIO
+#define STATUS_VDM_DISALLOWED			cpu_to_le32(0xC0000414) // -EIO
+#define STATUS_HUNG_DISPLAY_DRIVER_THREAD	cpu_to_le32(0xC0000415) // -EIO
+#define STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE cpu_to_le32(0xC0000416) // -EIO
+#define STATUS_INVALID_CRUNTIME_PARAMETER	cpu_to_le32(0xC0000417) // -EIO
+#define STATUS_NTLM_BLOCKED			cpu_to_le32(0xC0000418) // -EIO
+#define STATUS_ASSERTION_FAILURE		cpu_to_le32(0xC0000420) // -EIO
+#define STATUS_VERIFIER_STOP			cpu_to_le32(0xC0000421) // -EIO
+#define STATUS_CALLBACK_POP_STACK		cpu_to_le32(0xC0000423) // -EIO
+#define STATUS_INCOMPATIBLE_DRIVER_BLOCKED	cpu_to_le32(0xC0000424) // -EIO
+#define STATUS_HIVE_UNLOADED			cpu_to_le32(0xC0000425) // -EIO
+#define STATUS_COMPRESSION_DISABLED		cpu_to_le32(0xC0000426) // -EIO
+#define STATUS_FILE_SYSTEM_LIMITATION		cpu_to_le32(0xC0000427) // -EIO
+#define STATUS_INVALID_IMAGE_HASH		cpu_to_le32(0xC0000428) // -EIO
+#define STATUS_NOT_CAPABLE			cpu_to_le32(0xC0000429) // -EIO
+#define STATUS_REQUEST_OUT_OF_SEQUENCE		cpu_to_le32(0xC000042A) // -EIO
+#define STATUS_IMPLEMENTATION_LIMIT		cpu_to_le32(0xC000042B) // -EIO
+#define STATUS_ELEVATION_REQUIRED		cpu_to_le32(0xC000042C) // -EIO
+#define STATUS_BEYOND_VDL			cpu_to_le32(0xC0000432) // -EIO
+#define STATUS_ENCOUNTERED_WRITE_IN_PROGRESS	cpu_to_le32(0xC0000433) // -EIO
+#define STATUS_PTE_CHANGED			cpu_to_le32(0xC0000434) // -EIO
+#define STATUS_PURGE_FAILED			cpu_to_le32(0xC0000435) // -EIO
+#define STATUS_CRED_REQUIRES_CONFIRMATION	cpu_to_le32(0xC0000440) // -EIO
+#define STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE cpu_to_le32(0xC0000441) // -EIO
+#define STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER	cpu_to_le32(0xC0000442) // -EIO
+#define STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE cpu_to_le32(0xC0000443) // -EIO
+#define STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE	cpu_to_le32(0xC0000444) // -EIO
+#define STATUS_CS_ENCRYPTION_FILE_NOT_CSE	cpu_to_le32(0xC0000445) // -EIO
+#define STATUS_INVALID_LABEL			cpu_to_le32(0xC0000446) // -EIO
+#define STATUS_DRIVER_PROCESS_TERMINATED	cpu_to_le32(0xC0000450) // -EIO
+#define STATUS_AMBIGUOUS_SYSTEM_DEVICE		cpu_to_le32(0xC0000451) // -EIO
+#define STATUS_SYSTEM_DEVICE_NOT_FOUND		cpu_to_le32(0xC0000452) // -EIO
+#define STATUS_RESTART_BOOT_APPLICATION		cpu_to_le32(0xC0000453) // -EIO
+#define STATUS_INVALID_TASK_NAME		cpu_to_le32(0xC0000500) // -EIO
+#define STATUS_INVALID_TASK_INDEX		cpu_to_le32(0xC0000501) // -EIO
+#define STATUS_THREAD_ALREADY_IN_TASK		cpu_to_le32(0xC0000502) // -EIO
+#define STATUS_CALLBACK_BYPASS			cpu_to_le32(0xC0000503) // -EIO
+#define STATUS_SERVER_UNAVAILABLE		cpu_to_le32(0xC0000466) // -EAGAIN
+#define STATUS_FILE_NOT_AVAILABLE		cpu_to_le32(0xC0000467) // -EAGAIN
+#define STATUS_PORT_CLOSED			cpu_to_le32(0xC0000700) // -EIO
+#define STATUS_MESSAGE_LOST			cpu_to_le32(0xC0000701) // -EIO
+#define STATUS_INVALID_MESSAGE			cpu_to_le32(0xC0000702) // -EIO
+#define STATUS_REQUEST_CANCELED			cpu_to_le32(0xC0000703) // -EIO
+#define STATUS_RECURSIVE_DISPATCH		cpu_to_le32(0xC0000704) // -EIO
+#define STATUS_LPC_RECEIVE_BUFFER_EXPECTED	cpu_to_le32(0xC0000705) // -EIO
+#define STATUS_LPC_INVALID_CONNECTION_USAGE	cpu_to_le32(0xC0000706) // -EIO
+#define STATUS_LPC_REQUESTS_NOT_ALLOWED		cpu_to_le32(0xC0000707) // -EIO
+#define STATUS_RESOURCE_IN_USE			cpu_to_le32(0xC0000708) // -EIO
+#define STATUS_HARDWARE_MEMORY_ERROR		cpu_to_le32(0xC0000709) // -EIO
+#define STATUS_THREADPOOL_HANDLE_EXCEPTION	cpu_to_le32(0xC000070A) // -EIO
+#define STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED cpu_to_le32(0xC000070B) // -EIO
+#define STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED cpu_to_le32(0xC000070C) // -EIO
+#define STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED cpu_to_le32(0xC000070D) // -EIO
+#define STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED cpu_to_le32(0xC000070E) // -EIO
+#define STATUS_THREADPOOL_RELEASED_DURING_OPERATION cpu_to_le32(0xC000070F) // -EIO
+#define STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING cpu_to_le32(0xC0000710) // -EIO
+#define STATUS_APC_RETURNED_WHILE_IMPERSONATING	cpu_to_le32(0xC0000711) // -EIO
+#define STATUS_PROCESS_IS_PROTECTED		cpu_to_le32(0xC0000712) // -EIO
+#define STATUS_MCA_EXCEPTION			cpu_to_le32(0xC0000713) // -EIO
+#define STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE	cpu_to_le32(0xC0000714) // -EIO
+#define STATUS_SYMLINK_CLASS_DISABLED		cpu_to_le32(0xC0000715) // -EIO
+#define STATUS_INVALID_IDN_NORMALIZATION	cpu_to_le32(0xC0000716) // -EIO
+#define STATUS_NO_UNICODE_TRANSLATION		cpu_to_le32(0xC0000717) // -EIO
+#define STATUS_ALREADY_REGISTERED		cpu_to_le32(0xC0000718) // -EIO
+#define STATUS_CONTEXT_MISMATCH			cpu_to_le32(0xC0000719) // -EIO
+#define STATUS_PORT_ALREADY_HAS_COMPLETION_LIST	cpu_to_le32(0xC000071A) // -EIO
+#define STATUS_CALLBACK_RETURNED_THREAD_PRIORITY cpu_to_le32(0xC000071B) // -EIO
+#define STATUS_INVALID_THREAD			cpu_to_le32(0xC000071C) // -EIO
+#define STATUS_CALLBACK_RETURNED_TRANSACTION	cpu_to_le32(0xC000071D) // -EIO
+#define STATUS_CALLBACK_RETURNED_LDR_LOCK	cpu_to_le32(0xC000071E) // -EIO
+#define STATUS_CALLBACK_RETURNED_LANG		cpu_to_le32(0xC000071F) // -EIO
+#define STATUS_CALLBACK_RETURNED_PRI_BACK	cpu_to_le32(0xC0000720) // -EIO
+#define STATUS_CALLBACK_RETURNED_THREAD_AFFINITY cpu_to_le32(0xC0000721) // -EIO
+#define STATUS_DISK_REPAIR_DISABLED		cpu_to_le32(0xC0000800) // -EIO
+#define STATUS_DS_DOMAIN_RENAME_IN_PROGRESS	cpu_to_le32(0xC0000801) // -EIO
+#define STATUS_DISK_QUOTA_EXCEEDED		cpu_to_le32(0xC0000802) // -EDQUOT
+#define STATUS_CONTENT_BLOCKED			cpu_to_le32(0xC0000804) // -EIO
+#define STATUS_BAD_CLUSTERS			cpu_to_le32(0xC0000805) // -EIO
+#define STATUS_VOLUME_DIRTY			cpu_to_le32(0xC0000806) // -EIO
+#define STATUS_FILE_CHECKED_OUT			cpu_to_le32(0xC0000901) // -EIO
+#define STATUS_CHECKOUT_REQUIRED		cpu_to_le32(0xC0000902) // -EIO
+#define STATUS_BAD_FILE_TYPE			cpu_to_le32(0xC0000903) // -EIO
+#define STATUS_FILE_TOO_LARGE			cpu_to_le32(0xC0000904) // -EIO
+#define STATUS_FORMS_AUTH_REQUIRED		cpu_to_le32(0xC0000905) // -EIO
+#define STATUS_VIRUS_INFECTED			cpu_to_le32(0xC0000906) // -EIO
+#define STATUS_VIRUS_DELETED			cpu_to_le32(0xC0000907) // -EIO
+#define STATUS_BAD_MCFG_TABLE			cpu_to_le32(0xC0000908) // -EIO
+#define STATUS_WOW_ASSERTION			cpu_to_le32(0xC0009898) // -EIO
+#define STATUS_INVALID_SIGNATURE		cpu_to_le32(0xC000A000) // -EIO
+#define STATUS_HMAC_NOT_SUPPORTED		cpu_to_le32(0xC000A001) // -EIO
+#define STATUS_AUTH_TAG_MISMATCH		cpu_to_le32(0xC000A002) // -EBADMSG
+#define STATUS_IPSEC_QUEUE_OVERFLOW		cpu_to_le32(0xC000A010) // -EIO
+#define STATUS_ND_QUEUE_OVERFLOW		cpu_to_le32(0xC000A011) // -EIO
+#define STATUS_HOPLIMIT_EXCEEDED		cpu_to_le32(0xC000A012) // -EIO
+#define STATUS_PROTOCOL_NOT_SUPPORTED		cpu_to_le32(0xC000A013) // -EOPNOTSUPP
+#define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED cpu_to_le32(0xC000A080) // -EIO
+#define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR cpu_to_le32(0xC000A081) // -EIO
+#define STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR cpu_to_le32(0xC000A082) // -EIO
+#define STATUS_XML_PARSE_ERROR			cpu_to_le32(0xC000A083) // -EIO
+#define STATUS_XMLDSIG_ERROR			cpu_to_le32(0xC000A084) // -EIO
+#define STATUS_WRONG_COMPARTMENT		cpu_to_le32(0xC000A085) // -EIO
+#define STATUS_AUTHIP_FAILURE			cpu_to_le32(0xC000A086) // -EIO
+#define DBG_NO_STATE_CHANGE			cpu_to_le32(0xC0010001) // -EIO
+#define DBG_APP_NOT_IDLE			cpu_to_le32(0xC0010002) // -EIO
+#define RPC_NT_INVALID_STRING_BINDING		cpu_to_le32(0xC0020001) // -EIO
+#define RPC_NT_WRONG_KIND_OF_BINDING		cpu_to_le32(0xC0020002) // -EIO
+#define RPC_NT_INVALID_BINDING			cpu_to_le32(0xC0020003) // -EIO
+#define RPC_NT_PROTSEQ_NOT_SUPPORTED		cpu_to_le32(0xC0020004) // -EOPNOTSUPP
+#define RPC_NT_INVALID_RPC_PROTSEQ		cpu_to_le32(0xC0020005) // -EIO
+#define RPC_NT_INVALID_STRING_UUID		cpu_to_le32(0xC0020006) // -EIO
+#define RPC_NT_INVALID_ENDPOINT_FORMAT		cpu_to_le32(0xC0020007) // -EIO
+#define RPC_NT_INVALID_NET_ADDR			cpu_to_le32(0xC0020008) // -EIO
+#define RPC_NT_NO_ENDPOINT_FOUND		cpu_to_le32(0xC0020009) // -EIO
+#define RPC_NT_INVALID_TIMEOUT			cpu_to_le32(0xC002000A) // -EINVAL
+#define RPC_NT_OBJECT_NOT_FOUND			cpu_to_le32(0xC002000B) // -ENOENT
+#define RPC_NT_ALREADY_REGISTERED		cpu_to_le32(0xC002000C) // -EIO
+#define RPC_NT_TYPE_ALREADY_REGISTERED		cpu_to_le32(0xC002000D) // -EIO
+#define RPC_NT_ALREADY_LISTENING		cpu_to_le32(0xC002000E) // -EIO
+#define RPC_NT_NO_PROTSEQS_REGISTERED		cpu_to_le32(0xC002000F) // -EIO
+#define RPC_NT_NOT_LISTENING			cpu_to_le32(0xC0020010) // -EIO
+#define RPC_NT_UNKNOWN_MGR_TYPE			cpu_to_le32(0xC0020011) // -EIO
+#define RPC_NT_UNKNOWN_IF			cpu_to_le32(0xC0020012) // -EIO
+#define RPC_NT_NO_BINDINGS			cpu_to_le32(0xC0020013) // -EIO
+#define RPC_NT_NO_PROTSEQS			cpu_to_le32(0xC0020014) // -EIO
+#define RPC_NT_CANT_CREATE_ENDPOINT		cpu_to_le32(0xC0020015) // -EIO
+#define RPC_NT_OUT_OF_RESOURCES			cpu_to_le32(0xC0020016) // -EIO
+#define RPC_NT_SERVER_UNAVAILABLE		cpu_to_le32(0xC0020017) // -EIO
+#define RPC_NT_SERVER_TOO_BUSY			cpu_to_le32(0xC0020018) // -EBUSY
+#define RPC_NT_INVALID_NETWORK_OPTIONS		cpu_to_le32(0xC0020019) // -EIO
+#define RPC_NT_NO_CALL_ACTIVE			cpu_to_le32(0xC002001A) // -EIO
+#define RPC_NT_CALL_FAILED			cpu_to_le32(0xC002001B) // -EIO
+#define RPC_NT_CALL_FAILED_DNE			cpu_to_le32(0xC002001C) // -EIO
+#define RPC_NT_PROTOCOL_ERROR			cpu_to_le32(0xC002001D) // -EIO
+#define RPC_NT_UNSUPPORTED_TRANS_SYN		cpu_to_le32(0xC002001F) // -EIO
+#define RPC_NT_UNSUPPORTED_TYPE			cpu_to_le32(0xC0020021) // -EIO
+#define RPC_NT_INVALID_TAG			cpu_to_le32(0xC0020022) // -EIO
+#define RPC_NT_INVALID_BOUND			cpu_to_le32(0xC0020023) // -EIO
+#define RPC_NT_NO_ENTRY_NAME			cpu_to_le32(0xC0020024) // -EIO
+#define RPC_NT_INVALID_NAME_SYNTAX		cpu_to_le32(0xC0020025) // -EIO
+#define RPC_NT_UNSUPPORTED_NAME_SYNTAX		cpu_to_le32(0xC0020026) // -EIO
+#define RPC_NT_UUID_NO_ADDRESS			cpu_to_le32(0xC0020028) // -EIO
+#define RPC_NT_DUPLICATE_ENDPOINT		cpu_to_le32(0xC0020029) // -ENOTUNIQ
+#define RPC_NT_UNKNOWN_AUTHN_TYPE		cpu_to_le32(0xC002002A) // -EIO
+#define RPC_NT_MAX_CALLS_TOO_SMALL		cpu_to_le32(0xC002002B) // -EIO
+#define RPC_NT_STRING_TOO_LONG			cpu_to_le32(0xC002002C) // -EIO
+#define RPC_NT_PROTSEQ_NOT_FOUND		cpu_to_le32(0xC002002D) // -EIO
+#define RPC_NT_PROCNUM_OUT_OF_RANGE		cpu_to_le32(0xC002002E) // -EIO
+#define RPC_NT_BINDING_HAS_NO_AUTH		cpu_to_le32(0xC002002F) // -EIO
+#define RPC_NT_UNKNOWN_AUTHN_SERVICE		cpu_to_le32(0xC0020030) // -EIO
+#define RPC_NT_UNKNOWN_AUTHN_LEVEL		cpu_to_le32(0xC0020031) // -EIO
+#define RPC_NT_INVALID_AUTH_IDENTITY		cpu_to_le32(0xC0020032) // -EIO
+#define RPC_NT_UNKNOWN_AUTHZ_SERVICE		cpu_to_le32(0xC0020033) // -EIO
+#define EPT_NT_INVALID_ENTRY			cpu_to_le32(0xC0020034) // -EIO
+#define EPT_NT_CANT_PERFORM_OP			cpu_to_le32(0xC0020035) // -EIO
+#define EPT_NT_NOT_REGISTERED			cpu_to_le32(0xC0020036) // -EIO
+#define RPC_NT_NOTHING_TO_EXPORT		cpu_to_le32(0xC0020037) // -EIO
+#define RPC_NT_INCOMPLETE_NAME			cpu_to_le32(0xC0020038) // -EIO
+#define RPC_NT_INVALID_VERS_OPTION		cpu_to_le32(0xC0020039) // -EIO
+#define RPC_NT_NO_MORE_MEMBERS			cpu_to_le32(0xC002003A) // -EIO
+#define RPC_NT_NOT_ALL_OBJS_UNEXPORTED		cpu_to_le32(0xC002003B) // -EIO
+#define RPC_NT_INTERFACE_NOT_FOUND		cpu_to_le32(0xC002003C) // -EIO
+#define RPC_NT_ENTRY_ALREADY_EXISTS		cpu_to_le32(0xC002003D) // -EIO
+#define RPC_NT_ENTRY_NOT_FOUND			cpu_to_le32(0xC002003E) // -EIO
+#define RPC_NT_NAME_SERVICE_UNAVAILABLE		cpu_to_le32(0xC002003F) // -EIO
+#define RPC_NT_INVALID_NAF_ID			cpu_to_le32(0xC0020040) // -EIO
+#define RPC_NT_CANNOT_SUPPORT			cpu_to_le32(0xC0020041) // -EOPNOTSUPP
+#define RPC_NT_NO_CONTEXT_AVAILABLE		cpu_to_le32(0xC0020042) // -EIO
+#define RPC_NT_INTERNAL_ERROR			cpu_to_le32(0xC0020043) // -EIO
+#define RPC_NT_ZERO_DIVIDE			cpu_to_le32(0xC0020044) // -EIO
+#define RPC_NT_ADDRESS_ERROR			cpu_to_le32(0xC0020045) // -EIO
+#define RPC_NT_FP_DIV_ZERO			cpu_to_le32(0xC0020046) // -EIO
+#define RPC_NT_FP_UNDERFLOW			cpu_to_le32(0xC0020047) // -EIO
+#define RPC_NT_FP_OVERFLOW			cpu_to_le32(0xC0020048) // -EIO
+#define RPC_NT_CALL_IN_PROGRESS			cpu_to_le32(0xC0020049) // -EIO
+#define RPC_NT_NO_MORE_BINDINGS			cpu_to_le32(0xC002004A) // -EIO
+#define RPC_NT_GROUP_MEMBER_NOT_FOUND		cpu_to_le32(0xC002004B) // -EIO
+#define EPT_NT_CANT_CREATE			cpu_to_le32(0xC002004C) // -EIO
+#define RPC_NT_INVALID_OBJECT			cpu_to_le32(0xC002004D) // -EIO
+#define RPC_NT_NO_INTERFACES			cpu_to_le32(0xC002004F) // -EIO
+#define RPC_NT_CALL_CANCELLED			cpu_to_le32(0xC0020050) // -EIO
+#define RPC_NT_BINDING_INCOMPLETE		cpu_to_le32(0xC0020051) // -EIO
+#define RPC_NT_COMM_FAILURE			cpu_to_le32(0xC0020052) // -EIO
+#define RPC_NT_UNSUPPORTED_AUTHN_LEVEL		cpu_to_le32(0xC0020053) // -EIO
+#define RPC_NT_NO_PRINC_NAME			cpu_to_le32(0xC0020054) // -EIO
+#define RPC_NT_NOT_RPC_ERROR			cpu_to_le32(0xC0020055) // -EIO
+#define RPC_NT_SEC_PKG_ERROR			cpu_to_le32(0xC0020057) // -EIO
+#define RPC_NT_NOT_CANCELLED			cpu_to_le32(0xC0020058) // -EIO
+#define RPC_NT_INVALID_ASYNC_HANDLE		cpu_to_le32(0xC0020062) // -EIO
+#define RPC_NT_INVALID_ASYNC_CALL		cpu_to_le32(0xC0020063) // -EIO
+#define RPC_NT_PROXY_ACCESS_DENIED		cpu_to_le32(0xC0020064) // -EACCES
+#define RPC_NT_NO_MORE_ENTRIES			cpu_to_le32(0xC0030001) // -EIO
+#define RPC_NT_SS_CHAR_TRANS_OPEN_FAIL		cpu_to_le32(0xC0030002) // -EIO
+#define RPC_NT_SS_CHAR_TRANS_SHORT_FILE		cpu_to_le32(0xC0030003) // -EIO
+#define RPC_NT_SS_IN_NULL_CONTEXT		cpu_to_le32(0xC0030004) // -EIO
+#define RPC_NT_SS_CONTEXT_MISMATCH		cpu_to_le32(0xC0030005) // -EIO
+#define RPC_NT_SS_CONTEXT_DAMAGED		cpu_to_le32(0xC0030006) // -EIO
+#define RPC_NT_SS_HANDLES_MISMATCH		cpu_to_le32(0xC0030007) // -EIO
+#define RPC_NT_SS_CANNOT_GET_CALL_HANDLE	cpu_to_le32(0xC0030008) // -EIO
+#define RPC_NT_NULL_REF_POINTER			cpu_to_le32(0xC0030009) // -EIO
+#define RPC_NT_ENUM_VALUE_OUT_OF_RANGE		cpu_to_le32(0xC003000A) // -EIO
+#define RPC_NT_BYTE_COUNT_TOO_SMALL		cpu_to_le32(0xC003000B) // -EIO
+#define RPC_NT_BAD_STUB_DATA			cpu_to_le32(0xC003000C) // -EIO
+#define RPC_NT_INVALID_ES_ACTION		cpu_to_le32(0xC0030059) // -EIO
+#define RPC_NT_WRONG_ES_VERSION			cpu_to_le32(0xC003005A) // -EIO
+#define RPC_NT_WRONG_STUB_VERSION		cpu_to_le32(0xC003005B) // -EIO
+#define RPC_NT_INVALID_PIPE_OBJECT		cpu_to_le32(0xC003005C) // -EIO
+#define RPC_NT_INVALID_PIPE_OPERATION		cpu_to_le32(0xC003005D) // -EIO
+#define RPC_NT_WRONG_PIPE_VERSION		cpu_to_le32(0xC003005E) // -EIO
+#define RPC_NT_PIPE_CLOSED			cpu_to_le32(0xC003005F) // -EIO
+#define RPC_NT_PIPE_DISCIPLINE_ERROR		cpu_to_le32(0xC0030060) // -EIO
+#define RPC_NT_PIPE_EMPTY			cpu_to_le32(0xC0030061) // -EIO
+#define STATUS_PNP_BAD_MPS_TABLE		cpu_to_le32(0xC0040035) // -EIO
+#define STATUS_PNP_TRANSLATION_FAILED		cpu_to_le32(0xC0040036) // -EIO
+#define STATUS_PNP_IRQ_TRANSLATION_FAILED	cpu_to_le32(0xC0040037) // -EIO
+#define STATUS_PNP_INVALID_ID			cpu_to_le32(0xC0040038) // -EIO
+#define STATUS_IO_REISSUE_AS_CACHED		cpu_to_le32(0xC0040039) // -EIO
+#define STATUS_CTX_WINSTATION_NAME_INVALID	cpu_to_le32(0xC00A0001) // -EIO
+#define STATUS_CTX_INVALID_PD			cpu_to_le32(0xC00A0002) // -EIO
+#define STATUS_CTX_PD_NOT_FOUND			cpu_to_le32(0xC00A0003) // -EIO
+#define STATUS_CTX_CLOSE_PENDING		cpu_to_le32(0xC00A0006) // -EIO
+#define STATUS_CTX_NO_OUTBUF			cpu_to_le32(0xC00A0007) // -EIO
+#define STATUS_CTX_MODEM_INF_NOT_FOUND		cpu_to_le32(0xC00A0008) // -EIO
+#define STATUS_CTX_INVALID_MODEMNAME		cpu_to_le32(0xC00A0009) // -EIO
+#define STATUS_CTX_RESPONSE_ERROR		cpu_to_le32(0xC00A000A) // -EIO
+#define STATUS_CTX_MODEM_RESPONSE_TIMEOUT	cpu_to_le32(0xC00A000B) // -ETIMEDOUT
+#define STATUS_CTX_MODEM_RESPONSE_NO_CARRIER	cpu_to_le32(0xC00A000C) // -EIO
+#define STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE	cpu_to_le32(0xC00A000D) // -EIO
+#define STATUS_CTX_MODEM_RESPONSE_BUSY		cpu_to_le32(0xC00A000E) // -EBUSY
+#define STATUS_CTX_MODEM_RESPONSE_VOICE		cpu_to_le32(0xC00A000F) // -EIO
+#define STATUS_CTX_TD_ERROR			cpu_to_le32(0xC00A0010) // -EIO
+#define STATUS_CTX_LICENSE_CLIENT_INVALID	cpu_to_le32(0xC00A0012) // -EIO
+#define STATUS_CTX_LICENSE_NOT_AVAILABLE	cpu_to_le32(0xC00A0013) // -EIO
+#define STATUS_CTX_LICENSE_EXPIRED		cpu_to_le32(0xC00A0014) // -EIO
+#define STATUS_CTX_WINSTATION_NOT_FOUND		cpu_to_le32(0xC00A0015) // -EIO
+#define STATUS_CTX_WINSTATION_NAME_COLLISION	cpu_to_le32(0xC00A0016) // -EIO
+#define STATUS_CTX_WINSTATION_BUSY		cpu_to_le32(0xC00A0017) // -EBUSY
+#define STATUS_CTX_BAD_VIDEO_MODE		cpu_to_le32(0xC00A0018) // -EIO
+#define STATUS_CTX_GRAPHICS_INVALID		cpu_to_le32(0xC00A0022) // -EIO
+#define STATUS_CTX_NOT_CONSOLE			cpu_to_le32(0xC00A0024) // -EIO
+#define STATUS_CTX_CLIENT_QUERY_TIMEOUT		cpu_to_le32(0xC00A0026) // -EIO
+#define STATUS_CTX_CONSOLE_DISCONNECT		cpu_to_le32(0xC00A0027) // -EIO
+#define STATUS_CTX_CONSOLE_CONNECT		cpu_to_le32(0xC00A0028) // -EIO
+#define STATUS_CTX_SHADOW_DENIED		cpu_to_le32(0xC00A002A) // -EIO
+#define STATUS_CTX_WINSTATION_ACCESS_DENIED	cpu_to_le32(0xC00A002B) // -EACCES
+#define STATUS_CTX_INVALID_WD			cpu_to_le32(0xC00A002E) // -EIO
+#define STATUS_CTX_WD_NOT_FOUND			cpu_to_le32(0xC00A002F) // -EIO
+#define STATUS_CTX_SHADOW_INVALID		cpu_to_le32(0xC00A0030) // -EIO
+#define STATUS_CTX_SHADOW_DISABLED		cpu_to_le32(0xC00A0031) // -EIO
+#define STATUS_RDP_PROTOCOL_ERROR		cpu_to_le32(0xC00A0032) // -EIO
+#define STATUS_CTX_CLIENT_LICENSE_NOT_SET	cpu_to_le32(0xC00A0033) // -EIO
+#define STATUS_CTX_CLIENT_LICENSE_IN_USE	cpu_to_le32(0xC00A0034) // -EIO
+#define STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE	cpu_to_le32(0xC00A0035) // -EIO
+#define STATUS_CTX_SHADOW_NOT_RUNNING		cpu_to_le32(0xC00A0036) // -EIO
+#define STATUS_CTX_LOGON_DISABLED		cpu_to_le32(0xC00A0037) // -EIO
+#define STATUS_CTX_SECURITY_LAYER_ERROR		cpu_to_le32(0xC00A0038) // -EIO
+#define STATUS_TS_INCOMPATIBLE_SESSIONS		cpu_to_le32(0xC00A0039) // -EIO
+#define STATUS_MUI_FILE_NOT_FOUND		cpu_to_le32(0xC00B0001) // -EIO
+#define STATUS_MUI_INVALID_FILE			cpu_to_le32(0xC00B0002) // -EIO
+#define STATUS_MUI_INVALID_RC_CONFIG		cpu_to_le32(0xC00B0003) // -EIO
+#define STATUS_MUI_INVALID_LOCALE_NAME		cpu_to_le32(0xC00B0004) // -EIO
+#define STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME cpu_to_le32(0xC00B0005) // -EIO
+#define STATUS_MUI_FILE_NOT_LOADED		cpu_to_le32(0xC00B0006) // -EIO
+#define STATUS_RESOURCE_ENUM_USER_STOP		cpu_to_le32(0xC00B0007) // -EIO
+#define STATUS_CLUSTER_INVALID_NODE		cpu_to_le32(0xC0130001) // -EIO
+#define STATUS_CLUSTER_NODE_EXISTS		cpu_to_le32(0xC0130002) // -EIO
+#define STATUS_CLUSTER_JOIN_IN_PROGRESS		cpu_to_le32(0xC0130003) // -EIO
+#define STATUS_CLUSTER_NODE_NOT_FOUND		cpu_to_le32(0xC0130004) // -EIO
+#define STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND	cpu_to_le32(0xC0130005) // -EIO
+#define STATUS_CLUSTER_NETWORK_EXISTS		cpu_to_le32(0xC0130006) // -EIO
+#define STATUS_CLUSTER_NETWORK_NOT_FOUND	cpu_to_le32(0xC0130007) // -EIO
+#define STATUS_CLUSTER_NETINTERFACE_EXISTS	cpu_to_le32(0xC0130008) // -EIO
+#define STATUS_CLUSTER_NETINTERFACE_NOT_FOUND	cpu_to_le32(0xC0130009) // -EIO
+#define STATUS_CLUSTER_INVALID_REQUEST		cpu_to_le32(0xC013000A) // -EIO
+#define STATUS_CLUSTER_INVALID_NETWORK_PROVIDER	cpu_to_le32(0xC013000B) // -EIO
+#define STATUS_CLUSTER_NODE_DOWN		cpu_to_le32(0xC013000C) // -EIO
+#define STATUS_CLUSTER_NODE_UNREACHABLE		cpu_to_le32(0xC013000D) // -EIO
+#define STATUS_CLUSTER_NODE_NOT_MEMBER		cpu_to_le32(0xC013000E) // -EIO
+#define STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS	cpu_to_le32(0xC013000F) // -EIO
+#define STATUS_CLUSTER_INVALID_NETWORK		cpu_to_le32(0xC0130010) // -EIO
+#define STATUS_CLUSTER_NO_NET_ADAPTERS		cpu_to_le32(0xC0130011) // -EIO
+#define STATUS_CLUSTER_NODE_UP			cpu_to_le32(0xC0130012) // -EIO
+#define STATUS_CLUSTER_NODE_PAUSED		cpu_to_le32(0xC0130013) // -EIO
+#define STATUS_CLUSTER_NODE_NOT_PAUSED		cpu_to_le32(0xC0130014) // -EIO
+#define STATUS_CLUSTER_NO_SECURITY_CONTEXT	cpu_to_le32(0xC0130015) // -EIO
+#define STATUS_CLUSTER_NETWORK_NOT_INTERNAL	cpu_to_le32(0xC0130016) // -EIO
+#define STATUS_CLUSTER_POISONED			cpu_to_le32(0xC0130017) // -EIO
+#define STATUS_ACPI_INVALID_OPCODE		cpu_to_le32(0xC0140001) // -EIO
+#define STATUS_ACPI_STACK_OVERFLOW		cpu_to_le32(0xC0140002) // -EIO
+#define STATUS_ACPI_ASSERT_FAILED		cpu_to_le32(0xC0140003) // -EIO
+#define STATUS_ACPI_INVALID_INDEX		cpu_to_le32(0xC0140004) // -EIO
+#define STATUS_ACPI_INVALID_ARGUMENT		cpu_to_le32(0xC0140005) // -EIO
+#define STATUS_ACPI_FATAL			cpu_to_le32(0xC0140006) // -EIO
+#define STATUS_ACPI_INVALID_SUPERNAME		cpu_to_le32(0xC0140007) // -EIO
+#define STATUS_ACPI_INVALID_ARGTYPE		cpu_to_le32(0xC0140008) // -EIO
+#define STATUS_ACPI_INVALID_OBJTYPE		cpu_to_le32(0xC0140009) // -EIO
+#define STATUS_ACPI_INVALID_TARGETTYPE		cpu_to_le32(0xC014000A) // -EIO
+#define STATUS_ACPI_INCORRECT_ARGUMENT_COUNT	cpu_to_le32(0xC014000B) // -EIO
+#define STATUS_ACPI_ADDRESS_NOT_MAPPED		cpu_to_le32(0xC014000C) // -EIO
+#define STATUS_ACPI_INVALID_EVENTTYPE		cpu_to_le32(0xC014000D) // -EIO
+#define STATUS_ACPI_HANDLER_COLLISION		cpu_to_le32(0xC014000E) // -EIO
+#define STATUS_ACPI_INVALID_DATA		cpu_to_le32(0xC014000F) // -EIO
+#define STATUS_ACPI_INVALID_REGION		cpu_to_le32(0xC0140010) // -EIO
+#define STATUS_ACPI_INVALID_ACCESS_SIZE		cpu_to_le32(0xC0140011) // -EIO
+#define STATUS_ACPI_ACQUIRE_GLOBAL_LOCK		cpu_to_le32(0xC0140012) // -EIO
+#define STATUS_ACPI_ALREADY_INITIALIZED		cpu_to_le32(0xC0140013) // -EIO
+#define STATUS_ACPI_NOT_INITIALIZED		cpu_to_le32(0xC0140014) // -EIO
+#define STATUS_ACPI_INVALID_MUTEX_LEVEL		cpu_to_le32(0xC0140015) // -EIO
+#define STATUS_ACPI_MUTEX_NOT_OWNED		cpu_to_le32(0xC0140016) // -EIO
+#define STATUS_ACPI_MUTEX_NOT_OWNER		cpu_to_le32(0xC0140017) // -EIO
+#define STATUS_ACPI_RS_ACCESS			cpu_to_le32(0xC0140018) // -EIO
+#define STATUS_ACPI_INVALID_TABLE		cpu_to_le32(0xC0140019) // -EIO
+#define STATUS_ACPI_REG_HANDLER_FAILED		cpu_to_le32(0xC0140020) // -EIO
+#define STATUS_ACPI_POWER_REQUEST_FAILED	cpu_to_le32(0xC0140021) // -EIO
+#define STATUS_SXS_SECTION_NOT_FOUND		cpu_to_le32(0xC0150001) // -EIO
+#define STATUS_SXS_CANT_GEN_ACTCTX		cpu_to_le32(0xC0150002) // -EIO
+#define STATUS_SXS_INVALID_ACTCTXDATA_FORMAT	cpu_to_le32(0xC0150003) // -EIO
+#define STATUS_SXS_ASSEMBLY_NOT_FOUND		cpu_to_le32(0xC0150004) // -EIO
+#define STATUS_SXS_MANIFEST_FORMAT_ERROR	cpu_to_le32(0xC0150005) // -EIO
+#define STATUS_SXS_MANIFEST_PARSE_ERROR		cpu_to_le32(0xC0150006) // -EIO
+#define STATUS_SXS_ACTIVATION_CONTEXT_DISABLED	cpu_to_le32(0xC0150007) // -EIO
+#define STATUS_SXS_KEY_NOT_FOUND		cpu_to_le32(0xC0150008) // -EIO
+#define STATUS_SXS_VERSION_CONFLICT		cpu_to_le32(0xC0150009) // -EIO
+#define STATUS_SXS_WRONG_SECTION_TYPE		cpu_to_le32(0xC015000A) // -EIO
+#define STATUS_SXS_THREAD_QUERIES_DISABLED	cpu_to_le32(0xC015000B) // -EIO
+#define STATUS_SXS_ASSEMBLY_MISSING		cpu_to_le32(0xC015000C) // -EIO
+#define STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET	cpu_to_le32(0xC015000E) // -EIO
+#define STATUS_SXS_EARLY_DEACTIVATION		cpu_to_le32(0xC015000F) // -EIO
+#define STATUS_SXS_INVALID_DEACTIVATION		cpu_to_le32(0xC0150010) // -EIO
+#define STATUS_SXS_MULTIPLE_DEACTIVATION	cpu_to_le32(0xC0150011) // -EIO
+#define STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY cpu_to_le32(0xC0150012) // -EIO
+#define STATUS_SXS_PROCESS_TERMINATION_REQUESTED cpu_to_le32(0xC0150013) // -EIO
+#define STATUS_SXS_CORRUPT_ACTIVATION_STACK	cpu_to_le32(0xC0150014) // -EIO
+#define STATUS_SXS_CORRUPTION			cpu_to_le32(0xC0150015) // -EIO
+#define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE cpu_to_le32(0xC0150016) // -EIO
+#define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME cpu_to_le32(0xC0150017) // -EIO
+#define STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE	cpu_to_le32(0xC0150018) // -EIO
+#define STATUS_SXS_IDENTITY_PARSE_ERROR		cpu_to_le32(0xC0150019) // -EIO
+#define STATUS_SXS_COMPONENT_STORE_CORRUPT	cpu_to_le32(0xC015001A) // -EIO
+#define STATUS_SXS_FILE_HASH_MISMATCH		cpu_to_le32(0xC015001B) // -EIO
+#define STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT cpu_to_le32(0xC015001C) // -EIO
+#define STATUS_SXS_IDENTITIES_DIFFERENT		cpu_to_le32(0xC015001D) // -EIO
+#define STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT	cpu_to_le32(0xC015001E) // -EIO
+#define STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY	cpu_to_le32(0xC015001F) // -EIO
+#define STATUS_ADVANCED_INSTALLER_FAILED	cpu_to_le32(0xC0150020) // -EIO
+#define STATUS_XML_ENCODING_MISMATCH		cpu_to_le32(0xC0150021) // -EIO
+#define STATUS_SXS_MANIFEST_TOO_BIG		cpu_to_le32(0xC0150022) // -EIO
+#define STATUS_SXS_SETTING_NOT_REGISTERED	cpu_to_le32(0xC0150023) // -EIO
+#define STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE cpu_to_le32(0xC0150024) // -EIO
+#define STATUS_SMI_PRIMITIVE_INSTALLER_FAILED	cpu_to_le32(0xC0150025) // -EIO
+#define STATUS_GENERIC_COMMAND_FAILED		cpu_to_le32(0xC0150026) // -EIO
+#define STATUS_SXS_FILE_HASH_MISSING		cpu_to_le32(0xC0150027) // -EIO
+#define STATUS_TRANSACTIONAL_CONFLICT		cpu_to_le32(0xC0190001) // -EIO
+#define STATUS_INVALID_TRANSACTION		cpu_to_le32(0xC0190002) // -EIO
+#define STATUS_TRANSACTION_NOT_ACTIVE		cpu_to_le32(0xC0190003) // -EIO
+#define STATUS_TM_INITIALIZATION_FAILED		cpu_to_le32(0xC0190004) // -EIO
+#define STATUS_RM_NOT_ACTIVE			cpu_to_le32(0xC0190005) // -EIO
+#define STATUS_RM_METADATA_CORRUPT		cpu_to_le32(0xC0190006) // -EIO
+#define STATUS_TRANSACTION_NOT_JOINED		cpu_to_le32(0xC0190007) // -EIO
+#define STATUS_DIRECTORY_NOT_RM			cpu_to_le32(0xC0190008) // -EIO
+#define STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE	cpu_to_le32(0xC019000A) // -EIO
+#define STATUS_LOG_RESIZE_INVALID_SIZE		cpu_to_le32(0xC019000B) // -EIO
+#define STATUS_REMOTE_FILE_VERSION_MISMATCH	cpu_to_le32(0xC019000C) // -EIO
+#define STATUS_CRM_PROTOCOL_ALREADY_EXISTS	cpu_to_le32(0xC019000F) // -EIO
+#define STATUS_TRANSACTION_PROPAGATION_FAILED	cpu_to_le32(0xC0190010) // -EIO
+#define STATUS_CRM_PROTOCOL_NOT_FOUND		cpu_to_le32(0xC0190011) // -EIO
+#define STATUS_TRANSACTION_SUPERIOR_EXISTS	cpu_to_le32(0xC0190012) // -EIO
+#define STATUS_TRANSACTION_REQUEST_NOT_VALID	cpu_to_le32(0xC0190013) // -EIO
+#define STATUS_TRANSACTION_NOT_REQUESTED	cpu_to_le32(0xC0190014) // -EIO
+#define STATUS_TRANSACTION_ALREADY_ABORTED	cpu_to_le32(0xC0190015) // -EIO
+#define STATUS_TRANSACTION_ALREADY_COMMITTED	cpu_to_le32(0xC0190016) // -EIO
+#define STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER cpu_to_le32(0xC0190017) // -EIO
+#define STATUS_CURRENT_TRANSACTION_NOT_VALID	cpu_to_le32(0xC0190018) // -EIO
+#define STATUS_LOG_GROWTH_FAILED		cpu_to_le32(0xC0190019) // -EIO
+#define STATUS_OBJECT_NO_LONGER_EXISTS		cpu_to_le32(0xC0190021) // -EIO
+#define STATUS_STREAM_MINIVERSION_NOT_FOUND	cpu_to_le32(0xC0190022) // -EIO
+#define STATUS_STREAM_MINIVERSION_NOT_VALID	cpu_to_le32(0xC0190023) // -EIO
+#define STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION cpu_to_le32(0xC0190024) // -EIO
+#define STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT cpu_to_le32(0xC0190025) // -EIO
+#define STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS cpu_to_le32(0xC0190026) // -EIO
+#define STATUS_HANDLE_NO_LONGER_VALID		cpu_to_le32(0xC0190028) // -EIO
+#define STATUS_LOG_CORRUPTION_DETECTED		cpu_to_le32(0xC0190030) // -EIO
+#define STATUS_RM_DISCONNECTED			cpu_to_le32(0xC0190032) // -EIO
+#define STATUS_ENLISTMENT_NOT_SUPERIOR		cpu_to_le32(0xC0190033) // -EIO
+#define STATUS_FILE_IDENTITY_NOT_PERSISTENT	cpu_to_le32(0xC0190036) // -EIO
+#define STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY cpu_to_le32(0xC0190037) // -EIO
+#define STATUS_CANT_CROSS_RM_BOUNDARY		cpu_to_le32(0xC0190038) // -EIO
+#define STATUS_TXF_DIR_NOT_EMPTY		cpu_to_le32(0xC0190039) // -EIO
+#define STATUS_INDOUBT_TRANSACTIONS_EXIST	cpu_to_le32(0xC019003A) // -EIO
+#define STATUS_TM_VOLATILE			cpu_to_le32(0xC019003B) // -EIO
+#define STATUS_ROLLBACK_TIMER_EXPIRED		cpu_to_le32(0xC019003C) // -EIO
+#define STATUS_TXF_ATTRIBUTE_CORRUPT		cpu_to_le32(0xC019003D) // -EIO
+#define STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION	cpu_to_le32(0xC019003E) // -EIO
+#define STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED	cpu_to_le32(0xC019003F) // -EIO
+#define STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE cpu_to_le32(0xC0190040) // -EIO
+#define STATUS_TRANSACTION_REQUIRED_PROMOTION	cpu_to_le32(0xC0190043) // -EIO
+#define STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION cpu_to_le32(0xC0190044) // -EIO
+#define STATUS_TRANSACTIONS_NOT_FROZEN		cpu_to_le32(0xC0190045) // -EIO
+#define STATUS_TRANSACTION_FREEZE_IN_PROGRESS	cpu_to_le32(0xC0190046) // -EIO
+#define STATUS_NOT_SNAPSHOT_VOLUME		cpu_to_le32(0xC0190047) // -EIO
+#define STATUS_NO_SAVEPOINT_WITH_OPEN_FILES	cpu_to_le32(0xC0190048) // -EIO
+#define STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC0190049) // -EIO
+#define STATUS_TM_IDENTITY_MISMATCH		cpu_to_le32(0xC019004A) // -EIO
+#define STATUS_FLOATED_SECTION			cpu_to_le32(0xC019004B) // -EIO
+#define STATUS_CANNOT_ACCEPT_TRANSACTED_WORK	cpu_to_le32(0xC019004C) // -EIO
+#define STATUS_CANNOT_ABORT_TRANSACTIONS	cpu_to_le32(0xC019004D) // -EIO
+#define STATUS_TRANSACTION_NOT_FOUND		cpu_to_le32(0xC019004E) // -EIO
+#define STATUS_RESOURCEMANAGER_NOT_FOUND	cpu_to_le32(0xC019004F) // -EIO
+#define STATUS_ENLISTMENT_NOT_FOUND		cpu_to_le32(0xC0190050) // -EIO
+#define STATUS_TRANSACTIONMANAGER_NOT_FOUND	cpu_to_le32(0xC0190051) // -EIO
+#define STATUS_TRANSACTIONMANAGER_NOT_ONLINE	cpu_to_le32(0xC0190052) // -EIO
+#define STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION cpu_to_le32(0xC0190053) // -EIO
+#define STATUS_TRANSACTION_NOT_ROOT		cpu_to_le32(0xC0190054) // -EIO
+#define STATUS_TRANSACTION_OBJECT_EXPIRED	cpu_to_le32(0xC0190055) // -EIO
+#define STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC0190056) // -EIO
+#define STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED cpu_to_le32(0xC0190057) // -EIO
+#define STATUS_TRANSACTION_RECORD_TOO_LONG	cpu_to_le32(0xC0190058) // -EIO
+#define STATUS_NO_LINK_TRACKING_IN_TRANSACTION	cpu_to_le32(0xC0190059) // -EIO
+#define STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION cpu_to_le32(0xC019005A) // -EOPNOTSUPP
+#define STATUS_TRANSACTION_INTEGRITY_VIOLATED	cpu_to_le32(0xC019005B) // -EIO
+#define STATUS_LOG_SECTOR_INVALID		cpu_to_le32(0xC01A0001) // -EIO
+#define STATUS_LOG_SECTOR_PARITY_INVALID	cpu_to_le32(0xC01A0002) // -EIO
+#define STATUS_LOG_SECTOR_REMAPPED		cpu_to_le32(0xC01A0003) // -EIO
+#define STATUS_LOG_BLOCK_INCOMPLETE		cpu_to_le32(0xC01A0004) // -EIO
+#define STATUS_LOG_INVALID_RANGE		cpu_to_le32(0xC01A0005) // -EIO
+#define STATUS_LOG_BLOCKS_EXHAUSTED		cpu_to_le32(0xC01A0006) // -EIO
+#define STATUS_LOG_READ_CONTEXT_INVALID		cpu_to_le32(0xC01A0007) // -EIO
+#define STATUS_LOG_RESTART_INVALID		cpu_to_le32(0xC01A0008) // -EIO
+#define STATUS_LOG_BLOCK_VERSION		cpu_to_le32(0xC01A0009) // -EIO
+#define STATUS_LOG_BLOCK_INVALID		cpu_to_le32(0xC01A000A) // -EIO
+#define STATUS_LOG_READ_MODE_INVALID		cpu_to_le32(0xC01A000B) // -EIO
+#define STATUS_LOG_METADATA_CORRUPT		cpu_to_le32(0xC01A000D) // -EIO
+#define STATUS_LOG_METADATA_INVALID		cpu_to_le32(0xC01A000E) // -EIO
+#define STATUS_LOG_METADATA_INCONSISTENT	cpu_to_le32(0xC01A000F) // -EIO
+#define STATUS_LOG_RESERVATION_INVALID		cpu_to_le32(0xC01A0010) // -EIO
+#define STATUS_LOG_CANT_DELETE			cpu_to_le32(0xC01A0011) // -EIO
+#define STATUS_LOG_CONTAINER_LIMIT_EXCEEDED	cpu_to_le32(0xC01A0012) // -EIO
+#define STATUS_LOG_START_OF_LOG			cpu_to_le32(0xC01A0013) // -EIO
+#define STATUS_LOG_POLICY_ALREADY_INSTALLED	cpu_to_le32(0xC01A0014) // -EIO
+#define STATUS_LOG_POLICY_NOT_INSTALLED		cpu_to_le32(0xC01A0015) // -EIO
+#define STATUS_LOG_POLICY_INVALID		cpu_to_le32(0xC01A0016) // -EIO
+#define STATUS_LOG_POLICY_CONFLICT		cpu_to_le32(0xC01A0017) // -EIO
+#define STATUS_LOG_PINNED_ARCHIVE_TAIL		cpu_to_le32(0xC01A0018) // -EIO
+#define STATUS_LOG_RECORD_NONEXISTENT		cpu_to_le32(0xC01A0019) // -EIO
+#define STATUS_LOG_RECORDS_RESERVED_INVALID	cpu_to_le32(0xC01A001A) // -EIO
+#define STATUS_LOG_SPACE_RESERVED_INVALID	cpu_to_le32(0xC01A001B) // -EIO
+#define STATUS_LOG_TAIL_INVALID			cpu_to_le32(0xC01A001C) // -EIO
+#define STATUS_LOG_FULL				cpu_to_le32(0xC01A001D) // -EIO
+#define STATUS_LOG_MULTIPLEXED			cpu_to_le32(0xC01A001E) // -EIO
+#define STATUS_LOG_DEDICATED			cpu_to_le32(0xC01A001F) // -EIO
+#define STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS	cpu_to_le32(0xC01A0020) // -EIO
+#define STATUS_LOG_ARCHIVE_IN_PROGRESS		cpu_to_le32(0xC01A0021) // -EIO
+#define STATUS_LOG_EPHEMERAL			cpu_to_le32(0xC01A0022) // -EIO
+#define STATUS_LOG_NOT_ENOUGH_CONTAINERS	cpu_to_le32(0xC01A0023) // -EIO
+#define STATUS_LOG_CLIENT_ALREADY_REGISTERED	cpu_to_le32(0xC01A0024) // -EIO
+#define STATUS_LOG_CLIENT_NOT_REGISTERED	cpu_to_le32(0xC01A0025) // -EIO
+#define STATUS_LOG_FULL_HANDLER_IN_PROGRESS	cpu_to_le32(0xC01A0026) // -EIO
+#define STATUS_LOG_CONTAINER_READ_FAILED	cpu_to_le32(0xC01A0027) // -EIO
+#define STATUS_LOG_CONTAINER_WRITE_FAILED	cpu_to_le32(0xC01A0028) // -EIO
+#define STATUS_LOG_CONTAINER_OPEN_FAILED	cpu_to_le32(0xC01A0029) // -EIO
+#define STATUS_LOG_CONTAINER_STATE_INVALID	cpu_to_le32(0xC01A002A) // -EIO
+#define STATUS_LOG_STATE_INVALID		cpu_to_le32(0xC01A002B) // -EIO
+#define STATUS_LOG_PINNED			cpu_to_le32(0xC01A002C) // -EIO
+#define STATUS_LOG_METADATA_FLUSH_FAILED	cpu_to_le32(0xC01A002D) // -EIO
+#define STATUS_LOG_INCONSISTENT_SECURITY	cpu_to_le32(0xC01A002E) // -EIO
+#define STATUS_LOG_APPENDED_FLUSH_FAILED	cpu_to_le32(0xC01A002F) // -EIO
+#define STATUS_LOG_PINNED_RESERVATION		cpu_to_le32(0xC01A0030) // -EIO
+#define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD	cpu_to_le32(0xC01B00EA) // -EIO
+#define STATUS_FLT_NO_HANDLER_DEFINED		cpu_to_le32(0xC01C0001) // -EIO
+#define STATUS_FLT_CONTEXT_ALREADY_DEFINED	cpu_to_le32(0xC01C0002) // -EIO
+#define STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST	cpu_to_le32(0xC01C0003) // -EIO
+#define STATUS_FLT_DISALLOW_FAST_IO		cpu_to_le32(0xC01C0004) // -EIO
+#define STATUS_FLT_INVALID_NAME_REQUEST		cpu_to_le32(0xC01C0005) // -EIO
+#define STATUS_FLT_NOT_SAFE_TO_POST_OPERATION	cpu_to_le32(0xC01C0006) // -EIO
+#define STATUS_FLT_NOT_INITIALIZED		cpu_to_le32(0xC01C0007) // -EIO
+#define STATUS_FLT_FILTER_NOT_READY		cpu_to_le32(0xC01C0008) // -EIO
+#define STATUS_FLT_POST_OPERATION_CLEANUP	cpu_to_le32(0xC01C0009) // -EIO
+#define STATUS_FLT_INTERNAL_ERROR		cpu_to_le32(0xC01C000A) // -EIO
+#define STATUS_FLT_DELETING_OBJECT		cpu_to_le32(0xC01C000B) // -EIO
+#define STATUS_FLT_MUST_BE_NONPAGED_POOL	cpu_to_le32(0xC01C000C) // -EIO
+#define STATUS_FLT_DUPLICATE_ENTRY		cpu_to_le32(0xC01C000D) // -EIO
+#define STATUS_FLT_CBDQ_DISABLED		cpu_to_le32(0xC01C000E) // -EIO
+#define STATUS_FLT_DO_NOT_ATTACH		cpu_to_le32(0xC01C000F) // -EIO
+#define STATUS_FLT_DO_NOT_DETACH		cpu_to_le32(0xC01C0010) // -EIO
+#define STATUS_FLT_INSTANCE_ALTITUDE_COLLISION	cpu_to_le32(0xC01C0011) // -EIO
+#define STATUS_FLT_INSTANCE_NAME_COLLISION	cpu_to_le32(0xC01C0012) // -EIO
+#define STATUS_FLT_FILTER_NOT_FOUND		cpu_to_le32(0xC01C0013) // -EIO
+#define STATUS_FLT_VOLUME_NOT_FOUND		cpu_to_le32(0xC01C0014) // -EIO
+#define STATUS_FLT_INSTANCE_NOT_FOUND		cpu_to_le32(0xC01C0015) // -EIO
+#define STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND	cpu_to_le32(0xC01C0016) // -EIO
+#define STATUS_FLT_INVALID_CONTEXT_REGISTRATION	cpu_to_le32(0xC01C0017) // -EIO
+#define STATUS_FLT_NAME_CACHE_MISS		cpu_to_le32(0xC01C0018) // -EIO
+#define STATUS_FLT_NO_DEVICE_OBJECT		cpu_to_le32(0xC01C0019) // -EIO
+#define STATUS_FLT_VOLUME_ALREADY_MOUNTED	cpu_to_le32(0xC01C001A) // -EIO
+#define STATUS_FLT_ALREADY_ENLISTED		cpu_to_le32(0xC01C001B) // -EIO
+#define STATUS_FLT_CONTEXT_ALREADY_LINKED	cpu_to_le32(0xC01C001C) // -EIO
+#define STATUS_FLT_NO_WAITER_FOR_REPLY		cpu_to_le32(0xC01C0020) // -EIO
+#define STATUS_MONITOR_NO_DESCRIPTOR		cpu_to_le32(0xC01D0001) // -EIO
+#define STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT cpu_to_le32(0xC01D0002) // -EIO
+#define STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM cpu_to_le32(0xC01D0003) // -EIO
+#define STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK cpu_to_le32(0xC01D0004) // -EIO
+#define STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED cpu_to_le32(0xC01D0005) // -EIO
+#define STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK cpu_to_le32(0xC01D0006) // -EIO
+#define STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK cpu_to_le32(0xC01D0007) // -EIO
+#define STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA	cpu_to_le32(0xC01D0008) // -EIO
+#define STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK cpu_to_le32(0xC01D0009) // -EIO
+#define STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER cpu_to_le32(0xC01E0000) // -EIO
+#define STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER	cpu_to_le32(0xC01E0001) // -EIO
+#define STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER	cpu_to_le32(0xC01E0002) // -EIO
+#define STATUS_GRAPHICS_ADAPTER_WAS_RESET	cpu_to_le32(0xC01E0003) // -EIO
+#define STATUS_GRAPHICS_INVALID_DRIVER_MODEL	cpu_to_le32(0xC01E0004) // -EIO
+#define STATUS_GRAPHICS_PRESENT_MODE_CHANGED	cpu_to_le32(0xC01E0005) // -EIO
+#define STATUS_GRAPHICS_PRESENT_OCCLUDED	cpu_to_le32(0xC01E0006) // -EIO
+#define STATUS_GRAPHICS_PRESENT_DENIED		cpu_to_le32(0xC01E0007) // -EIO
+#define STATUS_GRAPHICS_CANNOTCOLORCONVERT	cpu_to_le32(0xC01E0008) // -EIO
+#define STATUS_GRAPHICS_NO_VIDEO_MEMORY		cpu_to_le32(0xC01E0100) // -EIO
+#define STATUS_GRAPHICS_CANT_LOCK_MEMORY	cpu_to_le32(0xC01E0101) // -EIO
+#define STATUS_GRAPHICS_ALLOCATION_BUSY		cpu_to_le32(0xC01E0102) // -EBUSY
+#define STATUS_GRAPHICS_TOO_MANY_REFERENCES	cpu_to_le32(0xC01E0103) // -EIO
+#define STATUS_GRAPHICS_TRY_AGAIN_LATER		cpu_to_le32(0xC01E0104) // -EIO
+#define STATUS_GRAPHICS_TRY_AGAIN_NOW		cpu_to_le32(0xC01E0105) // -EIO
+#define STATUS_GRAPHICS_ALLOCATION_INVALID	cpu_to_le32(0xC01E0106) // -EIO
+#define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE cpu_to_le32(0xC01E0107) // -EIO
+#define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED cpu_to_le32(0xC01E0108) // -EIO
+#define STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION cpu_to_le32(0xC01E0109) // -EIO
+#define STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE cpu_to_le32(0xC01E0110) // -EIO
+#define STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION cpu_to_le32(0xC01E0111) // -EIO
+#define STATUS_GRAPHICS_ALLOCATION_CLOSED	cpu_to_le32(0xC01E0112) // -EIO
+#define STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE cpu_to_le32(0xC01E0113) // -EIO
+#define STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE cpu_to_le32(0xC01E0114) // -EIO
+#define STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE	cpu_to_le32(0xC01E0115) // -EIO
+#define STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST	cpu_to_le32(0xC01E0116) // -EIO
+#define STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE	cpu_to_le32(0xC01E0200) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY	cpu_to_le32(0xC01E0300) // -EIO
+#define STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED cpu_to_le32(0xC01E0301) // -EIO
+#define STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED cpu_to_le32(0xC01E0302) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDPN		cpu_to_le32(0xC01E0303) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE cpu_to_le32(0xC01E0304) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET cpu_to_le32(0xC01E0305) // -EIO
+#define STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED cpu_to_le32(0xC01E0306) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET cpu_to_le32(0xC01E0308) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET cpu_to_le32(0xC01E0309) // -EIO
+#define STATUS_GRAPHICS_INVALID_FREQUENCY	cpu_to_le32(0xC01E030A) // -EIO
+#define STATUS_GRAPHICS_INVALID_ACTIVE_REGION	cpu_to_le32(0xC01E030B) // -EIO
+#define STATUS_GRAPHICS_INVALID_TOTAL_REGION	cpu_to_le32(0xC01E030C) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE cpu_to_le32(0xC01E0310) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE cpu_to_le32(0xC01E0311) // -EIO
+#define STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET cpu_to_le32(0xC01E0312) // -EIO
+#define STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY cpu_to_le32(0xC01E0313) // -EIO
+#define STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET	cpu_to_le32(0xC01E0314) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET cpu_to_le32(0xC01E0315) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET cpu_to_le32(0xC01E0316) // -EIO
+#define STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET	cpu_to_le32(0xC01E0317) // -EIO
+#define STATUS_GRAPHICS_TARGET_ALREADY_IN_SET	cpu_to_le32(0xC01E0318) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH cpu_to_le32(0xC01E0319) // -EIO
+#define STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY cpu_to_le32(0xC01E031A) // -EIO
+#define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET cpu_to_le32(0xC01E031B) // -EIO
+#define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE cpu_to_le32(0xC01E031C) // -EIO
+#define STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET cpu_to_le32(0xC01E031D) // -EIO
+#define STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET cpu_to_le32(0xC01E031F) // -EIO
+#define STATUS_GRAPHICS_STALE_MODESET		cpu_to_le32(0xC01E0320) // -EIO
+#define STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET cpu_to_le32(0xC01E0321) // -EIO
+#define STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE cpu_to_le32(0xC01E0322) // -EIO
+#define STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN cpu_to_le32(0xC01E0323) // -EIO
+#define STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE	cpu_to_le32(0xC01E0324) // -EIO
+#define STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION cpu_to_le32(0xC01E0325) // -EIO
+#define STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES cpu_to_le32(0xC01E0326) // -EIO
+#define STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY	cpu_to_le32(0xC01E0327) // -EIO
+#define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE cpu_to_le32(0xC01E0328) // -EIO
+#define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET cpu_to_le32(0xC01E0329) // -EIO
+#define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET cpu_to_le32(0xC01E032A) // -EIO
+#define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR cpu_to_le32(0xC01E032B) // -EIO
+#define STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET cpu_to_le32(0xC01E032C) // -EIO
+#define STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET cpu_to_le32(0xC01E032D) // -EIO
+#define STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E032E) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE cpu_to_le32(0xC01E032F) // -EIO
+#define STATUS_GRAPHICS_RESOURCES_NOT_RELATED	cpu_to_le32(0xC01E0330) // -EIO
+#define STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0331) // -EIO
+#define STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0332) // -EIO
+#define STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET cpu_to_le32(0xC01E0333) // -EIO
+#define STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER cpu_to_le32(0xC01E0334) // -EIO
+#define STATUS_GRAPHICS_NO_VIDPNMGR		cpu_to_le32(0xC01E0335) // -EIO
+#define STATUS_GRAPHICS_NO_ACTIVE_VIDPN		cpu_to_le32(0xC01E0336) // -EIO
+#define STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY	cpu_to_le32(0xC01E0337) // -EIO
+#define STATUS_GRAPHICS_MONITOR_NOT_CONNECTED	cpu_to_le32(0xC01E0338) // -EIO
+#define STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY	cpu_to_le32(0xC01E0339) // -EIO
+#define STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE cpu_to_le32(0xC01E033A) // -EIO
+#define STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE cpu_to_le32(0xC01E033B) // -EIO
+#define STATUS_GRAPHICS_INVALID_STRIDE		cpu_to_le32(0xC01E033C) // -EIO
+#define STATUS_GRAPHICS_INVALID_PIXELFORMAT	cpu_to_le32(0xC01E033D) // -EIO
+#define STATUS_GRAPHICS_INVALID_COLORBASIS	cpu_to_le32(0xC01E033E) // -EIO
+#define STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE cpu_to_le32(0xC01E033F) // -EIO
+#define STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY	cpu_to_le32(0xC01E0340) // -EIO
+#define STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT cpu_to_le32(0xC01E0341) // -EIO
+#define STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE	cpu_to_le32(0xC01E0342) // -EIO
+#define STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN cpu_to_le32(0xC01E0343) // -EIO
+#define STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL cpu_to_le32(0xC01E0344) // -EIO
+#define STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION cpu_to_le32(0xC01E0345) // -EIO
+#define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED cpu_to_le32(0xC01E0346) // -EIO
+#define STATUS_GRAPHICS_INVALID_GAMMA_RAMP	cpu_to_le32(0xC01E0347) // -EIO
+#define STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED cpu_to_le32(0xC01E0348) // -EIO
+#define STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED cpu_to_le32(0xC01E0349) // -EIO
+#define STATUS_GRAPHICS_MODE_NOT_IN_MODESET	cpu_to_le32(0xC01E034A) // -EIO
+#define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON cpu_to_le32(0xC01E034D) // -EIO
+#define STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE cpu_to_le32(0xC01E034E) // -EIO
+#define STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE cpu_to_le32(0xC01E034F) // -EIO
+#define STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS cpu_to_le32(0xC01E0350) // -EIO
+#define STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING cpu_to_le32(0xC01E0352) // -EIO
+#define STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED cpu_to_le32(0xC01E0353) // -EIO
+#define STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS cpu_to_le32(0xC01E0354) // -EIO
+#define STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT cpu_to_le32(0xC01E0355) // -EIO
+#define STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM cpu_to_le32(0xC01E0356) // -EIO
+#define STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN cpu_to_le32(0xC01E0357) // -EIO
+#define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT cpu_to_le32(0xC01E0358) // -EIO
+#define STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED	cpu_to_le32(0xC01E0359) // -EIO
+#define STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION cpu_to_le32(0xC01E035A) // -EIO
+#define STATUS_GRAPHICS_INVALID_CLIENT_TYPE	cpu_to_le32(0xC01E035B) // -EIO
+#define STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET	cpu_to_le32(0xC01E035C) // -EIO
+#define STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED cpu_to_le32(0xC01E0400) // -EIO
+#define STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED cpu_to_le32(0xC01E0401) // -EIO
+#define STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER	cpu_to_le32(0xC01E0430) // -EIO
+#define STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED	cpu_to_le32(0xC01E0431) // -EIO
+#define STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED cpu_to_le32(0xC01E0432) // -EIO
+#define STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY	cpu_to_le32(0xC01E0433) // -EIO
+#define STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED	cpu_to_le32(0xC01E0434) // -EIO
+#define STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON cpu_to_le32(0xC01E0435) // -EIO
+#define STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE cpu_to_le32(0xC01E0436) // -EIO
+#define STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER	cpu_to_le32(0xC01E0438) // -EIO
+#define STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED cpu_to_le32(0xC01E043B) // -EIO
+#define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS cpu_to_le32(0xC01E051C) // -EIO
+#define STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST cpu_to_le32(0xC01E051D) // -EIO
+#define STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR cpu_to_le32(0xC01E051E) // -EIO
+#define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS cpu_to_le32(0xC01E051F) // -EIO
+#define STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED cpu_to_le32(0xC01E0520) // -EIO
+#define STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST cpu_to_le32(0xC01E0521) // -EIO
+#define STATUS_GRAPHICS_OPM_NOT_SUPPORTED	cpu_to_le32(0xC01E0500) // -EIO
+#define STATUS_GRAPHICS_COPP_NOT_SUPPORTED	cpu_to_le32(0xC01E0501) // -EIO
+#define STATUS_GRAPHICS_UAB_NOT_SUPPORTED	cpu_to_le32(0xC01E0502) // -EIO
+#define STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS cpu_to_le32(0xC01E0503) // -EIO
+#define STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL cpu_to_le32(0xC01E0504) // -EIO
+#define STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST cpu_to_le32(0xC01E0505) // -EIO
+#define STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME cpu_to_le32(0xC01E0506) // -EIO
+#define STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP cpu_to_le32(0xC01E0507) // -EIO
+#define STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED cpu_to_le32(0xC01E0508) // -EIO
+#define STATUS_GRAPHICS_OPM_INVALID_POINTER	cpu_to_le32(0xC01E050A) // -EIO
+#define STATUS_GRAPHICS_OPM_INTERNAL_ERROR	cpu_to_le32(0xC01E050B) // -EIO
+#define STATUS_GRAPHICS_OPM_INVALID_HANDLE	cpu_to_le32(0xC01E050C) // -EIO
+#define STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE cpu_to_le32(0xC01E050D) // -EIO
+#define STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH cpu_to_le32(0xC01E050E) // -EIO
+#define STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED cpu_to_le32(0xC01E050F) // -EIO
+#define STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED cpu_to_le32(0xC01E0510) // -EIO
+#define STATUS_GRAPHICS_PVP_HFS_FAILED		cpu_to_le32(0xC01E0511) // -EIO
+#define STATUS_GRAPHICS_OPM_INVALID_SRM		cpu_to_le32(0xC01E0512) // -EIO
+#define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP cpu_to_le32(0xC01E0513) // -EIO
+#define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP cpu_to_le32(0xC01E0514) // -EIO
+#define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA cpu_to_le32(0xC01E0515) // -EIO
+#define STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET	cpu_to_le32(0xC01E0516) // -EIO
+#define STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH	cpu_to_le32(0xC01E0517) // -EIO
+#define STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE cpu_to_le32(0xC01E0518) // -EIO
+#define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS cpu_to_le32(0xC01E051A) // -EIO
+#define STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS cpu_to_le32(0xC01E051B) // -EIO
+#define STATUS_GRAPHICS_I2C_NOT_SUPPORTED	cpu_to_le32(0xC01E0580) // -EIO
+#define STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST cpu_to_le32(0xC01E0581) // -EIO
+#define STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA cpu_to_le32(0xC01E0582) // -EIO
+#define STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA cpu_to_le32(0xC01E0583) // -EIO
+#define STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED	cpu_to_le32(0xC01E0584) // -EIO
+#define STATUS_GRAPHICS_DDCCI_INVALID_DATA	cpu_to_le32(0xC01E0585) // -EIO
+#define STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE cpu_to_le32(0xC01E0586) // -EIO
+#define STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING cpu_to_le32(0xC01E0587) // -EIO
+#define STATUS_GRAPHICS_MCA_INTERNAL_ERROR	cpu_to_le32(0xC01E0588) // -EIO
+#define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND cpu_to_le32(0xC01E0589) // -EIO
+#define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH cpu_to_le32(0xC01E058A) // -EIO
+#define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM cpu_to_le32(0xC01E058B) // -EIO
+#define STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE cpu_to_le32(0xC01E058C) // -EIO
+#define STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS cpu_to_le32(0xC01E058D) // -EIO
+#define STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED cpu_to_le32(0xC01E05E0) // -EIO
+#define STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME cpu_to_le32(0xC01E05E1) // -EIO
+#define STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP cpu_to_le32(0xC01E05E2) // -EIO
+#define STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED cpu_to_le32(0xC01E05E3) // -EIO
+#define STATUS_GRAPHICS_INVALID_POINTER		cpu_to_le32(0xC01E05E4) // -EIO
+#define STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE cpu_to_le32(0xC01E05E5) // -EIO
+#define STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL cpu_to_le32(0xC01E05E6) // -EIO
+#define STATUS_GRAPHICS_INTERNAL_ERROR		cpu_to_le32(0xC01E05E7) // -EIO
+#define STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS cpu_to_le32(0xC01E05E8) // -EIO
+#define STATUS_FVE_LOCKED_VOLUME		cpu_to_le32(0xC0210000) // -EIO
+#define STATUS_FVE_NOT_ENCRYPTED		cpu_to_le32(0xC0210001) // -EIO
+#define STATUS_FVE_BAD_INFORMATION		cpu_to_le32(0xC0210002) // -EIO
+#define STATUS_FVE_TOO_SMALL			cpu_to_le32(0xC0210003) // -EIO
+#define STATUS_FVE_FAILED_WRONG_FS		cpu_to_le32(0xC0210004) // -EIO
+#define STATUS_FVE_FAILED_BAD_FS		cpu_to_le32(0xC0210005) // -EIO
+#define STATUS_FVE_FS_NOT_EXTENDED		cpu_to_le32(0xC0210006) // -EIO
+#define STATUS_FVE_FS_MOUNTED			cpu_to_le32(0xC0210007) // -EIO
+#define STATUS_FVE_NO_LICENSE			cpu_to_le32(0xC0210008) // -EIO
+#define STATUS_FVE_ACTION_NOT_ALLOWED		cpu_to_le32(0xC0210009) // -EIO
+#define STATUS_FVE_BAD_DATA			cpu_to_le32(0xC021000A) // -EIO
+#define STATUS_FVE_VOLUME_NOT_BOUND		cpu_to_le32(0xC021000B) // -EIO
+#define STATUS_FVE_NOT_DATA_VOLUME		cpu_to_le32(0xC021000C) // -EIO
+#define STATUS_FVE_CONV_READ_ERROR		cpu_to_le32(0xC021000D) // -EIO
+#define STATUS_FVE_CONV_WRITE_ERROR		cpu_to_le32(0xC021000E) // -EIO
+#define STATUS_FVE_OVERLAPPED_UPDATE		cpu_to_le32(0xC021000F) // -EIO
+#define STATUS_FVE_FAILED_SECTOR_SIZE		cpu_to_le32(0xC0210010) // -EIO
+#define STATUS_FVE_FAILED_AUTHENTICATION	cpu_to_le32(0xC0210011) // -EIO
+#define STATUS_FVE_NOT_OS_VOLUME		cpu_to_le32(0xC0210012) // -EIO
+#define STATUS_FVE_KEYFILE_NOT_FOUND		cpu_to_le32(0xC0210013) // -EIO
+#define STATUS_FVE_KEYFILE_INVALID		cpu_to_le32(0xC0210014) // -EIO
+#define STATUS_FVE_KEYFILE_NO_VMK		cpu_to_le32(0xC0210015) // -EIO
+#define STATUS_FVE_TPM_DISABLED			cpu_to_le32(0xC0210016) // -EIO
+#define STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO	cpu_to_le32(0xC0210017) // -EIO
+#define STATUS_FVE_TPM_INVALID_PCR		cpu_to_le32(0xC0210018) // -EIO
+#define STATUS_FVE_TPM_NO_VMK			cpu_to_le32(0xC0210019) // -EIO
+#define STATUS_FVE_PIN_INVALID			cpu_to_le32(0xC021001A) // -EIO
+#define STATUS_FVE_AUTH_INVALID_APPLICATION	cpu_to_le32(0xC021001B) // -EIO
+#define STATUS_FVE_AUTH_INVALID_CONFIG		cpu_to_le32(0xC021001C) // -EIO
+#define STATUS_FVE_DEBUGGER_ENABLED		cpu_to_le32(0xC021001D) // -EIO
+#define STATUS_FVE_DRY_RUN_FAILED		cpu_to_le32(0xC021001E) // -EIO
+#define STATUS_FVE_BAD_METADATA_POINTER		cpu_to_le32(0xC021001F) // -EIO
+#define STATUS_FVE_OLD_METADATA_COPY		cpu_to_le32(0xC0210020) // -EIO
+#define STATUS_FVE_REBOOT_REQUIRED		cpu_to_le32(0xC0210021) // -EIO
+#define STATUS_FVE_RAW_ACCESS			cpu_to_le32(0xC0210022) // -EIO
+#define STATUS_FVE_RAW_BLOCKED			cpu_to_le32(0xC0210023) // -EIO
+#define STATUS_FWP_CALLOUT_NOT_FOUND		cpu_to_le32(0xC0220001) // -EIO
+#define STATUS_FWP_CONDITION_NOT_FOUND		cpu_to_le32(0xC0220002) // -EIO
+#define STATUS_FWP_FILTER_NOT_FOUND		cpu_to_le32(0xC0220003) // -EIO
+#define STATUS_FWP_LAYER_NOT_FOUND		cpu_to_le32(0xC0220004) // -EIO
+#define STATUS_FWP_PROVIDER_NOT_FOUND		cpu_to_le32(0xC0220005) // -EIO
+#define STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND	cpu_to_le32(0xC0220006) // -EIO
+#define STATUS_FWP_SUBLAYER_NOT_FOUND		cpu_to_le32(0xC0220007) // -EIO
+#define STATUS_FWP_NOT_FOUND			cpu_to_le32(0xC0220008) // -EIO
+#define STATUS_FWP_ALREADY_EXISTS		cpu_to_le32(0xC0220009) // -EIO
+#define STATUS_FWP_IN_USE			cpu_to_le32(0xC022000A) // -EIO
+#define STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS	cpu_to_le32(0xC022000B) // -EIO
+#define STATUS_FWP_WRONG_SESSION		cpu_to_le32(0xC022000C) // -EIO
+#define STATUS_FWP_NO_TXN_IN_PROGRESS		cpu_to_le32(0xC022000D) // -EIO
+#define STATUS_FWP_TXN_IN_PROGRESS		cpu_to_le32(0xC022000E) // -EIO
+#define STATUS_FWP_TXN_ABORTED			cpu_to_le32(0xC022000F) // -EIO
+#define STATUS_FWP_SESSION_ABORTED		cpu_to_le32(0xC0220010) // -EIO
+#define STATUS_FWP_INCOMPATIBLE_TXN		cpu_to_le32(0xC0220011) // -EIO
+#define STATUS_FWP_TIMEOUT			cpu_to_le32(0xC0220012) // -ETIMEDOUT
+#define STATUS_FWP_NET_EVENTS_DISABLED		cpu_to_le32(0xC0220013) // -EIO
+#define STATUS_FWP_INCOMPATIBLE_LAYER		cpu_to_le32(0xC0220014) // -EIO
+#define STATUS_FWP_KM_CLIENTS_ONLY		cpu_to_le32(0xC0220015) // -EIO
+#define STATUS_FWP_LIFETIME_MISMATCH		cpu_to_le32(0xC0220016) // -EIO
+#define STATUS_FWP_BUILTIN_OBJECT		cpu_to_le32(0xC0220017) // -EIO
+#define STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS	cpu_to_le32(0xC0220018) // -EIO
+#define STATUS_FWP_TOO_MANY_CALLOUTS		cpu_to_le32(0xC0220018) // -EIO
+#define STATUS_FWP_NOTIFICATION_DROPPED		cpu_to_le32(0xC0220019) // -EIO
+#define STATUS_FWP_TRAFFIC_MISMATCH		cpu_to_le32(0xC022001A) // -EIO
+#define STATUS_FWP_INCOMPATIBLE_SA_STATE	cpu_to_le32(0xC022001B) // -EIO
+#define STATUS_FWP_NULL_POINTER			cpu_to_le32(0xC022001C) // -EIO
+#define STATUS_FWP_INVALID_ENUMERATOR		cpu_to_le32(0xC022001D) // -EIO
+#define STATUS_FWP_INVALID_FLAGS		cpu_to_le32(0xC022001E) // -EIO
+#define STATUS_FWP_INVALID_NET_MASK		cpu_to_le32(0xC022001F) // -EIO
+#define STATUS_FWP_INVALID_RANGE		cpu_to_le32(0xC0220020) // -EIO
+#define STATUS_FWP_INVALID_INTERVAL		cpu_to_le32(0xC0220021) // -EIO
+#define STATUS_FWP_ZERO_LENGTH_ARRAY		cpu_to_le32(0xC0220022) // -EIO
+#define STATUS_FWP_NULL_DISPLAY_NAME		cpu_to_le32(0xC0220023) // -EIO
+#define STATUS_FWP_INVALID_ACTION_TYPE		cpu_to_le32(0xC0220024) // -EIO
+#define STATUS_FWP_INVALID_WEIGHT		cpu_to_le32(0xC0220025) // -EIO
+#define STATUS_FWP_MATCH_TYPE_MISMATCH		cpu_to_le32(0xC0220026) // -EIO
+#define STATUS_FWP_TYPE_MISMATCH		cpu_to_le32(0xC0220027) // -EIO
+#define STATUS_FWP_OUT_OF_BOUNDS		cpu_to_le32(0xC0220028) // -EIO
+#define STATUS_FWP_RESERVED			cpu_to_le32(0xC0220029) // -EIO
+#define STATUS_FWP_DUPLICATE_CONDITION		cpu_to_le32(0xC022002A) // -EIO
+#define STATUS_FWP_DUPLICATE_KEYMOD		cpu_to_le32(0xC022002B) // -EIO
+#define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER cpu_to_le32(0xC022002C) // -EIO
+#define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER cpu_to_le32(0xC022002D) // -EIO
+#define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER cpu_to_le32(0xC022002E) // -EIO
+#define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT cpu_to_le32(0xC022002F) // -EIO
+#define STATUS_FWP_INCOMPATIBLE_AUTH_METHOD	cpu_to_le32(0xC0220030) // -EIO
+#define STATUS_FWP_INCOMPATIBLE_DH_GROUP	cpu_to_le32(0xC0220031) // -EIO
+#define STATUS_FWP_EM_NOT_SUPPORTED		cpu_to_le32(0xC0220032) // -EOPNOTSUPP
+#define STATUS_FWP_NEVER_MATCH			cpu_to_le32(0xC0220033) // -EIO
+#define STATUS_FWP_PROVIDER_CONTEXT_MISMATCH	cpu_to_le32(0xC0220034) // -EIO
+#define STATUS_FWP_INVALID_PARAMETER		cpu_to_le32(0xC0220035) // -EIO
+#define STATUS_FWP_TOO_MANY_SUBLAYERS		cpu_to_le32(0xC0220036) // -EIO
+#define STATUS_FWP_CALLOUT_NOTIFICATION_FAILED	cpu_to_le32(0xC0220037) // -EIO
+#define STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG	cpu_to_le32(0xC0220038) // -EIO
+#define STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG	cpu_to_le32(0xC0220039) // -EIO
+#define STATUS_FWP_TCPIP_NOT_READY		cpu_to_le32(0xC0220100) // -EIO
+#define STATUS_FWP_INJECT_HANDLE_CLOSING	cpu_to_le32(0xC0220101) // -EIO
+#define STATUS_FWP_INJECT_HANDLE_STALE		cpu_to_le32(0xC0220102) // -EIO
+#define STATUS_FWP_CANNOT_PEND			cpu_to_le32(0xC0220103) // -EIO
+#define STATUS_NDIS_CLOSING			cpu_to_le32(0xC0230002) // -EIO
+#define STATUS_NDIS_BAD_VERSION			cpu_to_le32(0xC0230004) // -EIO
+#define STATUS_NDIS_BAD_CHARACTERISTICS		cpu_to_le32(0xC0230005) // -EIO
+#define STATUS_NDIS_ADAPTER_NOT_FOUND		cpu_to_le32(0xC0230006) // -EIO
+#define STATUS_NDIS_OPEN_FAILED			cpu_to_le32(0xC0230007) // -EIO
+#define STATUS_NDIS_DEVICE_FAILED		cpu_to_le32(0xC0230008) // -EIO
+#define STATUS_NDIS_MULTICAST_FULL		cpu_to_le32(0xC0230009) // -EIO
+#define STATUS_NDIS_MULTICAST_EXISTS		cpu_to_le32(0xC023000A) // -EIO
+#define STATUS_NDIS_MULTICAST_NOT_FOUND		cpu_to_le32(0xC023000B) // -EIO
+#define STATUS_NDIS_REQUEST_ABORTED		cpu_to_le32(0xC023000C) // -EIO
+#define STATUS_NDIS_RESET_IN_PROGRESS		cpu_to_le32(0xC023000D) // -EIO
+#define STATUS_NDIS_INVALID_PACKET		cpu_to_le32(0xC023000F) // -EIO
+#define STATUS_NDIS_INVALID_DEVICE_REQUEST	cpu_to_le32(0xC0230010) // -EIO
+#define STATUS_NDIS_ADAPTER_NOT_READY		cpu_to_le32(0xC0230011) // -EIO
+#define STATUS_NDIS_INVALID_LENGTH		cpu_to_le32(0xC0230014) // -EIO
+#define STATUS_NDIS_INVALID_DATA		cpu_to_le32(0xC0230015) // -EIO
+#define STATUS_NDIS_BUFFER_TOO_SHORT		cpu_to_le32(0xC0230016) // -ENOBUFS
+#define STATUS_NDIS_INVALID_OID			cpu_to_le32(0xC0230017) // -EIO
+#define STATUS_NDIS_ADAPTER_REMOVED		cpu_to_le32(0xC0230018) // -EIO
+#define STATUS_NDIS_UNSUPPORTED_MEDIA		cpu_to_le32(0xC0230019) // -EIO
+#define STATUS_NDIS_GROUP_ADDRESS_IN_USE	cpu_to_le32(0xC023001A) // -EIO
+#define STATUS_NDIS_FILE_NOT_FOUND		cpu_to_le32(0xC023001B) // -EIO
+#define STATUS_NDIS_ERROR_READING_FILE		cpu_to_le32(0xC023001C) // -EIO
+#define STATUS_NDIS_ALREADY_MAPPED		cpu_to_le32(0xC023001D) // -EIO
+#define STATUS_NDIS_RESOURCE_CONFLICT		cpu_to_le32(0xC023001E) // -EIO
+#define STATUS_NDIS_MEDIA_DISCONNECTED		cpu_to_le32(0xC023001F) // -EIO
+#define STATUS_NDIS_INVALID_ADDRESS		cpu_to_le32(0xC0230022) // -EIO
+#define STATUS_NDIS_PAUSED			cpu_to_le32(0xC023002A) // -EIO
+#define STATUS_NDIS_INTERFACE_NOT_FOUND		cpu_to_le32(0xC023002B) // -EIO
+#define STATUS_NDIS_UNSUPPORTED_REVISION	cpu_to_le32(0xC023002C) // -EIO
+#define STATUS_NDIS_INVALID_PORT		cpu_to_le32(0xC023002D) // -EIO
+#define STATUS_NDIS_INVALID_PORT_STATE		cpu_to_le32(0xC023002E) // -EIO
+#define STATUS_NDIS_LOW_POWER_STATE		cpu_to_le32(0xC023002F) // -EIO
+#define STATUS_NDIS_NOT_SUPPORTED		cpu_to_le32(0xC02300BB) // -ENOSYS
+#define STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED	cpu_to_le32(0xC0232000) // -EIO
+#define STATUS_NDIS_DOT11_MEDIA_IN_USE		cpu_to_le32(0xC0232001) // -EIO
+#define STATUS_NDIS_DOT11_POWER_STATE_INVALID	cpu_to_le32(0xC0232002) // -EIO
+#define STATUS_IPSEC_BAD_SPI			cpu_to_le32(0xC0360001) // -EIO
+#define STATUS_IPSEC_SA_LIFETIME_EXPIRED	cpu_to_le32(0xC0360002) // -EIO
+#define STATUS_IPSEC_WRONG_SA			cpu_to_le32(0xC0360003) // -EIO
+#define STATUS_IPSEC_REPLAY_CHECK_FAILED	cpu_to_le32(0xC0360004) // -EIO
+#define STATUS_IPSEC_INVALID_PACKET		cpu_to_le32(0xC0360005) // -EIO
+#define STATUS_IPSEC_INTEGRITY_CHECK_FAILED	cpu_to_le32(0xC0360006) // -EIO
+#define STATUS_IPSEC_CLEAR_TEXT_DROP		cpu_to_le32(0xC0360007) // -EIO
+/* See MS-SMB2 3.3.5.4 */
+#define STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP cpu_to_le32(0xC05D0000) // -EIO
+
+#endif /* FS_SMB_COMMON_SMB2STATUS_H */
diff --git a/fs/smb/common/smbacl.h b/fs/smb/common/smbacl.h
new file mode 100644
index 000000000..70bba5ff7
--- /dev/null
+++ b/fs/smb/common/smbacl.h
@@ -0,0 +1,122 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
+/*
+ *   Copyright (c) International Business Machines  Corp., 2007
+ *   Author(s): Steve French (sfrench@us.ibm.com)
+ *   Modified by Namjae Jeon (linkinjeon@kernel.org)
+ */
+
+#ifndef _COMMON_SMBACL_H
+#define _COMMON_SMBACL_H
+
+#define NUM_AUTHS (6)	/* number of authority fields */
+#define SID_MAX_SUB_AUTHORITIES (15) /* max number of sub authority fields */
+
+/* ACE types - see MS-DTYP 2.4.4.1 */
+#define ACCESS_ALLOWED_ACE_TYPE 0x00
+#define ACCESS_DENIED_ACE_TYPE  0x01
+#define SYSTEM_AUDIT_ACE_TYPE   0x02
+#define SYSTEM_ALARM_ACE_TYPE   0x03
+#define ACCESS_ALLOWED_COMPOUND_ACE_TYPE 0x04
+#define ACCESS_ALLOWED_OBJECT_ACE_TYPE  0x05
+#define ACCESS_DENIED_OBJECT_ACE_TYPE   0x06
+#define SYSTEM_AUDIT_OBJECT_ACE_TYPE    0x07
+#define SYSTEM_ALARM_OBJECT_ACE_TYPE    0x08
+#define ACCESS_ALLOWED_CALLBACK_ACE_TYPE 0x09
+#define ACCESS_DENIED_CALLBACK_ACE_TYPE 0x0A
+#define ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE 0x0B
+#define ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE  0x0C
+#define SYSTEM_AUDIT_CALLBACK_ACE_TYPE  0x0D
+#define SYSTEM_ALARM_CALLBACK_ACE_TYPE  0x0E /* Reserved */
+#define SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE 0x0F
+#define SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE 0x10 /* reserved */
+#define SYSTEM_MANDATORY_LABEL_ACE_TYPE 0x11
+#define SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE 0x12
+#define SYSTEM_SCOPED_POLICY_ID_ACE_TYPE 0x13
+
+/* ACE flags */
+#define OBJECT_INHERIT_ACE		0x01
+#define CONTAINER_INHERIT_ACE		0x02
+#define NO_PROPAGATE_INHERIT_ACE	0x04
+#define INHERIT_ONLY_ACE		0x08
+#define INHERITED_ACE			0x10
+#define SUCCESSFUL_ACCESS_ACE_FLAG	0x40
+#define FAILED_ACCESS_ACE_FLAG		0x80
+
+/*
+ * Maximum size of a string representation of a SID:
+ *
+ * The fields are unsigned values in decimal. So:
+ *
+ * u8:  max 3 bytes in decimal
+ * u32: max 10 bytes in decimal
+ *
+ * "S-" + 3 bytes for version field + 15 for authority field + NULL terminator
+ *
+ * For authority field, max is when all 6 values are non-zero and it must be
+ * represented in hex. So "-0x" + 12 hex digits.
+ *
+ * Add 11 bytes for each subauthority field (10 bytes each + 1 for '-')
+ */
+#define SID_STRING_BASE_SIZE (2 + 3 + 15 + 1)
+#define SID_STRING_SUBAUTH_SIZE (11) /* size of a single subauth string */
+
+#define DOMAIN_USER_RID_LE	cpu_to_le32(513)
+
+/*
+ * ACE types - see MS-DTYP 2.4.4.1
+ */
+enum {
+	ACCESS_ALLOWED,
+	ACCESS_DENIED,
+};
+
+/*
+ * Security ID types
+ */
+enum {
+	SIDOWNER = 1,
+	SIDGROUP,
+	SIDCREATOR_OWNER,
+	SIDCREATOR_GROUP,
+	SIDUNIX_USER,
+	SIDUNIX_GROUP,
+	SIDNFS_USER,
+	SIDNFS_GROUP,
+	SIDNFS_MODE,
+};
+
+struct smb_ntsd {
+	__le16 revision; /* revision level */
+	__le16 type;
+	__le32 osidoffset;
+	__le32 gsidoffset;
+	__le32 sacloffset;
+	__le32 dacloffset;
+} __packed;
+
+struct smb_sid {
+	__u8 revision; /* revision level */
+	__u8 num_subauth;
+	__u8 authority[NUM_AUTHS];
+	__le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */
+} __packed;
+
+/* size of a struct smb_sid, sans sub_auth array */
+#define CIFS_SID_BASE_SIZE (1 + 1 + NUM_AUTHS)
+
+struct smb_acl {
+	__le16 revision; /* revision level */
+	__le16 size;
+	__le16 num_aces;
+	__le16 reserved;
+} __packed;
+
+struct smb_ace {
+	__u8 type; /* see above and MS-DTYP 2.4.4.1 */
+	__u8 flags;
+	__le16 size;
+	__le32 access_req;
+	struct smb_sid sid; /* ie UUID of user or group who gets these perms */
+} __packed;
+
+#endif /* _COMMON_SMBACL_H */
diff --git a/fs/smb/common/smbfsctl.h b/fs/smb/common/smbfsctl.h
new file mode 100644
index 000000000..b1123b0f7
--- /dev/null
+++ b/fs/smb/common/smbfsctl.h
@@ -0,0 +1,175 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
+/*
+ *   SMB, CIFS, SMB2 FSCTL definitions
+ *
+ *   Copyright (c) International Business Machines  Corp., 2002,2013
+ *   Author(s): Steve French (sfrench@us.ibm.com)
+ *
+ */
+
+/* IOCTL information */
+/*
+ * List of ioctl/fsctl function codes that are or could be useful in the
+ * future to remote clients like cifs or SMB2/SMB3 client.  This is probably
+ * a slightly larger set of fsctls that NTFS local filesystem could handle,
+ * including the seven below that we do not have struct definitions for.
+ * Even with protocol definitions for most of these now available, we still
+ * need to do some experimentation to identify which are practical to do
+ * remotely.  Some of the following, such as the encryption/compression ones
+ * could be invoked from tools via a specialized hook into the VFS rather
+ * than via the standard vfs entry points
+ *
+ * See MS-SMB2 Section 2.2.31 (last checked September 2021, all of that list are
+ * below). Additional detail on less common ones can be found in MS-FSCC
+ * section 2.3.
+ */
+
+#ifndef __SMBFSCTL_H
+#define __SMBFSCTL_H
+
+/*
+ * FSCTL values are 32 bits and are constructed as
+ * <device 16bits> <access 2bits> <function 12bits> <method 2bits>
+ */
+/* Device */
+#define FSCTL_DEVICE_DFS                 (0x0006 << 16)
+#define FSCTL_DEVICE_FILE_SYSTEM         (0x0009 << 16)
+#define FSCTL_DEVICE_NAMED_PIPE          (0x0011 << 16)
+#define FSCTL_DEVICE_NETWORK_FILE_SYSTEM (0x0014 << 16)
+#define FSCTL_DEVICE_MASK                0xffff0000
+/* Access */
+#define FSCTL_DEVICE_ACCESS_FILE_ANY_ACCESS        (0x00 << 14)
+#define FSCTL_DEVICE_ACCESS_FILE_READ_ACCESS       (0x01 << 14)
+#define FSCTL_DEVICE_ACCESS_FILE_WRITE_ACCESS      (0x02 << 14)
+#define FSCTL_DEVICE_ACCESS_FILE_READ_WRITE_ACCESS (0x03 << 14)
+#define FSCTL_DEVICE_ACCESS_MASK                   0x0000c000
+/* Function */
+#define FSCTL_DEVICE_FUNCTION_MASK       0x00003ffc
+/* Method */
+#define FSCTL_DEVICE_METHOD_BUFFERED   0x00
+#define FSCTL_DEVICE_METHOD_IN_DIRECT  0x01
+#define FSCTL_DEVICE_METHOD_OUT_DIRECT 0x02
+#define FSCTL_DEVICE_METHOD_NEITHER    0x03
+#define FSCTL_DEVICE_METHOD_MASK       0x00000003
+
+
+#define FSCTL_DFS_GET_REFERRALS      0x00060194
+#define FSCTL_DFS_GET_REFERRALS_EX   0x000601B0
+#define FSCTL_REQUEST_OPLOCK_LEVEL_1 0x00090000
+#define FSCTL_REQUEST_OPLOCK_LEVEL_2 0x00090004
+#define FSCTL_REQUEST_BATCH_OPLOCK   0x00090008
+#define FSCTL_LOCK_VOLUME            0x00090018
+#define FSCTL_UNLOCK_VOLUME          0x0009001C
+#define FSCTL_IS_PATHNAME_VALID      0x0009002C /* BB add struct */
+#define FSCTL_GET_COMPRESSION        0x0009003C
+#define FSCTL_SET_COMPRESSION        0x0009C040
+#define FSCTL_QUERY_FAT_BPB          0x00090058 /* BB add struct */
+/* Verify the next FSCTL number, we had it as 0x00090090 before */
+#define FSCTL_FILESYSTEM_GET_STATS   0x00090060 /* BB add struct */
+#define FSCTL_GET_NTFS_VOLUME_DATA   0x00090064 /* BB add struct */
+#define FSCTL_GET_RETRIEVAL_POINTERS 0x00090073 /* BB add struct */
+#define FSCTL_IS_VOLUME_DIRTY        0x00090078 /* BB add struct */
+#define FSCTL_ALLOW_EXTENDED_DASD_IO 0x00090083 /* BB add struct */
+#define FSCTL_REQUEST_FILTER_OPLOCK  0x0009008C
+#define FSCTL_FIND_FILES_BY_SID      0x0009008F /* BB add struct */
+#define FSCTL_SET_OBJECT_ID          0x00090098 /* BB add struct */
+#define FSCTL_GET_OBJECT_ID          0x0009009C /* BB add struct */
+#define FSCTL_DELETE_OBJECT_ID       0x000900A0 /* BB add struct */
+#define FSCTL_SET_REPARSE_POINT      0x000900A4 /* BB add struct */
+#define FSCTL_GET_REPARSE_POINT      0x000900A8 /* BB add struct */
+#define FSCTL_DELETE_REPARSE_POINT   0x000900AC /* BB add struct */
+#define FSCTL_SET_OBJECT_ID_EXTENDED 0x000900BC /* BB add struct */
+#define FSCTL_CREATE_OR_GET_OBJECT_ID 0x000900C0 /* BB add struct */
+#define FSCTL_SET_SPARSE             0x000900C4 /* BB add struct */
+#define FSCTL_SET_ZERO_DATA          0x000980C8
+#define FSCTL_SET_ENCRYPTION         0x000900D7 /* BB add struct */
+#define FSCTL_ENCRYPTION_FSCTL_IO    0x000900DB /* BB add struct */
+#define FSCTL_WRITE_RAW_ENCRYPTED    0x000900DF /* BB add struct */
+#define FSCTL_READ_RAW_ENCRYPTED     0x000900E3 /* BB add struct */
+#define FSCTL_READ_FILE_USN_DATA     0x000900EB /* BB add struct */
+#define FSCTL_WRITE_USN_CLOSE_RECORD 0x000900EF /* BB add struct */
+#define FSCTL_MARK_HANDLE	     0x000900FC /* BB add struct */
+#define FSCTL_SIS_COPYFILE           0x00090100 /* BB add struct */
+#define FSCTL_RECALL_FILE            0x00090117 /* BB add struct */
+#define FSCTL_QUERY_SPARING_INFO     0x00090138 /* BB add struct */
+#define FSCTL_QUERY_ON_DISK_VOLUME_INFO 0x0009013C
+#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_FILE_REGIONS     0x00090284
+#define FSCTL_GET_REFS_VOLUME_DATA   0x000902D8 /* See MS-FSCC 2.3.24 */
+#define FSCTL_SET_INTEGRITY_INFORMATION_EXT 0x00090380
+#define FSCTL_GET_RETRIEVAL_POINTERS_AND_REFCOUNT 0x000903d3
+#define FSCTL_GET_RETRIEVAL_POINTER_COUNT 0x0009042b
+#define FSCTL_REFS_STREAM_SNAPSHOT_MANAGEMENT 0x00090440
+#define FSCTL_QUERY_ALLOCATED_RANGES 0x000940CF
+#define FSCTL_OFFLOAD_READ	0x00094264 /* BB add struct */
+#define FSCTL_OFFLOAD_WRITE	0x00098268 /* 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_DUPLICATE_EXTENTS_TO_FILE_EX 0x000983E8
+#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 */
+#define FSCTL_PIPE_WAIT              0x00110018 /* BB add struct */
+/* Enumerate previous versions of a file */
+#define FSCTL_SRV_ENUMERATE_SNAPSHOTS 0x00144064
+/* Retrieve an opaque file reference for server-side data movement ie copy */
+#define FSCTL_SRV_REQUEST_RESUME_KEY 0x00140078
+#define FSCTL_SRV_ENUM_SNAPS 0x00144064
+#define FSCTL_LMR_REQUEST_RESILIENCY 0x001401D4
+#define FSCTL_LMR_GET_LINK_TRACK_INF 0x001400E8 /* BB add struct */
+#define FSCTL_LMR_SET_LINK_TRACK_INF 0x001400EC /* BB add struct */
+#define FSCTL_VALIDATE_NEGOTIATE_INFO 0x00140204
+/* Perform server-side data movement */
+#define FSCTL_SRV_COPYCHUNK 0x001440F2
+#define FSCTL_SRV_COPYCHUNK_WRITE 0x001480F2
+#define FSCTL_QUERY_NETWORK_INTERFACE_INFO 0x001401FC /* BB add struct */
+#define FSCTL_SRV_READ_HASH          0x001441BB /* BB add struct */
+
+/* See FSCC 2.1.2.5 */
+#define IO_REPARSE_TAG_MOUNT_POINT   0xA0000003
+#define IO_REPARSE_TAG_HSM           0xC0000004
+#define IO_REPARSE_TAG_SIS           0x80000007
+#define IO_REPARSE_TAG_HSM2          0x80000006
+#define IO_REPARSE_TAG_DRIVER_EXTENDER 0x80000005
+/* Used by the DFS filter. See MS-DFSC */
+#define IO_REPARSE_TAG_DFS           0x8000000A
+/* Used by the DFS filter See MS-DFSC */
+#define IO_REPARSE_TAG_DFSR          0x80000012
+#define IO_REPARSE_TAG_FILTER_MANAGER 0x8000000B
+/* Native SMB symlinks since Windows Vista, see MS-FSCC 2.1.2.4 */
+#define IO_REPARSE_TAG_SYMLINK       0xA000000C
+#define IO_REPARSE_TAG_DEDUP         0x80000013
+#define IO_REPARSE_APPXSTREAM	     0xC0000014
+/* NFS special files used by Windows NFS server since Windows Server 2012, see MS-FSCC 2.1.2.6 */
+#define IO_REPARSE_TAG_NFS           0x80000014
+/*
+ * AzureFileSync - see
+ * https://docs.microsoft.com/en-us/azure/storage/files/storage-sync-cloud-tiering
+ */
+#define IO_REPARSE_TAG_AZ_FILE_SYNC  0x8000001e
+/* Native Win32 AF_UNIX sockets since Windows 10 April 2018 Update, used also by WSL */
+#define IO_REPARSE_TAG_AF_UNIX       0x80000023
+/* WSL reparse tags */
+#define IO_REPARSE_TAG_LX_SYMLINK    0xA000001D
+#define IO_REPARSE_TAG_LX_FIFO	     0x80000024
+#define IO_REPARSE_TAG_LX_CHR	     0x80000025
+#define IO_REPARSE_TAG_LX_BLK	     0x80000026
+
+#define IO_REPARSE_TAG_LX_SYMLINK_LE   cpu_to_le32(IO_REPARSE_TAG_LX_SYMLINK)
+#define IO_REPARSE_TAG_AF_UNIX_LE      cpu_to_le32(IO_REPARSE_TAG_AF_UNIX)
+#define IO_REPARSE_TAG_LX_FIFO_LE      cpu_to_le32(IO_REPARSE_TAG_LX_FIFO)
+#define IO_REPARSE_TAG_LX_CHR_LE       cpu_to_le32(IO_REPARSE_TAG_LX_CHR)
+#define IO_REPARSE_TAG_LX_BLK_LE       cpu_to_le32(IO_REPARSE_TAG_LX_BLK)
+
+/* If Name Surrogate Bit is set, the file or directory represents another named entity in the system. */
+#define IS_REPARSE_TAG_NAME_SURROGATE(tag) (!!((tag) & 0x20000000))
+
+/* fsctl flags */
+/* If Flags is set to this value, the request is an FSCTL not ioctl request */
+#define SMB2_0_IOCTL_IS_FSCTL		0x00000001
+#endif /* __SMBFSCTL_H */
diff --git a/fs/smb/common/smbglob.h b/fs/smb/common/smbglob.h
new file mode 100644
index 000000000..d9c7e6e7a
--- /dev/null
+++ b/fs/smb/common/smbglob.h
@@ -0,0 +1,70 @@
+/* SPDX-License-Identifier: LGPL-2.1 */
+/*
+ *
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
+ *                 2018 Samsung Electronics Co., Ltd.
+ *   Author(s): Steve French (sfrench@us.ibm.com)
+ *              Jeremy Allison (jra@samba.org)
+ *              Namjae Jeon (linkinjeon@kernel.org)
+ *
+ */
+#ifndef _COMMON_SMB_GLOB_H
+#define _COMMON_SMB_GLOB_H
+
+struct smb_version_values {
+	char		*version_string;
+	__u16		protocol_id;
+	__le16		lock_cmd;
+	__u32		req_capabilities;
+	__u32		max_read_size;
+	__u32		max_write_size;
+	__u32		max_trans_size;
+	__u32		max_credits;
+	__u32		large_lock_type;
+	__u32		exclusive_lock_type;
+	__u32		shared_lock_type;
+	__u32		unlock_lock_type;
+	size_t		header_size;
+	size_t		max_header_size;
+	size_t		read_rsp_size;
+	unsigned int	cap_unix;
+	unsigned int	cap_nt_find;
+	unsigned int	cap_large_files;
+	unsigned int	cap_unicode;
+	__u16		signing_enabled;
+	__u16		signing_required;
+	size_t		create_lease_size;
+	size_t		create_durable_size;
+	size_t		create_durable_v2_size;
+	size_t		create_mxac_size;
+	size_t		create_disk_id_size;
+	size_t		create_posix_size;
+	size_t		create_aapl_size;
+};
+
+static inline unsigned int get_rfc1002_len(void *buf)
+{
+	return be32_to_cpu(*((__be32 *)buf)) & 0xffffff;
+}
+
+static inline void inc_rfc1001_len(void *buf, int count)
+{
+	be32_add_cpu((__be32 *)buf, count);
+}
+
+#define SMB1_VERSION_STRING	"1.0"
+#define SMB20_VERSION_STRING    "2.0"
+#define SMB21_VERSION_STRING	"2.1"
+#define SMBDEFAULT_VERSION_STRING "default"
+#define SMB3ANY_VERSION_STRING "3"
+#define SMB30_VERSION_STRING	"3.0"
+#define SMB302_VERSION_STRING	"3.02"
+#define ALT_SMB302_VERSION_STRING "3.0.2"
+#define SMB311_VERSION_STRING	"3.1.1"
+#define ALT_SMB311_VERSION_STRING "3.11"
+
+#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
+
+#define MAX_CIFS_SMALL_BUFFER_SIZE 448 /* big enough for most */
+
+#endif	/* _COMMON_SMB_GLOB_H */