Merge tag 'trace-v7.3-2' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-tracegrafted

Pull tracing fixes from Steven Rostedt:

 - Fix error output of boot instance creation failure

   Currently if a boot instance creation fails, instead of printing out
   the name of the instance that failed, it prints "(null)". That is
   because it prints "cur_str" that had already been processed by
   strsep(). Print the saved name instead.

   While at it, print the error code of the failure.

 - Fix use-after-free for same named historgrams

   Histograms can be named so that they can be used in multiple events.
   But if the named histogram has a variable attached, the second event
   that uses the named histogram which duplicates it and needs to free
   the original after duplication leaves the old variable in place and
   still visible. If another histogram uses than variable, it will use
   the stale one which will try to reference the freed duplicate
   histogram and crash the kernel.

   Free the duplicate variables along with the duplicated histogram
   data.

 - Check return value of kthread_run() in event self test

   The events self tests uses a kthread for testing but does not check
   if it succeeded in creating a kthread. If the kthread creation were
   to fail, the code will still try to call kthread_stop() on the error
   returned.

 - Fix race between reading trace_pipe and updating subbuffer size

   If a user is reading the trace_pipe file at the same time they update
   the ring buffer sub-buffer size, can cause the trace_pipe read to
   read stale data. Add trace_access_lock() around updating the ring
   buffer sub-buffer size.

 - Fix eventfs_inode on failure path in creation of the events directory

   In the creation of the "events" directory, if after allocating the
   eventfs_inode a failure is detected, it calls cleanup_ei() which
   calls free_ei(). The free_ei() will test if eventfs_inode being freed
   has no children. It is a bug if it does. But on the failure case of
   the creation of the "events" directory, the children lists have not
   yet been initialized and the free will trigger a warning because
   list_empty() on an uninitialized list returns false.

   Move the initialization into init_ei() where it makes more sense and
   makes sure that a created eventfs_inode has its lists initialized
   upon creation.

 - Check return value of kthread_run() in ftrace direct sample code

   The sample code that shows how to use the ftrace direct calls does
   not test the return of kthread_run() to see if it succeeds. Return a
   failure if the kthread_run() doesn't succeed.

 - Clear user events state on fork in case of alloc failure

   On fork, the child gets a pointer to the parent's user events state.
   It makes a copy of it then updates the child's pointer to it. But if
   the allocation fails, the duplication function leaves the child with
   a pointer to its parent's descriptor. When the child cleans up its
   data, it will free the parent's descriptor while the parent is still
   using it.

   In the duplication function, set the child's user_event_mm to NULL
   before testing if the allocation succeeded, and when it exits it will
   not free the parent's descriptor.

 - Fix retry exhaustion in simple ring buffer reader swap

   simple_ring_buffer_swap_reader_page() starts with retry set to 8 and
   post-decrements it only after a failed link replacement. On the final
   attempt, a successful replacement leaves retry at zero, while a
   failed replacement leaves it at -1.

   But the check for success expects the retry value to be non-zero and
   exits with an error on zero. This is the opposite result. Fix it.

 - Fail nicely when the remote swap_reader_page() returns an error

   Currently, if the swap_reader_page() of a remote buffer fails, it
   triggers a WARN_ON_ONCE() and continues normally. Instead, have it
   exit with an error and a pr_warn() print instead of a full WARNING.

* tag 'trace-v7.3-2' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace:
  ring-buffer: Stop remote reader update when page swap fails
  tracing: Fix retry exhaustion in simple ring buffer reader swap
  tracing/user_events: Clear copied tracing state before fork duplication
  samples/ftrace: Fix kthread_stop() on ERR_PTR in ftrace-direct-multi-modify
  samples/ftrace: Fix kthread_stop() on ERR_PTR in ftrace-direct-modify
  eventfs: Initialize ei->children and ei->list in init_ei()
  tracing: Fix use-after-free in trace_pipe read on sub-buffer order change
  tracing: Fix crash passing ERR_PTR to kthread_stop()
  tracing: Fix use-after-free with same-name named triggers
  tracing: Fix logged instance name on creation failure

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 */