summaryrefslogtreecommitdiffstats
path: root/fs/smb/common
diff options
context:
space:
mode:
Diffstat (limited to 'fs/smb/common')
-rw-r--r--fs/smb/common/Makefile9
-rw-r--r--fs/smb/common/cifs_md4.c198
-rw-r--r--fs/smb/common/compress/compress.c404
-rw-r--r--fs/smb/common/compress/compress.h29
-rw-r--r--fs/smb/common/compress/lz77.c461
-rw-r--r--fs/smb/common/compress/lz77.h46
-rw-r--r--fs/smb/common/fscc.h604
-rw-r--r--fs/smb/common/md4.h27
-rw-r--r--fs/smb/common/smb1pdu.h56
-rw-r--r--fs/smb/common/smb2pdu.h1836
-rw-r--r--fs/smb/common/smb2status.h1790
-rw-r--r--fs/smb/common/smbacl.h122
-rw-r--r--fs/smb/common/smbfsctl.h175
-rw-r--r--fs/smb/common/smbglob.h70
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 */
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-26 07:47:36 +0000