3 May
2022
3 May
'22
3:30 p.m.
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=060427353554079bdae3d…
commit 060427353554079bdae3d94cb8e53924d3c3cb16
Author: Vincent Franchomme <franchomme.vincent(a)gmail.com>
AuthorDate: Thu Apr 28 21:33:48 2022 +0200
Commit: Hermès BÉLUSCA - MAÏTO <hermes.belusca-maito(a)reactos.org>
CommitDate: Tue May 3 17:30:11 2022 +0200
[BTRFS][UBTRFS][SHELLBTRFS] Upgrade to 1.7.4 (#4417)
v1.7.4 (2020-08-23):
- Fixed issue when running compressed EXEs
- Changed build system to cmake
- Upgraded zstd to version 1.4.5
- Added support for FSCTL_GET_RETRIEVAL_POINTERS
- Miscellaneous bug fixes
---
dll/shellext/shellbtrfs/CMakeLists.txt | 9 +-
dll/shellext/shellbtrfs/balance.cpp | 14 +-
dll/shellext/shellbtrfs/contextmenu.cpp | 12 +-
dll/shellext/shellbtrfs/main.cpp | 4 +-
dll/shellext/shellbtrfs/recv.cpp | 170 +-
dll/shellext/shellbtrfs/scrub.cpp | 14 +-
dll/shellext/shellbtrfs/send.cpp | 22 +-
dll/shellext/shellbtrfs/shellbtrfs.rc | 8 +-
dll/shellext/shellbtrfs/volpropsheet.cpp | 21 +-
dll/win32/ubtrfs/ubtrfs.rc | 8 +-
drivers/filesystems/btrfs/CMakeLists.txt | 47 +-
drivers/filesystems/btrfs/boot.c | 4 +
drivers/filesystems/btrfs/btrfs.c | 147 +-
drivers/filesystems/btrfs/btrfs.rc | 8 +-
drivers/filesystems/btrfs/btrfs_drv.h | 87 +-
drivers/filesystems/btrfs/btrfsioctl.h | 8 +
drivers/filesystems/btrfs/compress.c | 17 +-
drivers/filesystems/btrfs/crc32c-amd64.S | 113 -
.../filesystems/btrfs/{crc32c-x86.S => crc32c.S} | 100 +-
drivers/filesystems/btrfs/crc32c.h | 8 +
drivers/filesystems/btrfs/create.c | 8 +-
drivers/filesystems/btrfs/dirctrl.c | 2 +-
drivers/filesystems/btrfs/fastio.c | 16 +
drivers/filesystems/btrfs/fileinfo.c | 8 +-
drivers/filesystems/btrfs/flushthread.c | 5 +-
drivers/filesystems/btrfs/fsctl.c | 369 +-
drivers/filesystems/btrfs/pnp.c | 2 +
drivers/filesystems/btrfs/read.c | 75 +-
drivers/filesystems/btrfs/reparse.c | 19 +-
drivers/filesystems/btrfs/scrub.c | 19 +-
drivers/filesystems/btrfs/security.c | 4 +-
drivers/filesystems/btrfs/volume.c | 94 +-
drivers/filesystems/btrfs/write.c | 6 +-
drivers/filesystems/btrfs/xor.S | 342 ++
drivers/filesystems/btrfs/zstd/bitstream.h | 81 +-
drivers/filesystems/btrfs/zstd/compiler.h | 78 +-
drivers/filesystems/btrfs/zstd/cpu.h | 4 +-
drivers/filesystems/btrfs/zstd/debug.h | 75 +-
drivers/filesystems/btrfs/zstd/entropy_common.c | 46 +-
drivers/filesystems/btrfs/zstd/error_private.c | 9 +-
drivers/filesystems/btrfs/zstd/error_private.h | 8 +-
drivers/filesystems/btrfs/zstd/fse.h | 50 +-
drivers/filesystems/btrfs/zstd/fse_compress.c | 90 +-
drivers/filesystems/btrfs/zstd/fse_decompress.c | 48 +-
drivers/filesystems/btrfs/zstd/hist.c | 88 +-
drivers/filesystems/btrfs/zstd/hist.h | 63 +-
drivers/filesystems/btrfs/zstd/huf.h | 78 +-
drivers/filesystems/btrfs/zstd/huf_compress.c | 271 +-
drivers/filesystems/btrfs/zstd/huf_decompress.c | 414 ++-
drivers/filesystems/btrfs/zstd/mem.h | 77 +-
drivers/filesystems/btrfs/zstd/zstd.h | 2168 +++++++-----
drivers/filesystems/btrfs/zstd/zstd_common.c | 6 +-
drivers/filesystems/btrfs/zstd/zstd_compress.c | 3690 +++++++++++---------
.../btrfs/zstd/zstd_compress_internal.h | 495 ++-
.../btrfs/zstd/zstd_compress_literals.c | 158 +
.../btrfs/zstd/zstd_compress_literals.h | 29 +
.../btrfs/zstd/zstd_compress_sequences.c | 419 +++
.../btrfs/zstd/zstd_compress_sequences.h | 54 +
.../btrfs/zstd/zstd_compress_superblock.c | 845 +++++
.../btrfs/zstd/zstd_compress_superblock.h | 32 +
drivers/filesystems/btrfs/zstd/zstd_cwksp.h | 525 +++
drivers/filesystems/btrfs/zstd/zstd_ddict.c | 244 ++
drivers/filesystems/btrfs/zstd/zstd_ddict.h | 44 +
drivers/filesystems/btrfs/zstd/zstd_decompress.c | 2513 ++++---------
.../filesystems/btrfs/zstd/zstd_decompress_block.c | 1432 ++++++++
.../filesystems/btrfs/zstd/zstd_decompress_block.h | 59 +
.../btrfs/zstd/zstd_decompress_internal.h | 189 +
drivers/filesystems/btrfs/zstd/zstd_double_fast.c | 116 +-
drivers/filesystems/btrfs/zstd/zstd_double_fast.h | 2 +-
drivers/filesystems/btrfs/zstd/zstd_errors.h | 4 +-
drivers/filesystems/btrfs/zstd/zstd_fast.c | 443 ++-
drivers/filesystems/btrfs/zstd/zstd_fast.h | 2 +-
drivers/filesystems/btrfs/zstd/zstd_internal.h | 236 +-
drivers/filesystems/btrfs/zstd/zstd_lazy.c | 159 +-
drivers/filesystems/btrfs/zstd/zstd_lazy.h | 4 +-
drivers/filesystems/btrfs/zstd/zstd_ldm.c | 127 +-
drivers/filesystems/btrfs/zstd/zstd_ldm.h | 15 +-
drivers/filesystems/btrfs/zstd/zstd_opt.c | 402 ++-
drivers/filesystems/btrfs/zstd/zstd_opt.h | 10 +-
sdk/lib/fslib/btrfslib/CMakeLists.txt | 9 +-
80 files changed, 11286 insertions(+), 6415 deletions(-)
diff --git a/dll/shellext/shellbtrfs/CMakeLists.txt
b/dll/shellext/shellbtrfs/CMakeLists.txt
index 6cbd3b04271..8fe8aa4d7ae 100644
--- a/dll/shellext/shellbtrfs/CMakeLists.txt
+++ b/dll/shellext/shellbtrfs/CMakeLists.txt
@@ -22,10 +22,17 @@ list(APPEND SOURCE
volpropsheet.cpp)
list(APPEND PCH_SKIP_SOURCE
- guid.c)
+ guid.c
+ ${REACTOS_SOURCE_DIR}/drivers/filesystems/btrfs/crc32c.c)
+
+if((ARCH STREQUAL "i386") OR (ARCH STREQUAL "amd64"))
+ list(APPEND ASM_SOURCE ${REACTOS_SOURCE_DIR}/drivers/filesystems/btrfs/crc32c.S)
+ add_asm_files(btrfs_asm ${ASM_SOURCE})
+endif()
add_library(shellbtrfs MODULE
${SOURCE}
+ ${btrfs_asm}
${PCH_SKIP_SOURCE}
shellbtrfs.rc
${CMAKE_CURRENT_BINARY_DIR}/shellbtrfs.def)
diff --git a/dll/shellext/shellbtrfs/balance.cpp b/dll/shellext/shellbtrfs/balance.cpp
index b73978167fc..baa2d07ce38 100644
--- a/dll/shellext/shellbtrfs/balance.cpp
+++ b/dll/shellext/shellbtrfs/balance.cpp
@@ -1061,11 +1061,7 @@ static void unserialize(void* data, ULONG len, WCHAR* s) {
}
}
-#ifdef __REACTOS__
-extern "C" {
-#endif
-
-void CALLBACK StartBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{
+extern "C" void CALLBACK StartBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
try {
WCHAR *s, *vol, *block;
win_handle h, token;
@@ -1126,7 +1122,7 @@ void CALLBACK StartBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int
}
}
-void CALLBACK PauseBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{
+extern "C" void CALLBACK PauseBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
try {
win_handle h, token;
TOKEN_PRIVILEGES tp;
@@ -1173,7 +1169,7 @@ void CALLBACK PauseBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int
}
}
-void CALLBACK StopBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{
+extern "C" void CALLBACK StopBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
try {
win_handle h, token;
TOKEN_PRIVILEGES tp;
@@ -1217,7 +1213,3 @@ void CALLBACK StopBalanceW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int n
error_message(hwnd, e.what());
}
}
-
-#ifdef __REACTOS__
-} /* extern "C" */
-#endif
diff --git a/dll/shellext/shellbtrfs/contextmenu.cpp
b/dll/shellext/shellbtrfs/contextmenu.cpp
index 3fbca1cb7c2..004ac00057c 100644
--- a/dll/shellext/shellbtrfs/contextmenu.cpp
+++ b/dll/shellext/shellbtrfs/contextmenu.cpp
@@ -1643,11 +1643,7 @@ static void reflink_copy2(const wstring& srcfn, const
wstring& destdir, const ws
}
}
-#ifdef __REACTOS__
-extern "C" {
-#endif
-
-void CALLBACK ReflinkCopyW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{
+extern "C" void CALLBACK ReflinkCopyW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
vector<wstring> args;
command_line_to_args(lpszCmdLine, args);
@@ -1719,8 +1715,4 @@ void CALLBACK ReflinkCopyW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int n
}
}
}
-}
-
-#ifdef __REACTOS__
-} /* extern "C" */
-#endif
+}
\ No newline at end of file
diff --git a/dll/shellext/shellbtrfs/main.cpp b/dll/shellext/shellbtrfs/main.cpp
index 9ba209ab664..55b4121a090 100644
--- a/dll/shellext/shellbtrfs/main.cpp
+++ b/dll/shellext/shellbtrfs/main.cpp
@@ -309,7 +309,7 @@ static void write_reg_key(HKEY root, const wstring& keyname, const
WCHAR* val, c
static void register_clsid(const GUID clsid, const WCHAR* description) {
WCHAR* clsidstring;
- wstring inproc, progid, clsidkeyname;
+ wstring inproc, clsidkeyname;
WCHAR dllpath[MAX_PATH];
StringFromCLSID(clsid, &clsidstring);
@@ -317,11 +317,9 @@ static void register_clsid(const GUID clsid, const WCHAR*
description) {
try {
#ifndef __REACTOS__
inproc = L"CLSID\\"s + clsidstring + L"\\InprocServer32"s;
- progid = L"CLSID\\"s + clsidstring + L"\\ProgId"s;
clsidkeyname = L"CLSID\\"s + clsidstring;
#else
inproc = wstring(L"CLSID\\") + clsidstring +
wstring(L"\\InprocServer32");
- progid = wstring(L"CLSID\\") + clsidstring +
wstring(L"\\ProgId");
clsidkeyname = wstring(L"CLSID\\") + clsidstring;
#endif
diff --git a/dll/shellext/shellbtrfs/recv.cpp b/dll/shellext/shellbtrfs/recv.cpp
index c18b5c92627..0c1ff3ef589 100644
--- a/dll/shellext/shellbtrfs/recv.cpp
+++ b/dll/shellext/shellbtrfs/recv.cpp
@@ -23,16 +23,15 @@
#include <iostream>
#include "recv.h"
#include "resource.h"
+#include "crc32c.h"
+
-#ifndef __REACTOS__
#ifndef _MSC_VER
#include <cpuid.h>
#else
#include <intrin.h>
#endif
-#include <smmintrin.h>
-#endif
const string EA_NTACL = "security.NTACL";
const string EA_DOSATTRIB = "user.DOSATTRIB";
@@ -40,118 +39,6 @@ const string EA_REPARSE = "user.reparse";
const string EA_EA = "user.EA";
const string XATTR_USER = "user.";
-#ifndef __REACTOS__
-bool have_sse42 = false;
-#endif
-
-static const uint32_t crctable[] = {
- 0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8,
0xd4ca64eb,
- 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27,
0x5e133c24,
- 0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087,
0xc494a384,
- 0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54, 0x5d1d08bf, 0xaf768bbc, 0xbc267848,
0x4e4dfb4b,
- 0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a, 0xe72719c1, 0x154c9ac2, 0x061c6936,
0xf477ea35,
- 0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5, 0x6dfe410e, 0x9f95c20d, 0x8cc531f9,
0x7eaeb2fa,
- 0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad, 0x1642ae59,
0xe4292d5a,
- 0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a, 0x7da08661, 0x8fcb0562, 0x9c9bf696,
0x6ef07595,
- 0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0, 0x67dafa54,
0x95b17957,
- 0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c, 0xfe53516f, 0xed03a29b,
0x1f682198,
- 0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927, 0x96bf4dcc, 0x64d4cecf, 0x77843d3b,
0x85efbe38,
- 0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4,
0x0f36e6f7,
- 0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096, 0xa65c047d, 0x5437877e, 0x4767748a,
0xb50cf789,
- 0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859, 0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45,
0x3fd5af46,
- 0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9, 0xb602c312, 0x44694011, 0x5739b3e5,
0xa55230e6,
- 0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de, 0xdde0eb2a,
0x2f8b6829,
- 0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c, 0x456cac67, 0xb7072f64, 0xa457dc90,
0x563c5f93,
- 0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043, 0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f,
0xdce5075c,
- 0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x55326b08, 0xa759e80b, 0xb4091bff,
0x466298fc,
- 0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c, 0xdfeb33c7, 0x2d80b0c4, 0x3ed04330,
0xccbbc033,
- 0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e,
0x7681d14d,
- 0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 0xef087a76, 0x1d63f975, 0x0e330a81,
0xfc588982,
- 0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d, 0x758fe5d6, 0x87e466d5, 0x94b49521,
0x66df1622,
- 0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2, 0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee,
0xec064eed,
- 0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530, 0x0417b1db, 0xf67c32d8, 0xe52cc12c,
0x1747422f,
- 0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff, 0x8ecee914, 0x7ca56a17, 0x6ff599e3,
0x9d9e1ae0,
- 0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f, 0x144976b4, 0xe622f5b7, 0xf5720643,
0x07198540,
- 0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90, 0x9e902e7b, 0x6cfbad78, 0x7fab5e8c,
0x8dc0dd8f,
- 0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee, 0x24aa3f05, 0xd6c1bc06, 0xc5914ff2,
0x37faccf1,
- 0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321, 0xae7367ca, 0x5c18e4c9, 0x4f48173d,
0xbd23943e,
- 0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81, 0x34f4f86a, 0xc69f7b69, 0xd5cf889d,
0x27a40b9e,
- 0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e, 0xbe2da0a5, 0x4c4623a6, 0x5f16d052,
0xad7d5351,
-};
-
-// HW code taken from https://github.com/rurban/smhasher/blob/master/crc32_hw.c
-#define ALIGN_SIZE 0x08UL
-#define ALIGN_MASK (ALIGN_SIZE - 1)
-#define CALC_CRC(op, crc, type, buf, len) \
-do { \
- for (; (len) >= sizeof (type); (len) -= (ULONG)sizeof(type), buf += sizeof (type))
{ \
- (crc) = (uint32_t)op((crc), *(type *) (buf)); \
- } \
-} while(0)
-
-#ifndef __REACTOS__
-static uint32_t crc32c_hw(const void *input, ULONG len, uint32_t crc) {
- const char* buf = (const char*)input;
-
- // Annoyingly, the CRC32 intrinsics don't work properly in modern versions of
MSVC -
- // it compiles _mm_crc32_u8 as if it was _mm_crc32_u32. And because we're
apparently
- // not allowed to use inline asm on amd64, there's no easy way to fix this!
-
- for (; (len > 0) && ((size_t)buf & ALIGN_MASK); len--, buf++) {
-#ifdef _MSC_VER
- crc = crctable[(crc ^ *buf) & 0xff] ^ (crc >> 8);
-#else
- crc = _mm_crc32_u8(crc, *buf);
-#endif
- }
-
-#ifdef _AMD64_
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4244) // _mm_crc32_u64 wants to return uint64_t(!)
-#pragma warning(disable:4242)
-#endif
- CALC_CRC(_mm_crc32_u64, crc, uint64_t, buf, len);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-#endif
- CALC_CRC(_mm_crc32_u32, crc, uint32_t, buf, len);
-
-#ifdef _MSC_VER
- for (; len > 0; len--, buf++) {
- crc = crctable[(crc ^ *buf) & 0xff] ^ (crc >> 8);
- }
-#else
- CALC_CRC(_mm_crc32_u16, crc, uint16_t, buf, len);
- CALC_CRC(_mm_crc32_u8, crc, uint8_t, buf, len);
-#endif
-
- return crc;
-}
-#endif
-
-static uint32_t calc_crc32c(uint32_t seed, uint8_t* msg, ULONG msglen) {
-#ifndef __REACTOS__
- if (have_sse42)
- return crc32c_hw(msg, msglen, seed);
- else {
-#endif
- uint32_t rem;
- ULONG i;
-
- rem = seed;
-
- for (i = 0; i < msglen; i++) {
- rem = crctable[(rem ^ msg[i]) & 0xff] ^ (rem >> 8);
- }
-
- return rem;
-#ifndef __REACTOS__
- }
-#endif
-}
-
bool BtrfsRecv::find_tlv(uint8_t* data, ULONG datalen, uint16_t type, void** value,
ULONG* len) {
size_t off = 0;
@@ -1473,6 +1360,33 @@ void BtrfsRecv::do_recv(const win_handle& f, uint64_t* pos,
uint64_t size, const
}
}
+#if defined(_X86_) || defined(_AMD64_)
+static void check_cpu() {
+ bool have_sse42 = false;
+
+#ifndef _MSC_VER
+ {
+ uint32_t eax, ebx, ecx, edx;
+
+ __cpuid(1, eax, ebx, ecx, edx);
+
+ if (__get_cpuid(1, &eax, &ebx, &ecx, &edx))
+ have_sse42 = ecx & bit_SSE4_2;
+ }
+#else
+ {
+ int cpu_info[4];
+
+ __cpuid(cpu_info, 1);
+ have_sse42 = (unsigned int)cpu_info[2] & (1 << 20);
+ }
+#endif
+
+ if (have_sse42)
+ calc_crc32c = calc_crc32c_hw;
+}
+#endif
+
DWORD BtrfsRecv::recv_thread() {
LARGE_INTEGER size;
uint64_t pos = 0;
@@ -1612,22 +1526,12 @@ static INT_PTR CALLBACK stub_RecvProgressDlgProc(HWND hwndDlg,
UINT uMsg, WPARAM
}
void BtrfsRecv::Open(HWND hwnd, const wstring& file, const wstring& path, bool
quiet) {
-#ifndef __REACTOS__
- uint32_t cpuInfo[4];
-#endif
-
streamfile = file;
dirpath = path;
subvolpath = L"";
-#ifndef __REACTOS__
-#ifndef _MSC_VER
- __get_cpuid(1, &cpuInfo[0], &cpuInfo[1], &cpuInfo[2], &cpuInfo[3]);
- have_sse42 = cpuInfo[2] & bit_SSE4_2;
-#else
- __cpuid((int*)cpuInfo, 1);
- have_sse42 = cpuInfo[2] & (1 << 20);
-#endif
+#if defined(_X86_) || defined(_AMD64_)
+ check_cpu();
#endif
if (quiet)
@@ -1638,11 +1542,7 @@ void BtrfsRecv::Open(HWND hwnd, const wstring& file, const
wstring& path, bool q
}
}
-#ifdef __REACTOS__
-extern "C" {
-#endif
-
-void CALLBACK RecvSubvolGUIW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int
nCmdShow) {
+extern "C" void CALLBACK RecvSubvolGUIW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
try {
OPENFILENAMEW ofn;
WCHAR file[MAX_PATH];
@@ -1714,7 +1614,7 @@ void CALLBACK RecvSubvolGUIW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int
}
}
-void CALLBACK RecvSubvolW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{
+extern "C" void CALLBACK RecvSubvolW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
try {
vector<wstring> args;
@@ -1774,7 +1674,3 @@ void CALLBACK RecvSubvolW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nC
cerr << "Error: " << e.what() << endl;
}
}
-
-#ifdef __REACTOS__
-} /* extern "C" */
-#endif
diff --git a/dll/shellext/shellbtrfs/scrub.cpp b/dll/shellext/shellbtrfs/scrub.cpp
index c0b39c0ad4b..f04091851d8 100644
--- a/dll/shellext/shellbtrfs/scrub.cpp
+++ b/dll/shellext/shellbtrfs/scrub.cpp
@@ -483,11 +483,7 @@ static INT_PTR CALLBACK stub_ScrubDlgProc(HWND hwndDlg, UINT uMsg,
WPARAM wParam
return false;
}
-#ifdef __REACTOS__
-extern "C" {
-#endif
-
-void CALLBACK ShowScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow) {
+extern "C" void CALLBACK ShowScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
try {
win_handle token;
TOKEN_PRIVILEGES tp;
@@ -516,7 +512,7 @@ void CALLBACK ShowScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCm
}
}
-void CALLBACK StartScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{
+extern "C" void CALLBACK StartScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
vector<wstring> args;
command_line_to_args(lpszCmdLine, args);
@@ -552,7 +548,7 @@ void CALLBACK StartScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nC
}
}
-void CALLBACK StopScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow) {
+extern "C" void CALLBACK StopScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
vector<wstring> args;
command_line_to_args(lpszCmdLine, args);
@@ -587,7 +583,3 @@ void CALLBACK StopScrubW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCm
}
}
}
-
-#ifdef __REACTOS__
-} /* extern "C" */
-#endif
diff --git a/dll/shellext/shellbtrfs/send.cpp b/dll/shellext/shellbtrfs/send.cpp
index f61e7510c3e..74ba33774e0 100644
--- a/dll/shellext/shellbtrfs/send.cpp
+++ b/dll/shellext/shellbtrfs/send.cpp
@@ -532,11 +532,7 @@ void BtrfsSend::Open(HWND hwnd, LPWSTR path) {
throw last_error(GetLastError());
}
-#ifdef __REACTOS__
-extern "C" {
-#endif
-
-void CALLBACK SendSubvolGUIW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int
nCmdShow) {
+extern "C" void CALLBACK SendSubvolGUIW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
try {
win_handle token;
TOKEN_PRIVILEGES tp;
@@ -565,10 +561,6 @@ void CALLBACK SendSubvolGUIW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int
}
}
-#ifdef __REACTOS__
-} /* extern "C" */
-#endif
-
static void send_subvol(const wstring& subvol, const wstring& file, const
wstring& parent, const vector<wstring>& clones) {
char* buf;
win_handle dirh, stream;
@@ -682,11 +674,7 @@ static void send_subvol(const wstring& subvol, const wstring&
file, const wstrin
free(buf);
}
-#ifdef __REACTOS__
-extern "C" {
-#endif
-
-void CALLBACK SendSubvolW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{
+extern "C" void CALLBACK SendSubvolW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nCmdShow) {
vector<wstring> args;
wstring subvol = L"", parent = L"", file = L"";
vector<wstring> clones;
@@ -741,8 +729,4 @@ void CALLBACK SendSubvolW(HWND hwnd, HINSTANCE hinst, LPWSTR
lpszCmdLine, int nC
}
}
}
-}
-
-#ifdef __REACTOS__
-} /* extern "C" */
-#endif
+}
\ No newline at end of file
diff --git a/dll/shellext/shellbtrfs/shellbtrfs.rc
b/dll/shellext/shellbtrfs/shellbtrfs.rc
index efc8aa1e581..4b6bbe2e883 100644
--- a/dll/shellext/shellbtrfs/shellbtrfs.rc
+++ b/dll/shellext/shellbtrfs/shellbtrfs.rc
@@ -61,8 +61,8 @@ IDI_ICON1 ICON "subvol.ico"
//
VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,7,3,0
- PRODUCTVERSION 1,7,3,0
+ FILEVERSION 1,7,4,0
+ PRODUCTVERSION 1,7,4,0
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@@ -78,12 +78,12 @@ BEGIN
BLOCK "080904b0"
BEGIN
VALUE "FileDescription", "WinBtrfs shell extension"
- VALUE "FileVersion", "1.7.3"
+ VALUE "FileVersion", "1.7.4"
VALUE "InternalName", "btrfs"
VALUE "LegalCopyright", "Copyright (c) Mark Harmstone
2016-20"
VALUE "OriginalFilename", "shellbtrfs.dll"
VALUE "ProductName", "WinBtrfs"
- VALUE "ProductVersion", "1.7.3"
+ VALUE "ProductVersion", "1.7.4"
END
END
BLOCK "VarFileInfo"
diff --git a/dll/shellext/shellbtrfs/volpropsheet.cpp
b/dll/shellext/shellbtrfs/volpropsheet.cpp
index 97de35ae3e1..ddc7dc24af0 100644
--- a/dll/shellext/shellbtrfs/volpropsheet.cpp
+++ b/dll/shellext/shellbtrfs/volpropsheet.cpp
@@ -1590,9 +1590,7 @@ INT_PTR BtrfsChangeDriveLetter::DlgProc(HWND hwndDlg, UINT uMsg,
WPARAM wParam,
return false;
}
-#ifdef __REACTOS__
-INT_PTR CALLBACK VolPropSheetDlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM
lParam)
-{
+static INT_PTR __stdcall dlg_proc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
BtrfsChangeDriveLetter* bcdl;
if (uMsg == WM_INITDIALOG) {
@@ -1603,24 +1601,9 @@ INT_PTR CALLBACK VolPropSheetDlgproc(HWND hwndDlg, UINT uMsg,
WPARAM wParam, LPA
return bcdl->DlgProc(hwndDlg, uMsg, wParam, lParam);
}
-#endif
void BtrfsChangeDriveLetter::show() {
-#ifndef __REACTOS__
- DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_DRIVE_LETTER), hwnd, [](HWND hwndDlg,
UINT uMsg, WPARAM wParam, LPARAM lParam) {
- BtrfsChangeDriveLetter* bcdl;
-
- if (uMsg == WM_INITDIALOG) {
- SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
- bcdl = (BtrfsChangeDriveLetter*)lParam;
- } else
- bcdl = (BtrfsChangeDriveLetter*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
-
- return bcdl->DlgProc(hwndDlg, uMsg, wParam, lParam);
- }, (LPARAM)this);
-#else
- DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_DRIVE_LETTER), hwnd,
VolPropSheetDlgproc, (LPARAM)this);
-#endif
+ DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_DRIVE_LETTER), hwnd, dlg_proc,
(LPARAM)this);
}
#ifdef __cplusplus
diff --git a/dll/win32/ubtrfs/ubtrfs.rc b/dll/win32/ubtrfs/ubtrfs.rc
index add9d0a5752..903edb0c9a5 100644
--- a/dll/win32/ubtrfs/ubtrfs.rc
+++ b/dll/win32/ubtrfs/ubtrfs.rc
@@ -51,8 +51,8 @@ END
//
VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,7,3,0
- PRODUCTVERSION 1,7,3,0
+ FILEVERSION 1,7,4,0
+ PRODUCTVERSION 1,7,4,0
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@@ -68,12 +68,12 @@ BEGIN
BLOCK "080904b0"
BEGIN
VALUE "FileDescription", "Btrfs utility DLL"
- VALUE "FileVersion", "1.7.3"
+ VALUE "FileVersion", "1.7.4"
VALUE "InternalName", "ubtrfs"
VALUE "LegalCopyright", "Copyright (c) Mark Harmstone
2016-20"
VALUE "OriginalFilename", "ubtrfs.dll"
VALUE "ProductName", "WinBtrfs"
- VALUE "ProductVersion", "1.7.3"
+ VALUE "ProductVersion", "1.7.4"
END
END
BLOCK "VarFileInfo"
diff --git a/drivers/filesystems/btrfs/CMakeLists.txt
b/drivers/filesystems/btrfs/CMakeLists.txt
index b86b210542e..bbe29b2b838 100644
--- a/drivers/filesystems/btrfs/CMakeLists.txt
+++ b/drivers/filesystems/btrfs/CMakeLists.txt
@@ -3,6 +3,28 @@ include_directories(${REACTOS_SOURCE_DIR}/sdk/include/reactos/drivers
${REACTOS_SOURCE_DIR}/sdk/include/reactos/libs/zlib
inc)
+set(ZSTD_SRC_FILES
+ zstd/entropy_common.c
+ zstd/error_private.c
+ zstd/fse_compress.c
+ zstd/fse_decompress.c
+ zstd/hist.c
+ zstd/huf_compress.c
+ zstd/huf_decompress.c
+ zstd/zstd_common.c
+ zstd/zstd_compress.c
+ zstd/zstd_compress_literals.c
+ zstd/zstd_compress_sequences.c
+ zstd/zstd_compress_superblock.c
+ zstd/zstd_ddict.c
+ zstd/zstd_decompress.c
+ zstd/zstd_decompress_block.c
+ zstd/zstd_double_fast.c
+ zstd/zstd_fast.c
+ zstd/zstd_lazy.c
+ zstd/zstd_ldm.c
+ zstd/zstd_opt.c)
+
list(APPEND SOURCE
balance.c
blake2b-ref.c
@@ -38,31 +60,14 @@ list(APPEND SOURCE
worker-thread.c
write.c
xxhash.c
- zstd/entropy_common.c
- zstd/fse_compress.c
- zstd/hist.c
- zstd/huf_decompress.c
- zstd/zstd_common.c
- zstd/zstd_decompress.c
- zstd/zstd_fast.c
- zstd/zstd_ldm.c
- zstd/error_private.c
- zstd/fse_decompress.c
- zstd/huf_compress.c
- zstd/zstd_compress.c
- zstd/zstd_double_fast.c
- zstd/zstd_lazy.c
- zstd/zstd_opt.c
+ ${ZSTD_SRC_FILES}
btrfs_drv.h)
-if(ARCH STREQUAL "i386")
- list(APPEND ASM_SOURCE crc32c-x86.S)
-elseif(ARCH STREQUAL "amd64")
- list(APPEND ASM_SOURCE crc32c-amd64.S)
+if((ARCH STREQUAL "i386") OR (ARCH STREQUAL "amd64"))
+ list(APPEND ASM_SOURCE crc32c.S xor.S)
+ add_asm_files(btrfs_asm ${ASM_SOURCE})
endif()
-add_asm_files(btrfs_asm ${ASM_SOURCE})
-
add_library(btrfs MODULE ${SOURCE} ${btrfs_asm} btrfs.rc)
if(MSVC)
diff --git a/drivers/filesystems/btrfs/boot.c b/drivers/filesystems/btrfs/boot.c
index 810717e9da1..43486cfad33 100644
--- a/drivers/filesystems/btrfs/boot.c
+++ b/drivers/filesystems/btrfs/boot.c
@@ -506,6 +506,10 @@ void __stdcall check_system_root(PDRIVER_OBJECT DriverObject, PVOID
Context, ULO
TRACE("(%p, %p, %lu)\n", DriverObject, Context, Count);
+ UNUSED(DriverObject);
+ UNUSED(Context);
+ UNUSED(Count);
+
// wait for any PNP notifications in progress to finish
ExAcquireResourceExclusiveLite(&boot_lock, TRUE);
ExReleaseResourceLite(&boot_lock);
diff --git a/drivers/filesystems/btrfs/btrfs.c b/drivers/filesystems/btrfs/btrfs.c
index 227e5d438c6..4824af9c87b 100644
--- a/drivers/filesystems/btrfs/btrfs.c
+++ b/drivers/filesystems/btrfs/btrfs.c
@@ -63,9 +63,6 @@ DEFINE_GUID(BtrfsBusInterface, 0x4d414874, 0x6865, 0x6761, 0x6d, 0x65,
0x83, 0x6
PDRIVER_OBJECT drvobj;
PDEVICE_OBJECT master_devobj, busobj;
-#ifndef __REACTOS__
-bool have_sse2 = false;
-#endif
uint64_t num_reads = 0;
LIST_ENTRY uid_map_list, gid_map_list;
LIST_ENTRY VcbList;
@@ -123,6 +120,9 @@ static void init_serial(bool first_time);
#endif
static NTSTATUS close_file(_In_ PFILE_OBJECT FileObject, _In_ PIRP Irp);
+static void __stdcall do_xor_basic(uint8_t* buf1, uint8_t* buf2, uint32_t len);
+
+xor_func do_xor = do_xor_basic;
typedef struct {
KEVENT Event;
@@ -282,6 +282,49 @@ bool is_top_level(_In_ PIRP Irp) {
return false;
}
+static void __stdcall do_xor_basic(uint8_t* buf1, uint8_t* buf2, uint32_t len) {
+ uint32_t j;
+
+#if defined(_ARM_) || defined(_ARM64_)
+ uint64x2_t x1, x2;
+
+ if (((uintptr_t)buf1 & 0xf) == 0 && ((uintptr_t)buf2 & 0xf) == 0) {
+ while (len >= 16) {
+ x1 = vld1q_u64((const uint64_t*)buf1);
+ x2 = vld1q_u64((const uint64_t*)buf2);
+ x1 = veorq_u64(x1, x2);
+ vst1q_u64((uint64_t*)buf1, x1);
+
+ buf1 += 16;
+ buf2 += 16;
+ len -= 16;
+ }
+ }
+#endif
+
+#if defined(_AMD64_) || defined(_ARM64_)
+ while (len > 8) {
+ *(uint64_t*)buf1 ^= *(uint64_t*)buf2;
+ buf1 += 8;
+ buf2 += 8;
+ len -= 8;
+ }
+#endif
+
+ while (len > 4) {
+ *(uint32_t*)buf1 ^= *(uint32_t*)buf2;
+ buf1 += 4;
+ buf2 += 4;
+ len -= 4;
+ }
+
+ for (j = 0; j < len; j++) {
+ *buf1 ^= *buf2;
+ buf1++;
+ buf2++;
+ }
+}
+
_Function_class_(DRIVER_UNLOAD)
static void __stdcall DriverUnload(_In_ PDRIVER_OBJECT DriverObject) {
UNICODE_STRING dosdevice_nameW;
@@ -520,7 +563,7 @@ static NTSTATUS __stdcall drv_flush_buffers(_In_ PDEVICE_OBJECT
DeviceObject, _I
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_flush_buffers(DeviceObject, Irp);
+ Status = STATUS_SUCCESS;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_SUCCESS;
@@ -726,14 +769,8 @@ NTSTATUS utf8_to_utf16(WCHAR* dest, ULONG dest_max, ULONG* dest_len,
char* src,
uint8_t* in = (uint8_t*)src;
uint16_t* out = (uint16_t*)dest;
ULONG needed = 0, left = dest_max / sizeof(uint16_t);
-#ifdef __REACTOS__
- ULONG i;
-
- for (i = 0; i < src_len; ++i) {
-#else
for (ULONG i = 0; i < src_len; i++) {
-#endif
uint32_t cp;
if (!(in[i] & 0x80))
@@ -816,14 +853,8 @@ NTSTATUS utf16_to_utf8(char* dest, ULONG dest_max, ULONG* dest_len,
WCHAR* src,
uint8_t* out = (uint8_t*)dest;
ULONG in_len = src_len / sizeof(uint16_t);
ULONG needed = 0, left = dest_max;
-#ifdef __REACTOS__
- ULONG i = 0;
-
- for (i = 0; i < in_len; i++) {
-#else
for (ULONG i = 0; i < in_len; i++) {
-#endif
uint32_t cp = *in;
in++;
@@ -934,7 +965,7 @@ static NTSTATUS __stdcall drv_query_volume_information(_In_
PDEVICE_OBJECT Devic
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_query_volume_information(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
@@ -1091,9 +1122,9 @@ static NTSTATUS __stdcall drv_query_volume_information(_In_
PDEVICE_OBJECT Devic
orig_label_len = label_len;
- if (IrpSp->Parameters.QueryVolume.Length <
sizeof(FILE_FS_VOLUME_INFORMATION) - sizeof(WCHAR) + label_len) {
- if (IrpSp->Parameters.QueryVolume.Length >
sizeof(FILE_FS_VOLUME_INFORMATION) - sizeof(WCHAR))
- label_len = IrpSp->Parameters.QueryVolume.Length -
sizeof(FILE_FS_VOLUME_INFORMATION) + sizeof(WCHAR);
+ if (IrpSp->Parameters.QueryVolume.Length <
offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel) + label_len) {
+ if (IrpSp->Parameters.QueryVolume.Length >
offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel))
+ label_len = IrpSp->Parameters.QueryVolume.Length -
offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel);
else
label_len = 0;
@@ -1102,12 +1133,12 @@ static NTSTATUS __stdcall drv_query_volume_information(_In_
PDEVICE_OBJECT Devic
TRACE("label_len = %lu\n", label_len);
- ffvi.VolumeCreationTime.QuadPart = 0; // FIXME
+ RtlZeroMemory(&ffvi, offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel));
+
ffvi.VolumeSerialNumber = Vcb->superblock.uuid.uuid[12] << 24 |
Vcb->superblock.uuid.uuid[13] << 16 | Vcb->superblock.uuid.uuid[14] << 8
| Vcb->superblock.uuid.uuid[15];
ffvi.VolumeLabelLength = orig_label_len;
- ffvi.SupportsObjects = false;
- RtlCopyMemory(data, &ffvi, min(sizeof(FILE_FS_VOLUME_INFORMATION) -
sizeof(WCHAR), IrpSp->Parameters.QueryVolume.Length));
+ RtlCopyMemory(data, &ffvi, min(offsetof(FILE_FS_VOLUME_INFORMATION,
VolumeLabel), IrpSp->Parameters.QueryVolume.Length));
if (label_len > 0) {
ULONG bytecount;
@@ -1124,7 +1155,7 @@ static NTSTATUS __stdcall drv_query_volume_information(_In_
PDEVICE_OBJECT Devic
ExReleaseResourceLite(&Vcb->tree_lock);
- BytesCopied = sizeof(FILE_FS_VOLUME_INFORMATION) - sizeof(WCHAR) +
label_len;
+ BytesCopied = offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel) + label_len;
Status = overflow ? STATUS_BUFFER_OVERFLOW : STATUS_SUCCESS;
break;
}
@@ -1384,7 +1415,7 @@ static NTSTATUS __stdcall drv_set_volume_information(_In_
PDEVICE_OBJECT DeviceO
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_set_volume_information(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
@@ -1779,12 +1810,8 @@ void reap_fcbs(device_extension* Vcb) {
}
void free_fileref(_Inout_ file_ref* fr) {
- LONG rc;
-
- rc = InterlockedDecrement(&fr->refcount);
-#ifdef __REACTOS__
- (void)rc;
-#endif
+#if defined(_DEBUG) || defined(DEBUG_FCB_REFCOUNTS)
+ LONG rc = InterlockedDecrement(&fr->refcount);
#ifdef DEBUG_FCB_REFCOUNTS
ERR("fileref %p: refcount now %i\n", fr, rc);
@@ -1796,6 +1823,9 @@ void free_fileref(_Inout_ file_ref* fr) {
int3;
}
#endif
+#else
+ InterlockedDecrement(&fr->refcount);
+#endif
}
void reap_fileref(device_extension* Vcb, file_ref* fr) {
@@ -2383,7 +2413,8 @@ static NTSTATUS __stdcall drv_cleanup(_In_ PDEVICE_OBJECT
DeviceObject, _In_ PIR
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_cleanup(DeviceObject, Irp);
+ Irp->IoStatus.Information = 0;
+ Status = STATUS_SUCCESS;
goto exit;
} else if (DeviceObject == master_devobj) {
TRACE("closing file system\n");
@@ -5215,7 +5246,7 @@ static NTSTATUS __stdcall drv_file_system_control(_In_
PDEVICE_OBJECT DeviceObje
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_file_system_control(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || (Vcb->type != VCB_TYPE_FS && Vcb->type !=
VCB_TYPE_CONTROL)) {
Status = STATUS_INVALID_PARAMETER;
@@ -5295,7 +5326,7 @@ static NTSTATUS __stdcall drv_lock_control(_In_ PDEVICE_OBJECT
DeviceObject, _In
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_lock_control(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
@@ -5460,7 +5491,7 @@ static NTSTATUS __stdcall drv_shutdown(_In_ PDEVICE_OBJECT
DeviceObject, _In_ PI
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_shutdown(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
}
@@ -5888,15 +5919,28 @@ static void init_serial(bool first_time) {
#if !defined(__REACTOS__) && (defined(_X86_) || defined(_AMD64_))
static void check_cpu() {
- bool have_sse42;
+ bool have_sse2 = false, have_sse42 = false, have_avx2 = false;
#ifndef _MSC_VER
{
- uint32_t eax, ebx, ecx, edx;
+ uint32_t eax, ebx, ecx, edx, xcr0;
__cpuid(1, eax, ebx, ecx, edx);
- have_sse42 = ecx & bit_SSE4_2;
- have_sse2 = edx & bit_SSE2;
+
+ if (__get_cpuid(1, &eax, &ebx, &ecx, &edx)) {
+ have_sse42 = ecx & bit_SSE4_2;
+ have_sse2 = edx & bit_SSE2;
+ }
+
+ if (__get_cpuid_count(7, 0, &eax, &ebx, &ecx, &edx))
+ have_avx2 = ebx & bit_AVX2;
+
+ if (have_avx2) { // check if supported by OS
+ __asm__("xgetbv" : "=a" (xcr0) : "c" (0) :
"edx" );
+
+ if ((xcr0 & 6) != 6)
+ have_avx2 = false;
+ }
}
#else
{
@@ -5905,6 +5949,16 @@ static void check_cpu() {
__cpuid(cpu_info, 1);
have_sse42 = cpu_info[2] & (1 << 20);
have_sse2 = cpu_info[3] & (1 << 26);
+
+ __cpuidex(cpu_info, 7, 0);
+ have_avx2 = cpu_info[1] & (1 << 5);
+
+ if (have_avx2) {
+ uint32_t xcr0 = (uint32_t)_xgetbv(0);
+
+ if ((xcr0 & 6) != 6)
+ have_avx2 = false;
+ }
}
#endif
@@ -5914,10 +5968,19 @@ static void check_cpu() {
} else
TRACE("SSE4.2 not supported\n");
- if (have_sse2)
+ if (have_sse2) {
TRACE("SSE2 is supported\n");
- else
+
+ if (!have_avx2)
+ do_xor = do_xor_sse2;
+ } else
TRACE("SSE2 is not supported\n");
+
+ if (have_avx2) {
+ TRACE("AVX2 is supported\n");
+ do_xor = do_xor_avx2;
+ } else
+ TRACE("AVX2 is not supported\n");
}
#endif
@@ -6047,6 +6110,8 @@ NTSTATUS __stdcall AddDevice(PDRIVER_OBJECT DriverObject,
PDEVICE_OBJECT Physica
TRACE("(%p, %p)\n", DriverObject, PhysicalDeviceObject);
+ UNUSED(DriverObject);
+
ExAcquireResourceSharedLite(&pdo_list_lock, true);
le = pdo_list.Flink;
diff --git a/drivers/filesystems/btrfs/btrfs.rc b/drivers/filesystems/btrfs/btrfs.rc
index 44920b9aeee..8a0116a2646 100644
--- a/drivers/filesystems/btrfs/btrfs.rc
+++ b/drivers/filesystems/btrfs/btrfs.rc
@@ -51,8 +51,8 @@ END
//
VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,7,3,0
- PRODUCTVERSION 1,7,3,0
+ FILEVERSION 1,7,4,0
+ PRODUCTVERSION 1,7,4,0
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@@ -68,12 +68,12 @@ BEGIN
BLOCK "080904b0"
BEGIN
VALUE "FileDescription", "WinBtrfs"
- VALUE "FileVersion", "1.7.3"
+ VALUE "FileVersion", "1.7.4"
VALUE "InternalName", "btrfs"
VALUE "LegalCopyright", "Copyright (c) Mark Harmstone
2016-20"
VALUE "OriginalFilename", "btrfs.sys"
VALUE "ProductName", "WinBtrfs"
- VALUE "ProductVersion", "1.7.3"
+ VALUE "ProductVersion", "1.7.4"
END
END
BLOCK "VarFileInfo"
diff --git a/drivers/filesystems/btrfs/btrfs_drv.h
b/drivers/filesystems/btrfs/btrfs_drv.h
index 8b92af9ea83..17c58e4e5d5 100644
--- a/drivers/filesystems/btrfs/btrfs_drv.h
+++ b/drivers/filesystems/btrfs/btrfs_drv.h
@@ -66,10 +66,6 @@
#include "btrfs.h"
#include "btrfsioctl.h"
-#if !defined(__REACTOS__) && (defined(_X86_) || defined(_AMD64_))
-#include <emmintrin.h>
-#endif
-
#ifdef __REACTOS__
C_ASSERT(sizeof(bool) == 1);
#endif
@@ -134,14 +130,16 @@ C_ASSERT(sizeof(bool) == 1);
#define try __try
#define except __except
#define finally __finally
+#define leave __leave
#else
#define try if (1)
#define except(x) if (0 && (x))
#define finally if (1)
+#define leave
#endif
#ifndef __REACTOS__
-#ifdef __GNUC__
+#ifndef InterlockedIncrement64
#define InterlockedIncrement64(a) __sync_add_and_fetch(a, 1)
#endif
#endif // __REACTOS__
@@ -1102,6 +1100,12 @@ __inline static uint32_t get_extent_data_refcount(uint8_t type,
void* data) {
}
}
+// in xor-gas.S
+#if defined(_X86_) || defined(_AMD64_)
+void __stdcall do_xor_sse2(uint8_t* buf1, uint8_t* buf2, uint32_t len);
+void __stdcall do_xor_avx2(uint8_t* buf1, uint8_t* buf2, uint32_t len);
+#endif
+
// in btrfs.c
_Ret_maybenull_
device* find_device_from_uuid(_In_ device_extension* Vcb, _In_ BTRFS_UUID* uuid);
@@ -1131,6 +1135,10 @@ bool is_file_name_valid(_In_ PUNICODE_STRING us, _In_ bool posix,
_In_ bool stre
void send_notification_fileref(_In_ file_ref* fileref, _In_ ULONG filter_match, _In_
ULONG action, _In_opt_ PUNICODE_STRING stream);
void queue_notification_fcb(_In_ file_ref* fileref, _In_ ULONG filter_match, _In_ ULONG
action, _In_opt_ PUNICODE_STRING stream);
+typedef void (__stdcall *xor_func)(uint8_t* buf1, uint8_t* buf2, uint32_t len);
+
+extern xor_func do_xor;
+
#ifdef DEBUG_CHUNK_LOCKS
#define acquire_chunk_lock(c, Vcb) { ExAcquireResourceExclusiveLite(&c->lock,
true); InterlockedIncrement(&Vcb->chunk_locks_held); }
#define release_chunk_lock(c, Vcb) { InterlockedDecrement(&Vcb->chunk_locks_held);
ExReleaseResourceLite(&c->lock); }
@@ -1176,8 +1184,6 @@ bool check_superblock_checksum(superblock* sb);
#define funcname __func__
#endif
-extern bool have_sse2;
-
extern uint32_t mount_compress;
extern uint32_t mount_compress_force;
extern uint32_t mount_compress_type;
@@ -1229,8 +1235,8 @@ void _debug_message(_In_ const char* func, _In_ char* s, ...)
__attribute__((for
#else
-#define TRACE(s, ...)
-#define WARN(s, ...)
+#define TRACE(s, ...) do { } while(0)
+#define WARN(s, ...) do { } while(0)
#define FIXME(s, ...) DbgPrint("Btrfs FIXME : %s : " s, funcname,
##__VA_ARGS__)
#define ERR(s, ...) DbgPrint("Btrfs ERR : %s : " s, funcname, ##__VA_ARGS__)
@@ -1424,10 +1430,10 @@ void insert_dir_child_into_hash_lists(fcb* fcb, dir_child* dc);
void remove_dir_child_from_hash_lists(fcb* fcb, dir_child* dc);
// in reparse.c
-NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject, void*
buffer, DWORD buflen, ULONG_PTR* retlen);
+NTSTATUS get_reparse_point(PFILE_OBJECT FileObject, void* buffer, DWORD buflen,
ULONG_PTR* retlen);
NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, ccb* ccb,
file_ref* fileref, PIRP Irp, LIST_ENTRY* rollback);
-NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp);
-NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+NTSTATUS set_reparse_point(PIRP Irp);
+NTSTATUS delete_reparse_point(PIRP Irp);
// in create.c
@@ -1605,21 +1611,7 @@ NTSTATUS vol_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS vol_close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_query_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_flush_buffers(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_query_volume_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_set_volume_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_cleanup(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_file_system_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_lock_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS vol_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_shutdown(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
void add_volume_device(superblock* sb, PUNICODE_STRING devpath, uint64_t length, ULONG
disk_num, ULONG part_num);
NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath);
@@ -1734,49 +1726,6 @@ static __inline bool write_fcb_compressed(fcb* fcb) {
return false;
}
-static __inline void do_xor(uint8_t* buf1, uint8_t* buf2, uint32_t len) {
- uint32_t j;
-#ifndef __REACTOS__
-#if defined(_X86_) || defined(_AMD64_)
- __m128i x1, x2;
-
- if (have_sse2 && ((uintptr_t)buf1 & 0xf) == 0 && ((uintptr_t)buf2
& 0xf) == 0) {
- while (len >= 16) {
- x1 = _mm_load_si128((__m128i*)buf1);
- x2 = _mm_load_si128((__m128i*)buf2);
- x1 = _mm_xor_si128(x1, x2);
- _mm_store_si128((__m128i*)buf1, x1);
-
- buf1 += 16;
- buf2 += 16;
- len -= 16;
- }
- }
-#elif defined(_ARM_) || defined(_ARM64_)
- uint64x2_t x1, x2;
-
- if (((uintptr_t)buf1 & 0xf) == 0 && ((uintptr_t)buf2 & 0xf) == 0) {
- while (len >= 16) {
- x1 = vld1q_u64((const uint64_t*)buf1);
- x2 = vld1q_u64((const uint64_t*)buf2);
- x1 = veorq_u64(x1, x2);
- vst1q_u64((uint64_t*)buf1, x1);
-
- buf1 += 16;
- buf2 += 16;
- len -= 16;
- }
- }
-#endif
-#endif // __REACTOS__
-
- for (j = 0; j < len; j++) {
- *buf1 ^= *buf2;
- buf1++;
- buf2++;
- }
-}
-
#ifdef DEBUG_FCB_REFCOUNTS
#ifdef DEBUG_LONG_MESSAGES
#define increase_fileref_refcount(fileref) {\
diff --git a/drivers/filesystems/btrfs/btrfsioctl.h
b/drivers/filesystems/btrfs/btrfsioctl.h
index 0ba18cf837a..dc1cccd89fe 100644
--- a/drivers/filesystems/btrfs/btrfsioctl.h
+++ b/drivers/filesystems/btrfs/btrfsioctl.h
@@ -37,6 +37,7 @@
#define FSCTL_BTRFS_READ_SEND_BUFFER CTL_CODE(FILE_DEVICE_UNKNOWN, 0x847,
METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
#define FSCTL_BTRFS_RESIZE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x848, METHOD_IN_DIRECT,
FILE_ANY_ACCESS)
#define IOCTL_BTRFS_UNLOAD CTL_CODE(FILE_DEVICE_UNKNOWN, 0x849, METHOD_NEITHER,
FILE_ANY_ACCESS)
+#define FSCTL_BTRFS_GET_CSUM_INFO CTL_CODE(FILE_DEVICE_UNKNOWN, 0x84a, METHOD_BUFFERED,
FILE_READ_ACCESS)
typedef struct {
uint64_t subvol;
@@ -279,3 +280,10 @@ typedef struct {
uint64_t device;
uint64_t size;
} btrfs_resize;
+
+typedef struct {
+ uint8_t csum_type;
+ uint8_t csum_length;
+ uint64_t num_sectors;
+ uint8_t data[1];
+} btrfs_csum_info;
diff --git a/drivers/filesystems/btrfs/compress.c b/drivers/filesystems/btrfs/compress.c
index 786bca33254..d5d229905b6 100644
--- a/drivers/filesystems/btrfs/compress.c
+++ b/drivers/filesystems/btrfs/compress.c
@@ -703,13 +703,18 @@ NTSTATUS zstd_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t*
outbuf, uint32
output.size = outlen;
output.pos = 0;
- read = ZSTD_decompressStream(stream, &output, &input);
+ do {
+ read = ZSTD_decompressStream(stream, &output, &input);
- if (ZSTD_isError(read)) {
- ERR("ZSTD_decompressStream failed: %s\n", ZSTD_getErrorName(read));
- Status = STATUS_INTERNAL_ERROR;
- goto end;
- }
+ if (ZSTD_isError(read)) {
+ ERR("ZSTD_decompressStream failed: %s\n",
ZSTD_getErrorName(read));
+ Status = STATUS_INTERNAL_ERROR;
+ goto end;
+ }
+
+ if (output.pos == output.size)
+ break;
+ } while (read != 0);
Status = STATUS_SUCCESS;
diff --git a/drivers/filesystems/btrfs/crc32c-amd64.S
b/drivers/filesystems/btrfs/crc32c-amd64.S
deleted file mode 100644
index dbe035487c7..00000000000
--- a/drivers/filesystems/btrfs/crc32c-amd64.S
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Copyright (c) Mark Harmstone 2020
- *
- * This file is part of WinBtrfs.
- *
- * WinBtrfs is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public Licence as published by
- * the Free Software Foundation, either version 3 of the Licence, or
- * (at your option) any later version.
- *
- * WinBtrfs is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public Licence for more details.
- *
- * You should have received a copy of the GNU Lesser General Public Licence
- * along with WinBtrfs. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <asm.inc>
-
-EXTERN crctable:QWORD
-
-.code64
-
-
-/* uint32_t __stdcall calc_crc32c_sw(uint32_t seed, uint8_t* msg, uint32_t msglen); */
-
-PUBLIC calc_crc32c_sw
-calc_crc32c_sw:
-
-/* rax = crc / seed
- * rdx = buf
- * r8 = len
- * rcx = tmp
- * r10 = tmp2 */
-
-mov rax, rcx
-
-crcloop:
-test r8, r8
-jz crcend
-
-mov rcx, rax
-shr rcx, 8
-mov r10b, byte ptr [rdx]
-xor al, r10b
-and rax, 255
-shl rax, 2
-lea r10, [rip+crctable]
-mov eax, dword ptr [r10 + rax]
-xor rax, rcx
-
-inc rdx
-dec r8
-
-jmp crcloop
-
-crcend:
-ret
-
-/****************************************************/
-
-/* uint32_t __stdcall calc_crc32c_hw(uint32_t seed, uint8_t* msg, uint32_t msglen); */
-
-PUBLIC calc_crc32c_hw
-calc_crc32c_hw:
-
-/* rax = crc / seed
- * rdx = buf
- * r8 = len */
-
-mov rax, rcx
-
-crchw_loop:
-cmp r8, 8
-jl crchw_stragglers
-
-crc32 rax, qword ptr [rdx]
-
-add rdx, 8
-sub r8, 8
-jmp crchw_loop
-
-crchw_stragglers:
-cmp r8, 4
-jl crchw_stragglers2
-
-crc32 eax, dword ptr [rdx]
-
-add rdx, 4
-sub r8, 4
-
-crchw_stragglers2:
-cmp r8, 2
-jl crchw_stragglers3
-
-crc32 eax, word ptr [rdx]
-
-add rdx, 2
-sub r8, 2
-
-crchw_stragglers3:
-test r8, r8
-jz crchw_end
-
-crc32 eax, byte ptr [rdx]
-inc rdx
-dec r8
-jmp crchw_stragglers3
-
-crchw_end:
-ret
-
-END
diff --git a/drivers/filesystems/btrfs/crc32c-x86.S b/drivers/filesystems/btrfs/crc32c.S
similarity index 62%
rename from drivers/filesystems/btrfs/crc32c-x86.S
rename to drivers/filesystems/btrfs/crc32c.S
index 991eec8dc57..516a911d18c 100644
--- a/drivers/filesystems/btrfs/crc32c-x86.S
+++ b/drivers/filesystems/btrfs/crc32c.S
@@ -17,8 +17,105 @@
#include <asm.inc>
-EXTERN _crctable:DWORD
+#ifdef __x86_64__
+
+EXTERN crctable:QWORD
+
+.code64
+
+/* uint32_t __stdcall calc_crc32c_sw(uint32_t seed, uint8_t* msg, uint32_t msglen); */
+
+PUBLIC calc_crc32c_sw
+calc_crc32c_sw:
+
+/* rax = crc / seed
+ * rdx = buf
+ * r8 = len
+ * rcx = tmp
+ * r10 = tmp2 */
+
+mov rax, rcx
+
+crcloop:
+test r8, r8
+jz crcend
+
+mov rcx, rax
+shr rcx, 8
+mov r10b, byte ptr [rdx]
+xor al, r10b
+and rax, 255
+shl rax, 2
+lea r10, [rip+crctable]
+mov eax, dword ptr [r10 + rax]
+xor rax, rcx
+
+inc rdx
+dec r8
+
+jmp crcloop
+
+crcend:
+ret
+
+/****************************************************/
+
+/* uint32_t __stdcall calc_crc32c_hw(uint32_t seed, uint8_t* msg, uint32_t msglen); */
+
+PUBLIC calc_crc32c_hw
+
+calc_crc32c_hw:
+
+/* rax = crc / seed
+ * rdx = buf
+ * r8 = len */
+mov rax, rcx
+
+crchw_loop:
+cmp r8, 8
+jl crchw_stragglers
+
+crc32 rax, qword ptr [rdx]
+
+add rdx, 8
+sub r8, 8
+jmp crchw_loop
+
+crchw_stragglers:
+cmp r8, 4
+jl crchw_stragglers2
+
+crc32 eax, dword ptr [rdx]
+
+add rdx, 4
+sub r8, 4
+
+crchw_stragglers2:
+cmp r8, 2
+jl crchw_stragglers3
+
+crc32 eax, word ptr [rdx]
+
+add rdx, 2
+sub r8, 2
+
+crchw_stragglers3:
+test r8, r8
+jz crchw_end
+
+crc32 eax, byte ptr [rdx]
+inc rdx
+dec r8
+jmp crchw_stragglers3
+
+crchw_end:
+ret
+
+END
+#elif defined(_X86_)
+
+EXTERN _crctable:DWORD
.code
/* uint32_t __stdcall calc_crc32c_sw(uint32_t seed, uint8_t* msg, uint32_t msglen); */
@@ -120,3 +217,4 @@ pop ebp
ret 12
END
+#endif
diff --git a/drivers/filesystems/btrfs/crc32c.h b/drivers/filesystems/btrfs/crc32c.h
index 73bd9697af3..c012642159f 100644
--- a/drivers/filesystems/btrfs/crc32c.h
+++ b/drivers/filesystems/btrfs/crc32c.h
@@ -2,6 +2,10 @@
#include <stdint.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
#if defined(_X86_) || defined(_AMD64_)
uint32_t __stdcall calc_crc32c_hw(uint32_t seed, uint8_t* msg, uint32_t msglen);
#endif
@@ -11,3 +15,7 @@ uint32_t __stdcall calc_crc32c_sw(uint32_t seed, uint8_t* msg, uint32_t
msglen);
typedef uint32_t (__stdcall *crc_func)(uint32_t seed, uint8_t* msg, uint32_t msglen);
extern crc_func calc_crc32c;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/drivers/filesystems/btrfs/create.c b/drivers/filesystems/btrfs/create.c
index 0dee14dc7fd..699228e95a1 100644
--- a/drivers/filesystems/btrfs/create.c
+++ b/drivers/filesystems/btrfs/create.c
@@ -387,7 +387,7 @@ static NTSTATUS split_path(device_extension* Vcb, PUNICODE_STRING
path, LIST_ENT
if (nb->us.Buffer[i] == ':') {
name_bit* nb2;
- if (nb->us.Buffer[i+1] == 0) {
+ if (i + 1 == nb->us.Length / sizeof(WCHAR)) {
WARN("zero-length stream name\n");
Status = STATUS_OBJECT_NAME_INVALID;
goto cleanup;
@@ -709,7 +709,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock)
_Requires_exclusive_lo
bool atts_set = false, sd_set = false, no_data;
LIST_ENTRY* lastle = NULL;
EXTENT_DATA* ed = NULL;
- uint64_t fcbs_version;
+ uint64_t fcbs_version = 0;
uint32_t hash;
hash = calc_crc32c(0xffffffff, (uint8_t*)&inode, sizeof(uint64_t));
@@ -1687,7 +1687,7 @@ NTSTATUS open_fileref(_Requires_lock_held_(_Curr_->tree_lock)
_Requires_exclusiv
UNICODE_STRING fnus2;
file_ref *dir, *sf, *sf2;
LIST_ENTRY parts;
- bool has_stream;
+ bool has_stream = false;
NTSTATUS Status;
LIST_ENTRY* le;
@@ -4658,7 +4658,7 @@ loaded:
if (!NT_SUCCESS(Status))
goto exit;
} else {
- file_ref* existing_file;
+ file_ref* existing_file = NULL;
Status = file_create(Irp, Vcb, FileObject, related, loaded_related, &fn,
RequestedDisposition, options, &existing_file, rollback);
diff --git a/drivers/filesystems/btrfs/dirctrl.c b/drivers/filesystems/btrfs/dirctrl.c
index 2d0a5fdb351..b13dd2a22ff 100644
--- a/drivers/filesystems/btrfs/dirctrl.c
+++ b/drivers/filesystems/btrfs/dirctrl.c
@@ -1174,7 +1174,7 @@ NTSTATUS __stdcall drv_directory_control(IN PDEVICE_OBJECT
DeviceObject, IN PIRP
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_directory_control(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
diff --git a/drivers/filesystems/btrfs/fastio.c b/drivers/filesystems/btrfs/fastio.c
index 465e191dfa6..e073f3f9b1d 100644
--- a/drivers/filesystems/btrfs/fastio.c
+++ b/drivers/filesystems/btrfs/fastio.c
@@ -25,6 +25,8 @@ static BOOLEAN __stdcall fast_query_basic_info(PFILE_OBJECT FileObject,
BOOLEAN
fcb* fcb;
ccb* ccb;
+ UNUSED(DeviceObject);
+
FsRtlEnterFileSystem();
TRACE("(%p, %u, %p, %p, %p)\n", FileObject, wait, fbi, IoStatus,
DeviceObject);
@@ -99,6 +101,8 @@ static BOOLEAN __stdcall fast_query_standard_info(PFILE_OBJECT
FileObject, BOOLE
bool ads;
ULONG adssize;
+ UNUSED(DeviceObject);
+
FsRtlEnterFileSystem();
TRACE("(%p, %u, %p, %p, %p)\n", FileObject, wait, fsi, IoStatus,
DeviceObject);
@@ -198,6 +202,10 @@ static BOOLEAN __stdcall fast_io_query_network_open_info(PFILE_OBJECT
FileObject
ccb* ccb;
file_ref* fileref;
+ UNUSED(Wait);
+ UNUSED(IoStatus); // FIXME - really? What about IoStatus->Information?
+ UNUSED(DeviceObject);
+
FsRtlEnterFileSystem();
TRACE("(%p, %u, %p, %p, %p)\n", FileObject, Wait, fnoi, IoStatus,
DeviceObject);
@@ -372,6 +380,8 @@ static BOOLEAN __stdcall fast_io_lock(PFILE_OBJECT FileObject,
PLARGE_INTEGER Fi
BOOLEAN ret;
fcb* fcb = FileObject->FsContext;
+ UNUSED(DeviceObject);
+
TRACE("(%p, %I64x, %I64x, %p, %lx, %u, %u, %p, %p)\n", FileObject,
FileOffset ? FileOffset->QuadPart : 0, Length ? Length->QuadPart : 0,
ProcessId, Key, FailImmediately, ExclusiveLock, IoStatus, DeviceObject);
@@ -402,6 +412,8 @@ static BOOLEAN __stdcall fast_io_unlock_single(PFILE_OBJECT
FileObject, PLARGE_I
ULONG Key, PIO_STATUS_BLOCK IoStatus,
PDEVICE_OBJECT DeviceObject) {
fcb* fcb = FileObject->FsContext;
+ UNUSED(DeviceObject);
+
TRACE("(%p, %I64x, %I64x, %p, %lx, %p, %p)\n", FileObject, FileOffset ?
FileOffset->QuadPart : 0, Length ? Length->QuadPart : 0,
ProcessId, Key, IoStatus, DeviceObject);
@@ -428,6 +440,8 @@ _Function_class_(FAST_IO_UNLOCK_ALL)
static BOOLEAN __stdcall fast_io_unlock_all(PFILE_OBJECT FileObject, PEPROCESS ProcessId,
PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
fcb* fcb = FileObject->FsContext;
+ UNUSED(DeviceObject);
+
TRACE("(%p, %p, %p, %p)\n", FileObject, ProcessId, IoStatus,
DeviceObject);
IoStatus->Information = 0;
@@ -458,6 +472,8 @@ static BOOLEAN __stdcall fast_io_unlock_all_by_key(PFILE_OBJECT
FileObject, PVOI
PIO_STATUS_BLOCK IoStatus,
PDEVICE_OBJECT DeviceObject) {
fcb* fcb = FileObject->FsContext;
+ UNUSED(DeviceObject);
+
TRACE("(%p, %p, %lx, %p, %p)\n", FileObject, ProcessId, Key, IoStatus,
DeviceObject);
IoStatus->Information = 0;
diff --git a/drivers/filesystems/btrfs/fileinfo.c b/drivers/filesystems/btrfs/fileinfo.c
index 81c0f06816a..85006b55fc5 100644
--- a/drivers/filesystems/btrfs/fileinfo.c
+++ b/drivers/filesystems/btrfs/fileinfo.c
@@ -3826,7 +3826,7 @@ NTSTATUS __stdcall drv_set_information(IN PDEVICE_OBJECT
DeviceObject, IN PIRP I
Irp->IoStatus.Information = 0;
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_set_information(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
@@ -5345,7 +5345,7 @@ NTSTATUS __stdcall drv_query_information(IN PDEVICE_OBJECT
DeviceObject, IN PIRP
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_query_information(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
@@ -5399,7 +5399,7 @@ NTSTATUS __stdcall drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN
PIRP Irp) {
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_query_ea(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
@@ -5635,7 +5635,7 @@ NTSTATUS __stdcall drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN
PIRP Irp) {
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_set_ea(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
diff --git a/drivers/filesystems/btrfs/flushthread.c
b/drivers/filesystems/btrfs/flushthread.c
index 6495859ab63..e6354b36822 100644
--- a/drivers/filesystems/btrfs/flushthread.c
+++ b/drivers/filesystems/btrfs/flushthread.c
@@ -5816,6 +5816,8 @@ static NTSTATUS partial_stripe_read(device_extension* Vcb, chunk* c,
partial_str
}
i = (parity + 1) % c->chunk_item->num_stripes;
+ logstripe = (c->chunk_item->num_stripes +
c->chunk_item->num_stripes - 1 - parity + stripe) %
c->chunk_item->num_stripes;
+
for (k = 0; k < c->chunk_item->num_stripes; k++) {
if (i != stripe) {
if (c->devices[i]->devobj) {
@@ -5835,8 +5837,7 @@ static NTSTATUS partial_stripe_read(device_extension* Vcb, chunk* c,
partial_str
ExFreePool(scratch);
return STATUS_UNEXPECTED_IO_ERROR;
}
- } else
- logstripe = k;
+ }
i = (i + 1) % c->chunk_item->num_stripes;
}
diff --git a/drivers/filesystems/btrfs/fsctl.c b/drivers/filesystems/btrfs/fsctl.c
index 70a954d04aa..f1bb68c22a0 100644
--- a/drivers/filesystems/btrfs/fsctl.c
+++ b/drivers/filesystems/btrfs/fsctl.c
@@ -17,6 +17,7 @@
#include "btrfs_drv.h"
#include "btrfsioctl.h"
+#include "crc32c.h"
#include <ntddstor.h>
#include <ntdddisk.h>
#ifndef __REACTOS__
@@ -2179,10 +2180,10 @@ end:
return Status;
}
-static NTSTATUS get_object_id(device_extension* Vcb, PFILE_OBJECT FileObject,
FILE_OBJECTID_BUFFER* buf, ULONG buflen, ULONG_PTR* retlen) {
+static NTSTATUS get_object_id(PFILE_OBJECT FileObject, FILE_OBJECTID_BUFFER* buf, ULONG
buflen, ULONG_PTR* retlen) {
fcb* fcb;
- TRACE("(%p, %p, %p, %lx, %p)\n", Vcb, FileObject, buf, buflen, retlen);
+ TRACE("(%p, %p, %lx, %p)\n", FileObject, buf, buflen, retlen);
if (!FileObject) {
ERR("FileObject was NULL\n");
@@ -4965,6 +4966,343 @@ static NTSTATUS fsctl_oplock(device_extension* Vcb, PIRP* Pirp) {
return Status;
}
+static NTSTATUS get_retrieval_pointers(device_extension* Vcb, PFILE_OBJECT FileObject,
STARTING_VCN_INPUT_BUFFER* in,
+ ULONG inlen, RETRIEVAL_POINTERS_BUFFER* out, ULONG
outlen, ULONG_PTR* retlen) {
+ NTSTATUS Status;
+ fcb* fcb;
+
+ TRACE("get_retrieval_pointers(%p, %p, %p, %lx, %p, %lx, %p)\n", Vcb,
FileObject, in, inlen,
+ out, outlen,
retlen);
+
+ if (!FileObject)
+ return STATUS_INVALID_PARAMETER;
+
+ fcb = FileObject->FsContext;
+
+ if (!fcb)
+ return STATUS_INVALID_PARAMETER;
+
+ if (inlen < sizeof(STARTING_VCN_INPUT_BUFFER) || in->StartingVcn.QuadPart <
0)
+ return STATUS_INVALID_PARAMETER;
+
+ if (!out)
+ return STATUS_INVALID_PARAMETER;
+
+ if (outlen < offsetof(RETRIEVAL_POINTERS_BUFFER, Extents[0]))
+ return STATUS_BUFFER_TOO_SMALL;
+
+ ExAcquireResourceSharedLite(fcb->Header.Resource, true);
+
+ try {
+ LIST_ENTRY* le = fcb->extents.Flink;
+ extent* first_ext = NULL;
+ unsigned int num_extents = 0, first_extent_num = 0, i;
+ uint64_t num_sectors, last_off = 0;
+
+ num_sectors = (fcb->inode_item.st_size + Vcb->superblock.sector_size - 1)
>> Vcb->sector_shift;
+
+ while (le != &fcb->extents) {
+ extent* ext = CONTAINING_RECORD(le, extent, list_entry);
+
+ if (ext->ignore || ext->extent_data.type == EXTENT_TYPE_INLINE) {
+ le = le->Flink;
+ continue;
+ }
+
+ if (ext->offset > last_off)
+ num_extents++;
+
+ if ((ext->offset >> Vcb->sector_shift) <=
(uint64_t)in->StartingVcn.QuadPart &&
+ (ext->offset + ext->extent_data.decoded_size) >>
Vcb->sector_shift > (uint64_t)in->StartingVcn.QuadPart) {
+ first_ext = ext;
+ first_extent_num = num_extents;
+ }
+
+ num_extents++;
+
+ last_off = ext->offset + ext->extent_data.decoded_size;
+
+ le = le->Flink;
+ }
+
+ if (num_sectors > last_off >> Vcb->sector_shift)
+ num_extents++;
+
+ if (!first_ext) {
+ Status = STATUS_END_OF_FILE;
+ leave;
+ }
+
+ out->ExtentCount = num_extents - first_extent_num;
+ out->StartingVcn.QuadPart = first_ext->offset >>
Vcb->sector_shift;
+ outlen -= offsetof(RETRIEVAL_POINTERS_BUFFER, Extents[0]);
+ *retlen = offsetof(RETRIEVAL_POINTERS_BUFFER, Extents[0]);
+
+ le = &first_ext->list_entry;
+ i = 0;
+ last_off = 0;
+
+ while (le != &fcb->extents) {
+ extent* ext = CONTAINING_RECORD(le, extent, list_entry);
+
+ if (ext->ignore || ext->extent_data.type == EXTENT_TYPE_INLINE) {
+ le = le->Flink;
+ continue;
+ }
+
+ if (ext->offset > last_off) {
+ if (outlen < sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER)) {
+ Status = STATUS_BUFFER_OVERFLOW;
+ leave;
+ }
+
+ out->Extents[i].NextVcn.QuadPart = ext->offset >>
Vcb->sector_shift;
+ out->Extents[i].Lcn.QuadPart = -1;
+
+ outlen -= sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER);
+ *retlen += sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER);
+ i++;
+ }
+
+ if (outlen < sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER)) {
+ Status = STATUS_BUFFER_OVERFLOW;
+ leave;
+ }
+
+ out->Extents[i].NextVcn.QuadPart = (ext->offset +
ext->extent_data.decoded_size) >> Vcb->sector_shift;
+
+ if (ext->extent_data.compression == BTRFS_COMPRESSION_NONE) {
+ EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ext->extent_data.data;
+
+ out->Extents[i].Lcn.QuadPart = (ed2->address + ed2->offset)
>> Vcb->sector_shift;
+ } else
+ out->Extents[i].Lcn.QuadPart = -1;
+
+ outlen -= sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER);
+ *retlen += sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER);
+ i++;
+
+ le = le->Flink;
+ }
+
+ if (num_sectors << Vcb->sector_shift > last_off) {
+ if (outlen < sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER)) {
+ Status = STATUS_BUFFER_OVERFLOW;
+ leave;
+ }
+
+ out->Extents[i].NextVcn.QuadPart = num_sectors;
+ out->Extents[i].Lcn.QuadPart = -1;
+
+ outlen -= sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER);
+ *retlen += sizeof(LARGE_INTEGER) + sizeof(LARGE_INTEGER);
+ }
+
+ Status = STATUS_SUCCESS;
+ } finally {
+ ExReleaseResourceLite(fcb->Header.Resource);
+ }
+
+ return Status;
+}
+
+static NTSTATUS add_csum_sparse_extents(device_extension* Vcb, uint64_t sparse_extents,
uint8_t** ptr, bool found, void* hash_ptr) {
+ if (!found) {
+ uint8_t* sector = ExAllocatePoolWithTag(PagedPool,
Vcb->superblock.sector_size, ALLOC_TAG);
+
+ if (!sector) {
+ ERR("out of memory\n");
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ memset(sector, 0, Vcb->superblock.sector_size);
+
+ get_sector_csum(Vcb, sector, hash_ptr);
+
+ ExFreePool(sector);
+ }
+
+ switch (Vcb->superblock.csum_type) {
+ case CSUM_TYPE_CRC32C: {
+ uint32_t* csum = (uint32_t*)*ptr;
+ uint32_t sparse_hash = *(uint32_t*)hash_ptr;
+
+ for (uint64_t i = 0; i < sparse_extents; i++) {
+ csum[i] = sparse_hash;
+ }
+
+ break;
+ }
+
+ case CSUM_TYPE_XXHASH: {
+ uint64_t* csum = (uint64_t*)*ptr;
+ uint64_t sparse_hash = *(uint64_t*)hash_ptr;
+
+ for (uint64_t i = 0; i < sparse_extents; i++) {
+ csum[i] = sparse_hash;
+ }
+
+ break;
+ }
+
+ case CSUM_TYPE_SHA256:
+ case CSUM_TYPE_BLAKE2: {
+ uint8_t* csum = (uint8_t*)*ptr;
+
+ for (uint64_t i = 0; i < sparse_extents; i++) {
+ memcpy(csum, hash_ptr, 32);
+ csum += 32;
+ }
+
+ break;
+ }
+
+ default:
+ ERR("unrecognized hash type %x\n", Vcb->superblock.csum_type);
+ return STATUS_INTERNAL_ERROR;
+ }
+
+ *ptr += sparse_extents * Vcb->csum_size;
+
+ return STATUS_SUCCESS;
+}
+
+static NTSTATUS get_csum_info(device_extension* Vcb, PFILE_OBJECT FileObject,
btrfs_csum_info* buf, ULONG buflen,
+ ULONG_PTR* retlen, KPROCESSOR_MODE processor_mode) {
+ NTSTATUS Status;
+ fcb* fcb;
+ ccb* ccb;
+
+ TRACE("get_csum_info(%p, %p, %p, %lx, %p, %x)\n", Vcb, FileObject, buf,
buflen, retlen, processor_mode);
+
+ if (!FileObject)
+ return STATUS_INVALID_PARAMETER;
+
+ fcb = FileObject->FsContext;
+ ccb = FileObject->FsContext2;
+
+ if (!fcb || !ccb)
+ return STATUS_INVALID_PARAMETER;
+
+ if (!buf)
+ return STATUS_INVALID_PARAMETER;
+
+ if (buflen < offsetof(btrfs_csum_info, data[0]))
+ return STATUS_BUFFER_TOO_SMALL;
+
+
+ if (processor_mode == UserMode && !(ccb->access & (FILE_READ_DATA |
FILE_WRITE_DATA))) {
+ WARN("insufficient privileges\n");
+ return STATUS_ACCESS_DENIED;
+ }
+
+ ExAcquireResourceSharedLite(fcb->Header.Resource, true);
+
+ try {
+ LIST_ENTRY* le;
+ uint8_t* ptr;
+ uint64_t last_off;
+ uint8_t sparse_hash[MAX_HASH_SIZE];
+ bool sparse_hash_found = false;
+
+ if (fcb->ads) {
+ Status = STATUS_INVALID_DEVICE_REQUEST;
+ leave;
+ }
+
+ if (fcb->type == BTRFS_TYPE_DIRECTORY) {
+ Status = STATUS_FILE_IS_A_DIRECTORY;
+ leave;
+ }
+
+ if (fcb->inode_item.flags & BTRFS_INODE_NODATASUM) {
+ Status = STATUS_INVALID_DEVICE_REQUEST;
+ leave;
+ }
+
+ buf->csum_type = Vcb->superblock.csum_type;
+ buf->csum_length = Vcb->csum_size;
+
+ le = fcb->extents.Flink;
+ while (le != &fcb->extents) {
+ extent* ext = CONTAINING_RECORD(le, extent, list_entry);
+
+ if (ext->ignore) {
+ le = le->Flink;
+ continue;
+ }
+
+ if (ext->extent_data.type == EXTENT_TYPE_INLINE) {
+ buf->num_sectors = 0;
+ *retlen = offsetof(btrfs_csum_info, data[0]);
+ Status = STATUS_SUCCESS;
+ leave;
+ }
+
+ le = le->Flink;
+ }
+
+ buf->num_sectors = (fcb->inode_item.st_size +
Vcb->superblock.sector_size - 1) >> Vcb->sector_shift;
+
+ if (buflen < offsetof(btrfs_csum_info, data[0]) + (buf->csum_length *
buf->num_sectors)) {
+ Status = STATUS_BUFFER_OVERFLOW;
+ *retlen = offsetof(btrfs_csum_info, data[0]);
+ leave;
+ }
+
+ ptr = buf->data;
+ last_off = 0;
+
+ le = fcb->extents.Flink;
+ while (le != &fcb->extents) {
+ extent* ext = CONTAINING_RECORD(le, extent, list_entry);
+ EXTENT_DATA2* ed2;
+
+ if (ext->ignore || ext->extent_data.type == EXTENT_TYPE_INLINE) {
+ le = le->Flink;
+ continue;
+ }
+
+ if (ext->offset > last_off) {
+ uint64_t sparse_extents = (ext->offset - last_off) >>
Vcb->sector_shift;
+
+ add_csum_sparse_extents(Vcb, sparse_extents, &ptr, sparse_hash_found,
sparse_hash);
+ sparse_hash_found = true;
+ }
+
+ ed2 = (EXTENT_DATA2*)ext->extent_data.data;
+
+ if (ext->extent_data.compression != BTRFS_COMPRESSION_NONE)
+ memset(ptr, 0, (ed2->num_bytes >> Vcb->sector_shift) *
Vcb->csum_size); // dummy value for compressed extents
+ else {
+ if (ext->csum)
+ memcpy(ptr, ext->csum, (ed2->num_bytes >>
Vcb->sector_shift) * Vcb->csum_size);
+ else
+ memset(ptr, 0, (ed2->num_bytes >> Vcb->sector_shift) *
Vcb->csum_size);
+
+ ptr += (ed2->num_bytes >> Vcb->sector_shift) *
Vcb->csum_size;
+ }
+
+ last_off = ext->offset + ed2->num_bytes;
+
+ le = le->Flink;
+ }
+
+ if (buf->num_sectors > last_off >> Vcb->sector_shift) {
+ uint64_t sparse_extents = buf->num_sectors - (last_off >>
Vcb->sector_shift);
+
+ add_csum_sparse_extents(Vcb, sparse_extents, &ptr, sparse_hash_found,
sparse_hash);
+ }
+
+ *retlen = offsetof(btrfs_csum_info, data[0]) + (buf->csum_length *
buf->num_sectors);
+ Status = STATUS_SUCCESS;
+ } finally {
+ ExReleaseResourceLite(fcb->Header.Resource);
+ }
+
+ return Status;
+}
+
NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp, uint32_t type) {
PIRP Irp = *Pirp;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
@@ -5065,8 +5403,11 @@ NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp,
uint32_t type) {
break;
case FSCTL_GET_RETRIEVAL_POINTERS:
- WARN("STUB: FSCTL_GET_RETRIEVAL_POINTERS\n");
- Status = STATUS_INVALID_DEVICE_REQUEST;
+ Status = get_retrieval_pointers(DeviceObject->DeviceExtension,
IrpSp->FileObject,
+
IrpSp->Parameters.FileSystemControl.Type3InputBuffer,
+
IrpSp->Parameters.FileSystemControl.InputBufferLength,
+ Irp->UserBuffer,
IrpSp->Parameters.FileSystemControl.OutputBufferLength,
+ &Irp->IoStatus.Information);
break;
case FSCTL_MOVE_FILE:
@@ -5093,8 +5434,8 @@ NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp,
uint32_t type) {
break;
case FSCTL_GET_OBJECT_ID:
- Status = get_object_id(DeviceObject->DeviceExtension,
IrpSp->FileObject, Irp->UserBuffer,
-
IrpSp->Parameters.FileSystemControl.OutputBufferLength,
&Irp->IoStatus.Information);
+ Status = get_object_id(IrpSp->FileObject, Irp->UserBuffer,
IrpSp->Parameters.FileSystemControl.OutputBufferLength,
+ &Irp->IoStatus.Information);
break;
case FSCTL_DELETE_OBJECT_ID:
@@ -5103,16 +5444,16 @@ NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp,
uint32_t type) {
break;
case FSCTL_SET_REPARSE_POINT:
- Status = set_reparse_point(DeviceObject, Irp);
+ Status = set_reparse_point(Irp);
break;
case FSCTL_GET_REPARSE_POINT:
- Status = get_reparse_point(DeviceObject, IrpSp->FileObject,
Irp->AssociatedIrp.SystemBuffer,
+ Status = get_reparse_point(IrpSp->FileObject,
Irp->AssociatedIrp.SystemBuffer,
IrpSp->Parameters.FileSystemControl.OutputBufferLength,
&Irp->IoStatus.Information);
break;
case FSCTL_DELETE_REPARSE_POINT:
- Status = delete_reparse_point(DeviceObject, Irp);
+ Status = delete_reparse_point(Irp);
break;
case FSCTL_ENUM_USN_DATA:
@@ -5136,8 +5477,8 @@ NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp,
uint32_t type) {
break;
case FSCTL_CREATE_OR_GET_OBJECT_ID:
- Status = get_object_id(DeviceObject->DeviceExtension,
IrpSp->FileObject, Irp->UserBuffer,
-
IrpSp->Parameters.FileSystemControl.OutputBufferLength,
&Irp->IoStatus.Information);
+ Status = get_object_id(IrpSp->FileObject, Irp->UserBuffer,
IrpSp->Parameters.FileSystemControl.OutputBufferLength,
+ &Irp->IoStatus.Information);
break;
case FSCTL_SET_SPARSE:
@@ -5558,6 +5899,12 @@ NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp,
uint32_t type) {
IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
break;
+ case FSCTL_BTRFS_GET_CSUM_INFO:
+ Status = get_csum_info(DeviceObject->DeviceExtension,
IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer,
+
IrpSp->Parameters.FileSystemControl.OutputBufferLength,
&Irp->IoStatus.Information,
+ Irp->RequestorMode);
+ break;
+
default:
WARN("unknown control code %lx (DeviceType = %lx, Access = %lx, Function
= %lx, Method = %lx)\n",
IrpSp->Parameters.FileSystemControl.FsControlCode,
(IrpSp->Parameters.FileSystemControl.FsControlCode & 0xff0000) >> 16,
diff --git a/drivers/filesystems/btrfs/pnp.c b/drivers/filesystems/btrfs/pnp.c
index 96401908fba..02314ba7a1f 100644
--- a/drivers/filesystems/btrfs/pnp.c
+++ b/drivers/filesystems/btrfs/pnp.c
@@ -79,6 +79,8 @@ NTSTATUS pnp_surprise_removal(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
TRACE("(%p, %p)\n", DeviceObject, Irp);
+ UNUSED(Irp);
+
if (DeviceObject->Vpb->Flags & VPB_MOUNTED) {
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
diff --git a/drivers/filesystems/btrfs/read.c b/drivers/filesystems/btrfs/read.c
index 091a0b0b7fe..824a1c17b29 100644
--- a/drivers/filesystems/btrfs/read.c
+++ b/drivers/filesystems/btrfs/read.c
@@ -466,7 +466,7 @@ static NTSTATUS read_data_raid0(device_extension* Vcb, uint8_t* buf,
uint64_t ad
static NTSTATUS read_data_raid10(device_extension* Vcb, uint8_t* buf, uint64_t addr,
uint32_t length, read_data_context* context,
CHUNK_ITEM* ci, device** devices, uint64_t generation,
uint64_t offset) {
- uint16_t stripe;
+ uint16_t stripe = 0;
NTSTATUS Status;
bool checksum_error = false;
CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&ci[1];
@@ -653,7 +653,7 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, uint8_t* buf,
uint64_t ad
NTSTATUS Status;
bool checksum_error = false;
CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&ci[1];
- uint16_t j, stripe;
+ uint16_t j, stripe = 0;
bool no_success = true;
for (j = 0; j < ci->num_stripes; j++) {
@@ -950,7 +950,7 @@ void raid6_recover2(uint8_t* sectors, uint16_t num_stripes, ULONG
sector_size, u
if (missing != 0)
galois_divpower(out, (uint8_t)missing, sector_size);
} else { // reconstruct from p and q
- uint16_t x, y, stripe;
+ uint16_t x = missing1, y = missing2, stripe;
uint8_t gyx, gx, denom, a, b, *p, *q, *pxy, *qxy;
uint32_t j;
@@ -962,11 +962,6 @@ void raid6_recover2(uint8_t* sectors, uint16_t num_stripes, ULONG
sector_size, u
if (stripe == missing1 || stripe == missing2) {
RtlZeroMemory(qxy, sector_size);
RtlZeroMemory(pxy, sector_size);
-
- if (stripe == missing1)
- x = stripe;
- else
- y = stripe;
} else {
RtlCopyMemory(qxy, sectors + (stripe * sector_size), sector_size);
RtlCopyMemory(pxy, sectors + (stripe * sector_size), sector_size);
@@ -980,10 +975,7 @@ void raid6_recover2(uint8_t* sectors, uint16_t num_stripes, ULONG
sector_size, u
if (stripe != missing1 && stripe != missing2) {
do_xor(qxy, sectors + (stripe * sector_size), sector_size);
do_xor(pxy, sectors + (stripe * sector_size), sector_size);
- } else if (stripe == missing1)
- x = stripe;
- else if (stripe == missing2)
- y = stripe;
+ }
} while (stripe > 0);
gyx = gpow2(y > x ? (y-x) : (255-x+y));
@@ -1015,7 +1007,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, uint8_t* buf,
uint64_t ad
NTSTATUS Status;
bool checksum_error = false;
CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&ci[1];
- uint16_t stripe, j;
+ uint16_t stripe = 0, j;
bool no_success = true;
for (j = 0; j < ci->num_stripes; j++) {
@@ -1117,7 +1109,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, uint8_t* buf,
uint64_t ad
if (context->tree) {
uint8_t* sector;
- uint16_t k, physstripe, parity1, parity2, error_stripe;
+ uint16_t k, physstripe, parity1, parity2, error_stripe = 0;
uint64_t off;
bool recovered = false, failed = false;
ULONG num_errors = 0;
@@ -1321,7 +1313,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, uint8_t* buf,
uint64_t ad
physstripe = (parity2 + stripe + 1) % ci->num_stripes;
if (!devices[physstripe] || !devices[physstripe]->devobj ||
(context->csum && !check_sector_csum(Vcb, buf + (i <<
Vcb->sector_shift), ptr))) {
- uint16_t error_stripe;
+ uint16_t error_stripe = 0;
bool recovered = false, failed = false;
ULONG num_errors = 0;
@@ -2018,7 +2010,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ uint64_t addr,
_In_ uint32_t
uint16_t endoffstripe, parity;
uint32_t *stripeoff, pos;
PMDL master_mdl;
- PFN_NUMBER *pfns, dummy;
+ PFN_NUMBER *pfns, dummy = 0;
bool need_dummy = false;
get_raid0_offset(addr - offset, ci->stripe_length, ci->num_stripes - 1,
&startoff, &startoffstripe);
@@ -2277,7 +2269,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ uint64_t addr,
_In_ uint32_t
uint16_t endoffstripe, parity1;
uint32_t *stripeoff, pos;
PMDL master_mdl;
- PFN_NUMBER *pfns, dummy;
+ PFN_NUMBER *pfns, dummy = 0;
bool need_dummy = false;
get_raid0_offset(addr - offset, ci->stripe_length, ci->num_stripes - 2,
&startoff, &startoffstripe);
@@ -3243,48 +3235,49 @@ nextitem:
inpageoff = inoff % LZO_PAGE_SIZE;
}
- if (off2 != 0) {
- outlen = off2 + min(rp->read,
(uint32_t)(rp->extents[i].ed_num_bytes - rp->extents[i].off));
+ /* Previous versions of this code decompressed directly into the
destination buffer,
+ * but unfortunately that can't be relied on - Windows likes to use
dummy pages sometimes
+ * when mmap-ing, which breaks the backtracking used by e.g. zstd. */
- decomp = ExAllocatePoolWithTag(pool_type, outlen, ALLOC_TAG);
- if (!decomp) {
- ERR("out of memory\n");
- Status = STATUS_INSUFFICIENT_RESOURCES;
- goto exit;
- }
- } else
+ if (off2 != 0)
+ outlen = off2 + min(rp->read,
(uint32_t)(rp->extents[i].ed_num_bytes - rp->extents[i].off));
+ else
outlen = min(rp->read, (uint32_t)(rp->extents[i].ed_num_bytes -
rp->extents[i].off));
+ decomp = ExAllocatePoolWithTag(pool_type, outlen, ALLOC_TAG);
+ if (!decomp) {
+ ERR("out of memory\n");
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto exit;
+ }
+
ccj = (comp_calc_job*)ExAllocatePoolWithTag(pool_type,
sizeof(comp_calc_job), ALLOC_TAG);
if (!ccj) {
ERR("out of memory\n");
- if (decomp)
- ExFreePool(decomp);
+ ExFreePool(decomp);
Status = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
- Status = add_calc_job_decomp(fcb->Vcb, rp->compression, buf2,
inlen, decomp ? decomp : rp->data, outlen,
+ ccj->data = rp->data;
+ ccj->decomp = decomp;
+
+ ccj->offset = off2;
+ ccj->length = (size_t)min(rp->read, rp->extents[i].ed_num_bytes
- rp->extents[i].off);
+
+ Status = add_calc_job_decomp(fcb->Vcb, rp->compression, buf2,
inlen, decomp, outlen,
inpageoff, &ccj->cj);
if (!NT_SUCCESS(Status)) {
ERR("add_calc_job_decomp returned %08lx\n", Status);
- if (decomp)
- ExFreePool(decomp);
-
+ ExFreePool(decomp);
ExFreePool(ccj);
goto exit;
}
- ccj->data = rp->data;
- ccj->decomp = decomp;
-
- ccj->offset = off2;
- ccj->length = (size_t)min(rp->read, rp->extents[i].ed_num_bytes
- rp->extents[i].off);
-
InsertTailList(&calc_jobs, &ccj->list_entry);
buf += rp->extents[i].ed_size;
@@ -3317,10 +3310,8 @@ nextitem:
if (!NT_SUCCESS(ccj->cj->Status))
Status = ccj->cj->Status;
- if (ccj->decomp) {
- RtlCopyMemory(ccj->data, (uint8_t*)ccj->decomp + ccj->offset,
ccj->length);
- ExFreePool(ccj->decomp);
- }
+ RtlCopyMemory(ccj->data, (uint8_t*)ccj->decomp + ccj->offset,
ccj->length);
+ ExFreePool(ccj->decomp);
ExFreePool(ccj);
}
diff --git a/drivers/filesystems/btrfs/reparse.c b/drivers/filesystems/btrfs/reparse.c
index e6a8145b0d3..03708228d46 100644
--- a/drivers/filesystems/btrfs/reparse.c
+++ b/drivers/filesystems/btrfs/reparse.c
@@ -24,7 +24,7 @@ typedef struct {
char name[1];
} REPARSE_DATA_BUFFER_LX_SYMLINK;
-NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject, void*
buffer, DWORD buflen, ULONG_PTR* retlen) {
+NTSTATUS get_reparse_point(PFILE_OBJECT FileObject, void* buffer, DWORD buflen,
ULONG_PTR* retlen) {
USHORT subnamelen, printnamelen, i;
ULONG stringlen;
DWORD reqlen;
@@ -33,7 +33,7 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT
FileObject,
ccb* ccb = FileObject->FsContext2;
NTSTATUS Status;
- TRACE("(%p, %p, %p, %lx, %p)\n", DeviceObject, FileObject, buffer, buflen,
retlen);
+ TRACE("(%p, %p, %lx, %p)\n", FileObject, buffer, buflen, retlen);
if (!ccb)
return STATUS_INVALID_PARAMETER;
@@ -234,15 +234,16 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb,
ccb* ccb, REP
REPARSE_DATA_BUFFER_LX_SYMLINK* buf;
if (buflen < offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) +
rdb->ReparseDataLength) {
- WARN("buffer was less than expected length (%lu < %u)\n",
buflen,
- offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) +
rdb->ReparseDataLength);
+ WARN("buffer was less than expected length (%lu < %lu)\n",
buflen,
+ (unsigned long)(offsetof(REPARSE_DATA_BUFFER,
GenericReparseBuffer.DataBuffer) + rdb->ReparseDataLength));
return STATUS_INVALID_PARAMETER;
}
buf = (REPARSE_DATA_BUFFER_LX_SYMLINK*)rdb->GenericReparseBuffer.DataBuffer;
if (buflen < offsetof(REPARSE_DATA_BUFFER_LX_SYMLINK, name)) {
- WARN("buffer was less than minimum length (%u < %u)\n",
rdb->ReparseDataLength, offsetof(REPARSE_DATA_BUFFER_LX_SYMLINK, name));
+ WARN("buffer was less than minimum length (%u < %lu)\n",
rdb->ReparseDataLength,
+ (unsigned long)(offsetof(REPARSE_DATA_BUFFER_LX_SYMLINK, name)));
return STATUS_INVALID_PARAMETER;
}
@@ -397,7 +398,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG
buflen, cc
return STATUS_SUCCESS;
}
-NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
+NTSTATUS set_reparse_point(PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
void* buffer = Irp->AssociatedIrp.SystemBuffer;
@@ -409,7 +410,7 @@ NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
file_ref* fileref;
LIST_ENTRY rollback;
- TRACE("(%p, %p)\n", DeviceObject, Irp);
+ TRACE("(%p)\n", Irp);
InitializeListHead(&rollback);
@@ -470,7 +471,7 @@ end:
return Status;
}
-NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
+NTSTATUS delete_reparse_point(PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
REPARSE_DATA_BUFFER* rdb = Irp->AssociatedIrp.SystemBuffer;
@@ -481,7 +482,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
file_ref* fileref;
LIST_ENTRY rollback;
- TRACE("(%p, %p)\n", DeviceObject, Irp);
+ TRACE("(%p)\n", Irp);
InitializeListHead(&rollback);
diff --git a/drivers/filesystems/btrfs/scrub.c b/drivers/filesystems/btrfs/scrub.c
index 40938a38077..01160f73654 100644
--- a/drivers/filesystems/btrfs/scrub.c
+++ b/drivers/filesystems/btrfs/scrub.c
@@ -1377,7 +1377,7 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG
type, uint64
scrub_context context;
CHUNK_ITEM_STRIPE* cis;
NTSTATUS Status;
- uint16_t startoffstripe, num_missing, allowed_missing;
+ uint16_t startoffstripe = 0, num_missing, allowed_missing;
TRACE("(%p, %p, %lx, %I64x, %x, %p)\n", Vcb, c, type, offset, size, csum);
@@ -1788,8 +1788,8 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c,
scrub_context_ra
return;
for (ULONG i = 0; i < sectors_per_stripe; i++) {
- ULONG num_errors = 0, bad_off;
- uint64_t bad_stripe;
+ ULONG num_errors = 0, bad_off = 0;
+ uint64_t bad_stripe = 0;
bool alloc = false;
stripe = (parity + 1) % c->chunk_item->num_stripes;
@@ -2006,8 +2006,8 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c,
scrub_context_ra
for (ULONG i = 0; i < sectors_per_stripe; i++) {
ULONG num_errors = 0;
- uint64_t bad_stripe1, bad_stripe2;
- ULONG bad_off1, bad_off2;
+ uint64_t bad_stripe1 = 0, bad_stripe2 = 0;
+ ULONG bad_off1 = 0, bad_off2 = 0;
bool alloc = false;
stripe = (parity1 + 2) % c->chunk_item->num_stripes;
@@ -2071,7 +2071,6 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c,
scrub_context_ra
}
} else if (num_errors == 1) {
uint32_t len;
- uint16_t stripe_num, bad_stripe_num;
uint64_t addr = c->offset + (stripe_start *
(c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (bad_off1
<< Vcb->sector_shift);
uint8_t* scratch;
@@ -2091,6 +2090,8 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c,
scrub_context_ra
stripe = parity1 == 0 ? (c->chunk_item->num_stripes - 1) : (parity1 -
1);
if (c->devices[parity2]->devobj) {
+ uint16_t stripe_num, bad_stripe_num = 0;
+
stripe_num = c->chunk_item->num_stripes - 3;
while (stripe != parity2) {
galois_double(scratch, len);
@@ -2275,7 +2276,7 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c,
scrub_context_ra
ExFreePool(scratch);
} else if (num_errors == 2 && missing_devices == 0) {
- uint16_t x, y, k;
+ uint16_t x = 0, y = 0, k;
uint64_t addr;
uint32_t len = (RtlCheckBit(&context->is_tree, bad_off1) ||
RtlCheckBit(&context->is_tree, bad_off2)) ? Vcb->superblock.node_size :
Vcb->superblock.sector_size;
uint8_t gyx, gx, denom, a, b, *p, *q, *pxy, *qxy;
@@ -2837,7 +2838,7 @@ static NTSTATUS scrub_chunk_raid56(device_extension* Vcb, chunk* c,
uint64_t* of
KEY searchkey;
traverse_ptr tp;
bool b;
- uint64_t full_stripe_len, stripe, stripe_start, stripe_end, total_data = 0;
+ uint64_t full_stripe_len, stripe, stripe_start = 0, stripe_end = 0, total_data = 0;
ULONG num_extents = 0, num_parity_stripes = c->chunk_item->type &
BLOCK_FLAG_RAID6 ? 2 : 1;
full_stripe_len = (c->chunk_item->num_stripes - num_parity_stripes) *
c->chunk_item->stripe_length;
@@ -2925,7 +2926,7 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c,
uint64_t* offset, b
traverse_ptr tp;
bool b = false, tree_run = false;
ULONG type, num_extents = 0;
- uint64_t total_data = 0, tree_run_start, tree_run_end;
+ uint64_t total_data = 0, tree_run_start = 0, tree_run_end = 0;
TRACE("chunk %I64x\n", c->offset);
diff --git a/drivers/filesystems/btrfs/security.c b/drivers/filesystems/btrfs/security.c
index f6769d05606..2761c63a915 100644
--- a/drivers/filesystems/btrfs/security.c
+++ b/drivers/filesystems/btrfs/security.c
@@ -678,7 +678,7 @@ NTSTATUS __stdcall drv_query_security(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Ir
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_query_security(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
@@ -842,7 +842,7 @@ NTSTATUS __stdcall drv_set_security(IN PDEVICE_OBJECT DeviceObject, IN
PIRP Irp)
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
- Status = vol_set_security(DeviceObject, Irp);
+ Status = STATUS_INVALID_DEVICE_REQUEST;
goto end;
} else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
Status = STATUS_INVALID_PARAMETER;
diff --git a/drivers/filesystems/btrfs/volume.c b/drivers/filesystems/btrfs/volume.c
index e89b6154d31..3ee63ed29f6 100644
--- a/drivers/filesystems/btrfs/volume.c
+++ b/drivers/filesystems/btrfs/volume.c
@@ -303,74 +303,6 @@ end:
return Status;
}
-NTSTATUS vol_query_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_flush_buffers(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_SUCCESS;
-}
-
-NTSTATUS vol_query_volume_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_set_volume_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_cleanup(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- Irp->IoStatus.Information = 0;
-
- return STATUS_SUCCESS;
-}
-
-NTSTATUS vol_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_file_system_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_lock_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
static NTSTATUS vol_query_device_name(volume_device_extension* vde, PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PMOUNTDEV_NAME name;
@@ -877,17 +809,15 @@ NTSTATUS vol_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP
Irp) {
return vol_get_disk_extents(vde, Irp);
default: { // pass ioctl through if only one child device
- ULONG code = IrpSp->Parameters.DeviceIoControl.IoControlCode;
NTSTATUS Status = vol_ioctl_passthrough(vde, Irp);
-
-#ifdef __REACTOS__
- &code;
-#endif
+#ifdef _DEBUG
+ ULONG code = IrpSp->Parameters.DeviceIoControl.IoControlCode;
if (NT_SUCCESS(Status))
TRACE("passing through ioctl %lx (returning %08lx)\n", code,
Status);
else
WARN("passing through ioctl %lx (returning %08lx)\n", code,
Status);
+#endif
return Status;
}
@@ -896,24 +826,6 @@ NTSTATUS vol_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP
Irp) {
return STATUS_INVALID_DEVICE_REQUEST;
}
-NTSTATUS vol_shutdown(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
-NTSTATUS vol_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
- TRACE("(%p, %p)\n", DeviceObject, Irp);
-
- return STATUS_INVALID_DEVICE_REQUEST;
-}
-
NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
NTSTATUS Status;
ULONG mmdltsize;
diff --git a/drivers/filesystems/btrfs/write.c b/drivers/filesystems/btrfs/write.c
index b73c17d689c..e8e354280c3 100644
--- a/drivers/filesystems/btrfs/write.c
+++ b/drivers/filesystems/btrfs/write.c
@@ -552,9 +552,7 @@ NTSTATUS alloc_chunk(device_extension* Vcb, uint64_t flags, chunk**
pc, bool ful
}
}
- if (type == 0 || type == BLOCK_FLAG_DUPLICATE || type == BLOCK_FLAG_RAID1 || type ==
BLOCK_FLAG_RAID1C3 || type == BLOCK_FLAG_RAID1C4)
- factor = 1;
- else if (type == BLOCK_FLAG_RAID0)
+ if (type == BLOCK_FLAG_RAID0)
factor = num_stripes;
else if (type == BLOCK_FLAG_RAID10)
factor = num_stripes / sub_stripes;
@@ -562,6 +560,8 @@ NTSTATUS alloc_chunk(device_extension* Vcb, uint64_t flags, chunk**
pc, bool ful
factor = num_stripes - 1;
else if (type == BLOCK_FLAG_RAID6)
factor = num_stripes - 2;
+ else
+ factor = 1; // SINGLE, DUPLICATE, RAID1, RAID1C3, RAID1C4
if (stripe_size * factor > max_chunk_size)
stripe_size = max_chunk_size / factor;
diff --git a/drivers/filesystems/btrfs/xor.S b/drivers/filesystems/btrfs/xor.S
new file mode 100644
index 00000000000..0a2b7e21580
--- /dev/null
+++ b/drivers/filesystems/btrfs/xor.S
@@ -0,0 +1,342 @@
+/* Copyright (c) Mark Harmstone 2020
+ *
+ * This file is part of WinBtrfs.
+ *
+ * WinBtrfs is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public Licence as published by
+ * the Free Software Foundation, either version 3 of the Licence, or
+ * (at your option) any later version.
+ *
+ * WinBtrfs is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public Licence for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public Licence
+ * along with WinBtrfs. If not, see <http://www.gnu.org/licenses/>. */
+
+#include <asm.inc>
+
+#ifdef __x86_64__
+
+.code64
+
+/* void do_xor_sse2(uint8_t* buf1, uint8_t* buf2, uint32_t len); */
+PUBLIC do_xor_sse2
+do_xor_sse2:
+ /* rcx = buf1
+ * rdx = buf2
+ * r8d = len
+ * rax = tmp1
+ * r9 = tmp2
+ * xmm0 = tmp3
+ * xmm1 = tmp4 */
+
+ mov rax, rcx
+ and rax, 15
+ cmp rax, 0
+ jne stragglers2
+
+ mov rax, rdx
+ and rax, 15
+ cmp rax, 0
+ jne stragglers2
+
+do_xor_sse2_loop:
+ cmp r8d, 16
+ jl stragglers2
+
+ movdqa xmm0, [rcx]
+ movdqa xmm1, [rdx]
+ pxor xmm0, xmm1
+ movdqa [rcx], xmm0
+
+ add rcx, 16
+ add rdx, 16
+ sub r8d, 16
+
+ jmp do_xor_sse2_loop
+
+stragglers2:
+
+ cmp r8d, 8
+ jl stragglers
+
+ mov rax, [rcx]
+ mov r9, [rdx]
+ xor rax, r9
+ mov [rcx], rax
+
+ add rcx, 8
+ add rdx, 8
+ sub r8d, 8
+
+ jmp stragglers2
+
+stragglers:
+
+ cmp r8d, 0
+ je do_xor_sse2_end
+
+ mov al, [rcx]
+ mov r9b, [rdx]
+ xor al, r9b
+ mov [rcx], al
+
+ inc rcx
+ inc rdx
+ dec r8d
+
+ jmp stragglers
+
+do_xor_sse2_end:
+ ret
+
+/* void do_xor_avx2(uint8_t* buf1, uint8_t* buf2, uint32_t len); */
+PUBLIC do_xor_avx2
+do_xor_avx2:
+ /* rcx = buf1
+ * rdx = buf2
+ * r8d = len
+ * rax = tmp1
+ * r9 = tmp2
+ * xmm0 = tmp3
+ * xmm1 = tmp4 */
+
+ mov rax, rcx
+ and rax, 31
+ cmp rax, 0
+ jne stragglers4
+
+ mov rax, rdx
+ and rax, 31
+ cmp rax, 0
+ jne stragglers4
+
+do_xor_avx2_loop:
+ cmp r8d, 32
+ jl stragglers4
+
+ vmovdqa ymm0, YMMWORD PTR[rcx]
+ vmovdqa ymm1, YMMWORD PTR[rdx]
+ vpxor ymm0, ymm0, ymm1
+ vmovdqa YMMWORD PTR[rcx], ymm0
+
+ add rcx, 32
+ add rdx, 32
+ sub r8d, 32
+
+ jmp do_xor_avx2_loop
+
+stragglers4:
+
+ cmp r8d, 8
+ jl stragglers3
+
+ mov rax, [rcx]
+ mov r9, [rdx]
+ xor rax, r9
+ mov [rcx], rax
+
+ add rcx, 8
+ add rdx, 8
+ sub r8d, 8
+
+ jmp stragglers4
+
+stragglers3:
+
+ cmp r8d, 0
+ je do_xor_avx2_end
+
+ mov al, [rcx]
+ mov r9b, [rdx]
+ xor al, r9b
+ mov [rcx], al
+
+ inc rcx
+ inc rdx
+ dec r8d
+
+ jmp stragglers3
+
+do_xor_avx2_end:
+ ret
+END
+#else
+
+.code
+
+/* void __stdcall do_xor_sse2(uint8_t* buf1, uint8_t* buf2, uint32_t len); */
+PUBLIC _do_xor_sse2@12
+_do_xor_sse2@12:
+ /* edi = buf1
+ * edx = buf2
+ * esi = len
+ * eax = tmp1
+ * ecx = tmp2
+ * xmm0 = tmp3
+ * xmm1 = tmp4 */
+
+ push ebp
+ mov ebp, esp
+
+ push esi
+ push edi
+
+ mov edi, [ebp+8]
+ mov edx, [ebp+12]
+ mov esi, [ebp+16]
+
+ mov eax, edi
+ and eax, 15
+ cmp eax, 0
+ jne stragglers2
+
+ mov eax, edx
+ and eax, 15
+ cmp eax, 0
+ jne stragglers2
+
+do_xor_sse2_loop:
+ cmp esi, 16
+ jl stragglers2
+
+ movdqa xmm0, [edi]
+ movdqa xmm1, [edx]
+ pxor xmm0, xmm1
+ movdqa [edi], xmm0
+
+ add edi, 16
+ add edx, 16
+ sub esi, 16
+
+ jmp do_xor_sse2_loop
+
+stragglers2:
+
+ cmp esi, 4
+ jl stragglers
+
+ mov eax, [edi]
+ mov ecx, [edx]
+ xor eax, ecx
+ mov [edi], eax
+
+ add edi, 4
+ add edx, 4
+ sub esi, 4
+
+ jmp stragglers2
+
+stragglers:
+
+ cmp esi, 0
+ je do_xor_sse2_end
+
+ mov al, [edi]
+ mov cl, [edx]
+ xor al, cl
+ mov [edi], al
+
+ inc edi
+ inc edx
+ dec esi
+
+ jmp stragglers
+
+do_xor_sse2_end:
+ pop edi
+ pop esi
+ pop ebp
+
+ ret 12
+
+/* void __stdcall do_xor_avx2(uint8_t* buf1, uint8_t* buf2, uint32_t len); */
+PUBLIC _do_xor_avx2@12
+_do_xor_avx2@12:
+ /* edi = buf1
+ * edx = buf2
+ * esi = len
+ * eax = tmp1
+ * ecx = tmp2
+ * xmm0 = tmp3
+ * xmm1 = tmp4 */
+
+ push ebp
+ mov ebp, esp
+
+ push esi
+ push edi
+
+ mov edi, [ebp+8]
+ mov edx, [ebp+12]
+ mov esi, [ebp+16]
+
+ mov eax, edi
+ and eax, 31
+ cmp eax, 0
+ jne stragglers4
+
+ mov eax, edx
+ and eax, 31
+ cmp eax, 0
+ jne stragglers4
+
+do_xor_avx2_loop:
+ cmp esi, 32
+ jl stragglers4
+
+ vmovdqa ymm0, YMMWORD PTR[edi]
+ vmovdqa ymm1, YMMWORD PTR[edx]
+ vpxor ymm0, ymm0, ymm1
+ vmovdqa YMMWORD PTR[edi], ymm0
+
+ add edi, 32
+ add edx, 32
+ sub esi, 32
+
+ jmp do_xor_avx2_loop
+
+stragglers4:
+
+ cmp esi, 4
+ jl stragglers3
+
+ mov eax, [edi]
+ mov ecx, [edx]
+ xor eax, ecx
+ mov [edi], eax
+
+ add edi, 4
+ add edx, 4
+ sub esi, 4
+
+ jmp stragglers4
+
+stragglers3:
+
+ cmp esi, 0
+ je do_xor_avx2_end
+
+ mov al, [edi]
+ mov cl, [edx]
+ xor al, cl
+ mov [edi], al
+
+ inc edi
+ inc edx
+ dec esi
+
+ jmp stragglers3
+
+do_xor_avx2_end:
+ pop edi
+ pop esi
+ pop ebp
+
+ ret 12
+
+END
+
+#endif
diff --git a/drivers/filesystems/btrfs/zstd/bitstream.h
b/drivers/filesystems/btrfs/zstd/bitstream.h
index ef89b9878e2..37b99c01eed 100644
--- a/drivers/filesystems/btrfs/zstd/bitstream.h
+++ b/drivers/filesystems/btrfs/zstd/bitstream.h
@@ -1,35 +1,15 @@
/* ******************************************************************
- bitstream
- Part of FSE library
- Copyright (C) 2013-present, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * bitstream
+ * Part of FSE library
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
#ifndef BITSTREAM_H_MODULE
#define BITSTREAM_H_MODULE
@@ -48,6 +28,7 @@ extern "C" {
* Dependencies
******************************************/
#include "mem.h" /* unaligned access routines */
+#include "compiler.h" /* UNLIKELY() */
#include "debug.h" /* assert(), DEBUGLOG(), RAWLOG() */
#include "error_private.h" /* error codes and messages */
@@ -57,6 +38,8 @@ extern "C" {
=========================================*/
#if defined(__BMI__) && defined(__GNUC__)
# include <immintrin.h> /* support for bextr (experimental) */
+#elif defined(__ICCARM__)
+# include <intrinsics.h>
#endif
#define STREAM_ACCUMULATOR_MIN_32 25
@@ -159,10 +142,11 @@ MEM_STATIC unsigned BIT_highbit32 (U32 val)
{
# if defined(_MSC_VER) /* Visual */
unsigned long r=0;
- _BitScanReverse ( &r, val );
- return (unsigned) r;
+ return _BitScanReverse ( &r, val ) ? (unsigned)r : 0;
# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */
- return 31 - __builtin_clz (val);
+ return __builtin_clz (val) ^ 31;
+# elif defined(__ICCARM__) /* IAR Intrinsic */
+ return 31 - __CLZ(val);
# else /* Software version */
static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29,
11, 14, 16, 18, 22, 25, 3, 30,
@@ -240,9 +224,9 @@ MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
{
size_t const nbBytes = bitC->bitPos >> 3;
assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
+ assert(bitC->ptr <= bitC->endPtr);
MEM_writeLEST(bitC->ptr, bitC->bitContainer);
bitC->ptr += nbBytes;
- assert(bitC->ptr <= bitC->endPtr);
bitC->bitPos &= 7;
bitC->bitContainer >>= nbBytes*8;
}
@@ -256,6 +240,7 @@ MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
{
size_t const nbBytes = bitC->bitPos >> 3;
assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
+ assert(bitC->ptr <= bitC->endPtr);
MEM_writeLEST(bitC->ptr, bitC->bitContainer);
bitC->ptr += nbBytes;
if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
@@ -389,7 +374,7 @@ MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
* Read (consume) next n bits from local register and update.
* Pay attention to not read more than nbBits contained into local register.
* @return : extracted value. */
-MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
{
size_t const value = BIT_lookBits(bitD, nbBits);
BIT_skipBits(bitD, nbBits);
@@ -398,7 +383,7 @@ MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
/*! BIT_readBitsFast() :
* unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
{
size_t const value = BIT_lookBitsFast(bitD, nbBits);
assert(nbBits >= 1);
@@ -406,6 +391,23 @@ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
return value;
}
+/*! BIT_reloadDStreamFast() :
+ * Similar to BIT_reloadDStream(), but with two differences:
+ * 1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
+ * 2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
+ * point you must use BIT_reloadDStream() to reload.
+ */
+MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
+{
+ if (UNLIKELY(bitD->ptr < bitD->limitPtr))
+ return BIT_DStream_overflow;
+ assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
+ bitD->ptr -= bitD->bitsConsumed >> 3;
+ bitD->bitsConsumed &= 7;
+ bitD->bitContainer = MEM_readLEST(bitD->ptr);
+ return BIT_DStream_unfinished;
+}
+
/*! BIT_reloadDStream() :
* Refill `bitD` from buffer previously set in BIT_initDStream() .
* This function is safe, it guarantees it will not read beyond src buffer.
@@ -417,10 +419,7 @@ MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
return BIT_DStream_overflow;
if (bitD->ptr >= bitD->limitPtr) {
- bitD->ptr -= bitD->bitsConsumed >> 3;
- bitD->bitsConsumed &= 7;
- bitD->bitContainer = MEM_readLEST(bitD->ptr);
- return BIT_DStream_unfinished;
+ return BIT_reloadDStreamFast(bitD);
}
if (bitD->ptr == bitD->start) {
if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return
BIT_DStream_endOfBuffer;
diff --git a/drivers/filesystems/btrfs/zstd/compiler.h
b/drivers/filesystems/btrfs/zstd/compiler.h
index 07f875e4d38..95e9483521d 100644
--- a/drivers/filesystems/btrfs/zstd/compiler.h
+++ b/drivers/filesystems/btrfs/zstd/compiler.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under both the BSD-style license (found in the
@@ -15,13 +15,15 @@
* Compiler specifics
*********************************************************/
/* force inlining */
-#if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) &&
__STDC_VERSION__ >= 199901L /* C99 */
+
+#if !defined(ZSTD_NO_INLINE)
+#if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) || defined(__cplusplus) ||
defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */
# define INLINE_KEYWORD inline
#else
# define INLINE_KEYWORD
#endif
-#if defined(__GNUC__)
+#if defined(__GNUC__) || defined(__ICCARM__)
# define FORCE_INLINE_ATTR __attribute__((always_inline))
#elif defined(_MSC_VER)
# define FORCE_INLINE_ATTR __forceinline
@@ -29,9 +31,16 @@
# define FORCE_INLINE_ATTR
#endif
+#else
+
+#define INLINE_KEYWORD
+#define FORCE_INLINE_ATTR
+
+#endif
+
/**
* FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant
- * parameters. They must be inlined for the compiler to elimininate the constant
+ * parameters. They must be inlined for the compiler to eliminate the constant
* branches.
*/
#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
@@ -52,11 +61,18 @@
# define HINT_INLINE static INLINE_KEYWORD FORCE_INLINE_ATTR
#endif
+/* UNUSED_ATTR tells the compiler it is okay if the function is unused. */
+#if defined(__GNUC__)
+# define UNUSED_ATTR __attribute__((unused))
+#else
+# define UNUSED_ATTR
+#endif
+
/* force no inlining */
#ifdef _MSC_VER
# define FORCE_NOINLINE static __declspec(noinline)
#else
-# ifdef __GNUC__
+# if defined(__GNUC__) || defined(__ICCARM__)
# define FORCE_NOINLINE static __attribute__((__noinline__))
# else
# define FORCE_NOINLINE static
@@ -67,7 +83,7 @@
#ifndef __has_attribute
#define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
#endif
-#if defined(__GNUC__)
+#if defined(__GNUC__) || defined(__ICCARM__)
# define TARGET_ATTRIBUTE(target) __attribute__((__target__(target)))
#else
# define TARGET_ATTRIBUTE(target)
@@ -89,23 +105,24 @@
#endif
/* prefetch
- * can be disabled, by declaring NO_PREFETCH macro
- * All prefetch invocations use a single default locality 2,
- * generating instruction prefetcht1,
- * which, according to Intel, means "load data into L2 cache".
- * This is a good enough "middle ground" for the time being,
- * though in theory, it would be better to specialize locality depending on data being
prefetched.
- * Tests could not determine any sensible difference based on locality value. */
+ * can be disabled, by declaring NO_PREFETCH build macro */
#if defined(NO_PREFETCH)
-# define PREFETCH(ptr) (void)(ptr) /* disabled */
+# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */
+# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */
#else
# if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) /*
_mm_prefetch() is not defined outside of x86/x64 */
# include <mmintrin.h> /*
https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
-# define PREFETCH(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T1)
+# define PREFETCH_L1(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0)
+# define PREFETCH_L2(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T1)
+# elif defined(__aarch64__)
+# define PREFETCH_L1(ptr) __asm__ __volatile__("prfm pldl1keep, %0"
::"Q"(*(ptr)))
+# define PREFETCH_L2(ptr) __asm__ __volatile__("prfm pldl2keep, %0"
::"Q"(*(ptr)))
# elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) &&
(__GNUC_MINOR__ >= 1) ) )
-# define PREFETCH(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality
*/)
+# define PREFETCH_L1(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality
*/)
+# define PREFETCH_L2(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality
*/)
# else
-# define PREFETCH(ptr) (void)(ptr) /* disabled */
+# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */
+# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */
# endif
#endif /* NO_PREFETCH */
@@ -116,10 +133,35 @@
size_t const _size = (size_t)(s); \
size_t _pos; \
for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) { \
- PREFETCH(_ptr + _pos); \
+ PREFETCH_L2(_ptr + _pos); \
} \
}
+/* vectorization
+ * older GCC (pre gcc-4.3 picked as the cutoff) uses a different syntax */
+#if !defined(__INTEL_COMPILER) && !defined(__clang__) &&
defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ > 3) || (__GNUC__ >= 5)
+# define DONT_VECTORIZE __attribute__((optimize("no-tree-vectorize")))
+# else
+# define DONT_VECTORIZE _Pragma("GCC
optimize(\"no-tree-vectorize\")")
+# endif
+#else
+# define DONT_VECTORIZE
+#endif
+
+/* Tell the compiler that a branch is likely or unlikely.
+ * Only use these macros if it causes the compiler to generate better code.
+ * If you can remove a LIKELY/UNLIKELY annotation without speed changes in gcc
+ * and clang, please do.
+ */
+#if defined(__GNUC__)
+#define LIKELY(x) (__builtin_expect((x), 1))
+#define UNLIKELY(x) (__builtin_expect((x), 0))
+#else
+#define LIKELY(x) (x)
+#define UNLIKELY(x) (x)
+#endif
+
/* disable warnings */
#ifdef _MSC_VER /* Visual Studio */
# include <intrin.h> /* For Visual 2005 */
diff --git a/drivers/filesystems/btrfs/zstd/cpu.h b/drivers/filesystems/btrfs/zstd/cpu.h
index eeb428ad5f6..6e8a974f62d 100644
--- a/drivers/filesystems/btrfs/zstd/cpu.h
+++ b/drivers/filesystems/btrfs/zstd/cpu.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018-present, Facebook, Inc.
+ * Copyright (c) 2018-2020, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under both the BSD-style license (found in the
@@ -78,7 +78,7 @@ MEM_STATIC ZSTD_cpuid_t ZSTD_cpuid(void) {
__asm__(
"pushl %%ebx\n\t"
"cpuid\n\t"
- "movl %%ebx, %%eax\n\r"
+ "movl %%ebx, %%eax\n\t"
"popl %%ebx"
: "=a"(f7b), "=c"(f7c)
: "a"(7), "c"(0)
diff --git a/drivers/filesystems/btrfs/zstd/debug.h
b/drivers/filesystems/btrfs/zstd/debug.h
index 0c04ad2cc98..ac6224888d8 100644
--- a/drivers/filesystems/btrfs/zstd/debug.h
+++ b/drivers/filesystems/btrfs/zstd/debug.h
@@ -1,35 +1,15 @@
/* ******************************************************************
- debug
- Part of FSE library
- Copyright (C) 2013-present, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * debug
+ * Part of FSE library
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
@@ -57,9 +37,9 @@ extern "C" {
#endif
-/* static assert is triggered at compile time, leaving no runtime artefact,
- * but can only work with compile-time constants.
- * This variant can only be used inside a function. */
+/* static assert is triggered at compile time, leaving no runtime artefact.
+ * static assert only works with compile-time constants.
+ * Also, this variant can only be used inside a function. */
#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])
@@ -70,9 +50,19 @@ extern "C" {
# define DEBUGLEVEL 0
#endif
+
+/* DEBUGFILE can be defined externally,
+ * typically through compiler command line.
+ * note : currently useless.
+ * Value must be stderr or stdout */
+#ifndef DEBUGFILE
+# define DEBUGFILE stderr
+#endif
+
+
/* recommended values for DEBUGLEVEL :
- * 0 : no debug, all run-time functions disabled
- * 1 : no display, enables assert() only
+ * 0 : release mode, no debug, all run-time checks disabled
+ * 1 : enables assert() only, no display
* 2 : reserved, for currently active debug path
* 3 : events once per object lifetime (CCtx, CDict, etc.)
* 4 : events once per frame
@@ -81,7 +71,7 @@ extern "C" {
* 7+: events at every position (*very* verbose)
*
* It's generally inconvenient to output traces > 5.
- * In which case, it's possible to selectively enable higher verbosity levels
+ * In which case, it's possible to selectively trigger high verbosity levels
* by modifying g_debug_level.
*/
@@ -95,11 +85,12 @@ extern "C" {
#if (DEBUGLEVEL>=2)
# include <stdio.h>
-extern int g_debuglevel; /* here, this variable is only declared,
- it actually lives in debug.c,
- and is shared by the whole process.
- It's typically used to enable very verbose levels
- on selective conditions (such as position in src) */
+extern int g_debuglevel; /* the variable is only declared,
+ it actually lives in debug.c,
+ and is shared by the whole process.
+ It's not thread-safe.
+ It's useful when enabling very verbose levels
+ on selective conditions (such as position in src) */
# define RAWLOG(l, ...) { \
if (l<=g_debuglevel) { \
diff --git a/drivers/filesystems/btrfs/zstd/entropy_common.c
b/drivers/filesystems/btrfs/zstd/entropy_common.c
index b12944e1de9..9d3e4e8e36a 100644
--- a/drivers/filesystems/btrfs/zstd/entropy_common.c
+++ b/drivers/filesystems/btrfs/zstd/entropy_common.c
@@ -1,36 +1,16 @@
-/*
- Common functions of New Generation Entropy library
- Copyright (C) 2016, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
- - Public forum : https://groups.google.com/forum/#!forum/lz4c
-*************************************************************************** */
+/* ******************************************************************
+ * Common functions of New Generation Entropy library
+ * Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+****************************************************************** */
/* *************************************
* Dependencies
diff --git a/drivers/filesystems/btrfs/zstd/error_private.c
b/drivers/filesystems/btrfs/zstd/error_private.c
index d004ee636c6..cd437529c12 100644
--- a/drivers/filesystems/btrfs/zstd/error_private.c
+++ b/drivers/filesystems/btrfs/zstd/error_private.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under both the BSD-style license (found in the
@@ -14,6 +14,10 @@
const char* ERR_getErrorString(ERR_enum code)
{
+#ifdef ZSTD_STRIP_ERROR_STRINGS
+ (void)code;
+ return "Error strings stripped";
+#else
static const char* const notErrorCode = "Unspecified error code";
switch( code )
{
@@ -39,10 +43,13 @@ const char* ERR_getErrorString(ERR_enum code)
case PREFIX(dictionaryCreation_failed): return "Cannot create Dictionary from
provided samples";
case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
case PREFIX(srcSize_wrong): return "Src size is incorrect";
+ case PREFIX(dstBuffer_null): return "Operation on NULL destination
buffer";
/* following error codes are not stable and may be removed or changed in a future
version */
case PREFIX(frameIndex_tooLarge): return "Frame index is too large";
case PREFIX(seekableIO): return "An I/O error occurred when
reading/seeking";
+ case PREFIX(dstBuffer_wrong): return "Destination buffer is wrong";
case PREFIX(maxCode):
default: return notErrorCode;
}
+#endif
}
diff --git a/drivers/filesystems/btrfs/zstd/error_private.h
b/drivers/filesystems/btrfs/zstd/error_private.h
index 0d2fa7e34b0..982cf8e9fe6 100644
--- a/drivers/filesystems/btrfs/zstd/error_private.h
+++ b/drivers/filesystems/btrfs/zstd/error_private.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under both the BSD-style license (found in the
@@ -49,7 +49,7 @@ typedef ZSTD_ErrorCode ERR_enum;
/*-****************************************
* Error codes handling
******************************************/
-#undef ERROR /* reported already defined on VS 2015 (Rich Geldreich) */
+#undef ERROR /* already defined on Visual Studio */
#define ERROR(name) ZSTD_ERROR(name)
#define ZSTD_ERROR(name) ((size_t)-PREFIX(name))
@@ -57,6 +57,10 @@ ERR_STATIC unsigned ERR_isError(size_t code) { return (code >
ERROR(maxCode)); }
ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return
(ERR_enum)0; return (ERR_enum) (0-code); }
+/* check and forward error code */
+#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
+#define CHECK_F(f) { CHECK_V_F(_var_err__, f); }
+
/*-****************************************
* Error Strings
diff --git a/drivers/filesystems/btrfs/zstd/fse.h b/drivers/filesystems/btrfs/zstd/fse.h
index a5a6b6d4db7..ff54e70ea75 100644
--- a/drivers/filesystems/btrfs/zstd/fse.h
+++ b/drivers/filesystems/btrfs/zstd/fse.h
@@ -1,35 +1,15 @@
/* ******************************************************************
- FSE : Finite State Entropy codec
- Public Prototypes declaration
- Copyright (C) 2013-2016, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * FSE : Finite State Entropy codec
+ * Public Prototypes declaration
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
#if defined (__cplusplus)
@@ -308,7 +288,7 @@ If there is an error, the function will return an error code, which
can be teste
*******************************************/
/* FSE buffer bounds */
#define FSE_NCOUNTBOUND 512
-#define FSE_BLOCKBOUND(size) (size + (size>>7))
+#define FSE_BLOCKBOUND(size) (size + (size>>7) + 4 /* fse states */ +
sizeof(size_t) /* bitContainer */)
#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro
version, useful for static allocation */
/* It is possible to statically allocate FSE CTable/DTable as a table of
FSE_CTable/FSE_DTable using below macros */
@@ -358,7 +338,7 @@ size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void*
cSrc, size
typedef enum {
FSE_repeat_none, /**< Cannot use the previous table */
FSE_repeat_check, /**< Can use the previous table but it must be checked */
- FSE_repeat_valid /**< Can use the previous table and it is asumed to be valid */
+ FSE_repeat_valid /**< Can use the previous table and it is assumed to be valid */
} FSE_repeat;
/* *****************************************
@@ -512,7 +492,7 @@ MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const
FSE_CTable* ct)
const U32 tableLog = MEM_read16(ptr);
statePtr->value = (ptrdiff_t)1<<tableLog;
statePtr->stateTable = u16ptr+2;
- statePtr->symbolTT = ((const U32*)ct + 1 + (tableLog ? (1<<(tableLog-1)) :
1));
+ statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
statePtr->stateLog = tableLog;
}
@@ -531,7 +511,7 @@ MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const
FSE_CTable* ct, U3
}
}
-MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, U32
symbol)
+MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned
symbol)
{
FSE_symbolCompressionTransform const symbolTT = ((const
FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
const U16* const stateTable = (const U16*)(statePtr->stateTable);
diff --git a/drivers/filesystems/btrfs/zstd/fse_compress.c
b/drivers/filesystems/btrfs/zstd/fse_compress.c
index c84f1d87ec9..419ad23b090 100644
--- a/drivers/filesystems/btrfs/zstd/fse_compress.c
+++ b/drivers/filesystems/btrfs/zstd/fse_compress.c
@@ -1,35 +1,15 @@
/* ******************************************************************
- FSE : Finite State Entropy encoder
- Copyright (C) 2013-present, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
- - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ * FSE : Finite State Entropy encoder
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
/* **************************************************************
@@ -118,7 +98,7 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
/* symbol start positions */
{ U32 u;
cumul[0] = 0;
- for (u=1; u<=maxSymbolValue+1; u++) {
+ for (u=1; u <= maxSymbolValue+1; u++) {
if (normalizedCounter[u-1]==-1) { /* Low proba symbol */
cumul[u] = cumul[u-1] + 1;
tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1);
@@ -132,9 +112,9 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
{ U32 position = 0;
U32 symbol;
for (symbol=0; symbol<=maxSymbolValue; symbol++) {
- int nbOccurences;
+ int nbOccurrences;
int const freq = normalizedCounter[symbol];
- for (nbOccurences=0; nbOccurences<freq; nbOccurences++) {
+ for (nbOccurrences=0; nbOccurrences<freq; nbOccurrences++) {
tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
position = (position + step) & tableMask;
while (position > highThreshold)
@@ -194,17 +174,8 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned
maxSymbolValue, unsigned tableLog)
{
- FSE_FUNCTION_TYPE* tableSymbol = ExAllocatePoolWithTag(NonPagedPool,
sizeof(FSE_FUNCTION_TYPE) * FSE_MAX_TABLESIZE, FSEC_ALLOC_TAG);
- size_t ret;
-
- if (!tableSymbol)
- return 0;
-
- ret = FSE_buildCTable_wksp(ct, normalizedCounter, maxSymbolValue, tableLog,
tableSymbol, sizeof(FSE_FUNCTION_TYPE) * FSE_MAX_TABLESIZE);
-
- ExFreePool(tableSymbol);
-
- return ret;
+ FSE_FUNCTION_TYPE tableSymbol[FSE_MAX_TABLESIZE]; /* memset() is not necessary,
even if static analyzer complain about it */
+ return FSE_buildCTable_wksp(ct, normalizedCounter, maxSymbolValue, tableLog,
tableSymbol, sizeof(tableSymbol));
}
@@ -657,9 +628,6 @@ size_t FSE_compress_usingCTable (void* dst, size_t dstSize,
size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }
-#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
-#define CHECK_F(f) { CHECK_V_F(_var_err__, f); }
-
/* FSE_compress_wksp() :
* Same as FSE_compress2(), but using an externally allocated scratch buffer
(`workSpace`).
* `wkspSize` size must be `(1<<tableLog)`.
@@ -670,7 +638,7 @@ size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src,
size_t src
BYTE* op = ostart;
BYTE* const oend = ostart + dstSize;
- U32 count[FSE_MAX_SYMBOL_VALUE+1];
+ unsigned count[FSE_MAX_SYMBOL_VALUE+1];
S16 norm[FSE_MAX_SYMBOL_VALUE+1];
FSE_CTable* CTable = (FSE_CTable*)workSpace;
size_t const CTableSize = FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue);
@@ -684,7 +652,7 @@ size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src,
size_t src
if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG;
/* Scan input and build symbol stats */
- { CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize,
(unsigned*)scratchBuffer) );
+ { CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize,
scratchBuffer, scratchBufferSize) );
if (maxCount == srcSize) return 1; /* only a single symbol in src : rle */
if (maxCount == 1) return 0; /* each symbol present maximum once =>
not compressible */
if (maxCount < (srcSize >> 7)) return 0; /* Heuristic : not
compressible enough */
@@ -718,24 +686,10 @@ typedef struct {
size_t FSE_compress2 (void* dst, size_t dstCapacity, const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned tableLog)
{
- fseWkspMax_t* scratchBuffer;
- size_t ret;
-
- DEBUG_STATIC_ASSERT(sizeof(fseWkspMax_t) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG,
FSE_MAX_SYMBOL_VALUE)); /* compilation failures here means scratchBuffer is not large
enough */
-
- if (tableLog > FSE_MAX_TABLELOG)
- return ERROR(tableLog_tooLarge);
-
- scratchBuffer = ExAllocatePoolWithTag(NonPagedPool, sizeof(fseWkspMax_t),
FSEC_ALLOC_TAG);
-
- if (!scratchBuffer)
- return 0;
-
- ret = FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog,
scratchBuffer, sizeof(fseWkspMax_t));
-
- ExFreePool(scratchBuffer);
-
- return ret;
+ fseWkspMax_t scratchBuffer;
+ DEBUG_STATIC_ASSERT(sizeof(scratchBuffer) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG,
FSE_MAX_SYMBOL_VALUE)); /* compilation failures here means scratchBuffer is not large
enough */
+ if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+ return FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog,
&scratchBuffer, sizeof(scratchBuffer));
}
size_t FSE_compress (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
diff --git a/drivers/filesystems/btrfs/zstd/fse_decompress.c
b/drivers/filesystems/btrfs/zstd/fse_decompress.c
index 987813eb97e..aabf08abc69 100644
--- a/drivers/filesystems/btrfs/zstd/fse_decompress.c
+++ b/drivers/filesystems/btrfs/zstd/fse_decompress.c
@@ -1,35 +1,15 @@
/* ******************************************************************
- FSE : Finite State Entropy decoder
- Copyright (C) 2013-2015, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
- - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ * FSE : Finite State Entropy decoder
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
@@ -53,9 +33,6 @@
#define FSE_isError ERR_isError
#define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) /* use only *after* variable
declarations */
-/* check and forward error code */
-#define CHECK_F(f) { size_t const e = f; if (FSE_isError(e)) return e; }
-
/* **************************************************************
* Templates
@@ -81,7 +58,6 @@
#define FSED_ALLOC_TAG 0x64455346 // "FSEd"
-
/* Function templates */
FSE_DTable* FSE_createDTable (unsigned tableLog)
{
@@ -289,7 +265,7 @@ size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void*
cSrc, size
/* normal FSE decoding mode */
size_t const NCountLength = FSE_readNCount (counting, &maxSymbolValue,
&tableLog, istart, cSrcSize);
if (FSE_isError(NCountLength)) return NCountLength;
- //if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong); /* too small input
size; supposed to be already checked in NCountLength, only remaining case :
NCountLength==cSrcSize */
+ /* if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong); */ /* too small
input size; supposed to be already checked in NCountLength, only remaining case :
NCountLength==cSrcSize */
if (tableLog > maxLog) return ERROR(tableLog_tooLarge);
ip += NCountLength;
cSrcSize -= NCountLength;
diff --git a/drivers/filesystems/btrfs/zstd/hist.c
b/drivers/filesystems/btrfs/zstd/hist.c
index 714a27e8d07..c17b9725f0d 100644
--- a/drivers/filesystems/btrfs/zstd/hist.c
+++ b/drivers/filesystems/btrfs/zstd/hist.c
@@ -1,36 +1,16 @@
/* ******************************************************************
- hist : Histogram functions
- part of Finite State Entropy project
- Copyright (C) 2013-present, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
- - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ * hist : Histogram functions
+ * part of Finite State Entropy project
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
/* --- dependencies --- */
@@ -38,10 +18,7 @@
#include "debug.h" /* assert, DEBUGLOG */
#include "error_private.h" /* ERROR */
#include "hist.h"
-#include <ntifs.h>
-#include <ntddk.h>
-#define HIST_ALLOC_TAG 0x54534948 // "HIST"
/* --- Error management --- */
unsigned HIST_isError(size_t code) { return ERR_isError(code); }
@@ -76,6 +53,7 @@ unsigned HIST_count_simple(unsigned* count, unsigned*
maxSymbolValuePtr,
return largestCount;
}
+typedef enum { trustInput, checkMaxSymbolValue } HIST_checkInput_e;
/* HIST_count_parallel_wksp() :
* store histogram into 4 intermediate tables, recombined at the end.
@@ -88,8 +66,8 @@ unsigned HIST_count_simple(unsigned* count, unsigned*
maxSymbolValuePtr,
static size_t HIST_count_parallel_wksp(
unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize,
- unsigned checkMax,
- unsigned* const workSpace)
+ HIST_checkInput_e check,
+ U32* const workSpace)
{
const BYTE* ip = (const BYTE*)source;
const BYTE* const iend = ip+sourceSize;
@@ -140,7 +118,7 @@ static size_t HIST_count_parallel_wksp(
/* finish last symbols */
while (ip<iend) Counting1[*ip++]++;
- if (checkMax) { /* verify stats will fit into destination table */
+ if (check) { /* verify stats will fit into destination table */
U32 s; for (s=255; s>maxSymbolValue; s--) {
Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall);
@@ -160,48 +138,46 @@ static size_t HIST_count_parallel_wksp(
/* HIST_countFast_wksp() :
* Same as HIST_countFast(), but using an externally provided scratch buffer.
- * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */
+ * `workSpace` is a writable buffer which must be 4-bytes aligned,
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE
+ */
size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize,
- unsigned* workSpace)
+ void* workSpace, size_t workSpaceSize)
{
if (sourceSize < 1500) /* heuristic threshold */
return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize);
- return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 0,
workSpace);
+ if ((size_t)workSpace & 3) return ERROR(GENERIC); /* must be aligned on 4-bytes
boundaries */
+ if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
+ return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize,
trustInput, (U32*)workSpace);
}
/* fast variant (unsafe : won't check if src contains values beyond count[] limit)
*/
size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize)
{
- unsigned* tmpCounters = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) *
HIST_WKSP_SIZE_U32, HIST_ALLOC_TAG);
- size_t ret;
-
- if (!tmpCounters)
- return 0;
-
- ret = HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize,
tmpCounters);
-
- ExFreePool(tmpCounters);
-
- return ret;
+ unsigned tmpCounters[HIST_WKSP_SIZE_U32];
+ return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters,
sizeof(tmpCounters));
}
/* HIST_count_wksp() :
* Same as HIST_count(), but using an externally provided scratch buffer.
* `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */
size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
- const void* source, size_t sourceSize, unsigned* workSpace)
+ const void* source, size_t sourceSize,
+ void* workSpace, size_t workSpaceSize)
{
+ if ((size_t)workSpace & 3) return ERROR(GENERIC); /* must be aligned on 4-bytes
boundaries */
+ if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
if (*maxSymbolValuePtr < 255)
- return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 1,
workSpace);
+ return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize,
checkMaxSymbolValue, (U32*)workSpace);
*maxSymbolValuePtr = 255;
- return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace);
+ return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace,
workSpaceSize);
}
size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize)
{
unsigned tmpCounters[HIST_WKSP_SIZE_U32];
- return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters);
+ return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters,
sizeof(tmpCounters));
}
diff --git a/drivers/filesystems/btrfs/zstd/hist.h
b/drivers/filesystems/btrfs/zstd/hist.h
index 8b1991a90bd..77e3ec4fb19 100644
--- a/drivers/filesystems/btrfs/zstd/hist.h
+++ b/drivers/filesystems/btrfs/zstd/hist.h
@@ -1,36 +1,16 @@
/* ******************************************************************
- hist : Histogram functions
- part of Finite State Entropy project
- Copyright (C) 2013-present, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
- - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ * hist : Histogram functions
+ * part of Finite State Entropy project
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
/* --- dependencies --- */
@@ -41,11 +21,11 @@
/*! HIST_count():
* Provides the precise count of each byte within a table 'count'.
- * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).
+ * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).
* Updates *maxSymbolValuePtr with actual largest symbol value detected.
- * @return : count of the most frequent symbol (which isn't identified).
- * or an error code, which can be tested using HIST_isError().
- * note : if return == srcSize, there is only one symbol.
+ * @return : count of the most frequent symbol (which isn't identified).
+ * or an error code, which can be tested using HIST_isError().
+ * note : if return == srcSize, there is only one symbol.
*/
size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize);
@@ -56,14 +36,16 @@ unsigned HIST_isError(size_t code); /**< tells if a return value
is an error co
/* --- advanced histogram functions --- */
#define HIST_WKSP_SIZE_U32 1024
+#define HIST_WKSP_SIZE (HIST_WKSP_SIZE_U32 * sizeof(unsigned))
/** HIST_count_wksp() :
* Same as HIST_count(), but using an externally provided scratch buffer.
* Benefit is this function will use very little stack space.
- * `workSpace` must be a table of unsigned of size >= HIST_WKSP_SIZE_U32
+ * `workSpace` is a writable buffer which must be 4-bytes aligned,
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE
*/
size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize,
- unsigned* workSpace);
+ void* workSpace, size_t workSpaceSize);
/** HIST_countFast() :
* same as HIST_count(), but blindly trusts that all byte values within src are <=
*maxSymbolValuePtr.
@@ -74,11 +56,12 @@ size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
/** HIST_countFast_wksp() :
* Same as HIST_countFast(), but using an externally provided scratch buffer.
- * `workSpace` must be a table of unsigned of size >= HIST_WKSP_SIZE_U32
+ * `workSpace` is a writable buffer which must be 4-bytes aligned,
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE
*/
size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize,
- unsigned* workSpace);
+ void* workSpace, size_t workSpaceSize);
/*! HIST_count_simple() :
* Same as HIST_countFast(), this function is unsafe,
diff --git a/drivers/filesystems/btrfs/zstd/huf.h b/drivers/filesystems/btrfs/zstd/huf.h
index dc84f7ab114..ef432685dac 100644
--- a/drivers/filesystems/btrfs/zstd/huf.h
+++ b/drivers/filesystems/btrfs/zstd/huf.h
@@ -1,35 +1,15 @@
/* ******************************************************************
- huff0 huffman codec,
- part of Finite State Entropy library
- Copyright (C) 2013-present, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * huff0 huffman codec,
+ * part of Finite State Entropy library
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
#if defined (__cplusplus)
@@ -110,7 +90,7 @@ HUF_PUBLIC_API size_t HUF_compress2 (void* dst, size_t dstCapacity,
/** HUF_compress4X_wksp() :
* Same as HUF_compress2(), but uses externally allocated `workSpace`.
* `workspace` must have minimum alignment of 4, and be at least as large as
HUF_WORKSPACE_SIZE */
-#define HUF_WORKSPACE_SIZE (6 << 10)
+#define HUF_WORKSPACE_SIZE ((6 << 10) + 256)
#define HUF_WORKSPACE_SIZE_U32 (HUF_WORKSPACE_SIZE / sizeof(U32))
HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
@@ -163,21 +143,29 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t
dstCapacity,
/* static allocation of HUF's DTable */
typedef U32 HUF_DTable;
#define HUF_DTABLE_SIZE(maxTableLog) (1 + (1<<(maxTableLog)))
+#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
+ HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) *
0x01000001) }
+#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+ HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) *
0x01000001) }
/* ****************************************
* Advanced decompression functions
******************************************/
size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
/**< single-symbol decoder */
+#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
/**< double-symbols decoder */
+#endif
size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void*
cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */
size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void*
cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const
void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< considers RLE and
uncompressed as errors */
size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void*
cSrc, size_t cSrcSize); /**< single-symbol decoder */
size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const
void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< single-symbol
decoder */
+#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void*
cSrc, size_t cSrcSize); /**< double-symbols decoder */
size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const
void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< double-symbols
decoder */
+#endif
/* ****************************************
@@ -200,6 +188,8 @@ typedef struct HUF_CElt_s HUF_CElt; /* incomplete type */
size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue,
unsigned maxNbBits); /* @return : maxNbBits; CTable and count can overlap. In which
case, CTable will overwrite count content */
size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned
maxSymbolValue, unsigned huffLog);
size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t
srcSize, const HUF_CElt* CTable);
+size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned
maxSymbolValue);
+int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned
maxSymbolValue);
typedef enum {
HUF_repeat_none, /**< Cannot use the previous table */
@@ -224,7 +214,7 @@ size_t HUF_compress4X_repeat(void* dst, size_t dstSize,
#define HUF_CTABLE_WORKSPACE_SIZE_U32 (2*HUF_SYMBOLVALUE_MAX +1 +1)
#define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned))
size_t HUF_buildCTable_wksp (HUF_CElt* tree,
- const U32* count, U32 maxSymbolValue, U32 maxNbBits,
+ const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
void* workSpace, size_t wkspSize);
/*! HUF_readStats() :
@@ -238,7 +228,7 @@ size_t HUF_readStats(BYTE* huffWeight, size_t hwSize,
/** HUF_readCTable() :
* Loading a CTable saved with HUF_writeCTable() */
-size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src,
size_t srcSize);
+size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src,
size_t srcSize, unsigned *hasZeroWeights);
/** HUF_getNbBits() :
* Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <=
HUF_SYMBOLVALUE_MAX
@@ -273,14 +263,22 @@ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);
#define HUF_DECOMPRESS_WORKSPACE_SIZE (2 << 10)
#define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))
+#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize);
size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void*
workSpace, size_t wkspSize);
+#endif
+#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize);
size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void*
workSpace, size_t wkspSize);
+#endif
size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc,
size_t cSrcSize, const HUF_DTable* DTable);
+#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc,
size_t cSrcSize, const HUF_DTable* DTable);
+#endif
+#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc,
size_t cSrcSize, const HUF_DTable* DTable);
+#endif
/* ====================== */
@@ -302,24 +300,36 @@ size_t HUF_compress1X_repeat(void* dst, size_t dstSize,
HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int
bmi2);
size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
/* single-symbol decoder */
+#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
/* double-symbol decoder */
+#endif
size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void*
cSrc, size_t cSrcSize);
size_t HUF_decompress1X_DCtx_wksp (HUF_DTable* dctx, void* dst, size_t dstSize, const
void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);
+#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress1X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void*
cSrc, size_t cSrcSize); /**< single-symbol decoder */
size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const
void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< single-symbol
decoder */
+#endif
+#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void*
cSrc, size_t cSrcSize); /**< double-symbols decoder */
size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const
void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< double-symbols
decoder */
+#endif
size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc,
size_t cSrcSize, const HUF_DTable* DTable); /**< automatic selection of sing or
double symbol decoder, based on DTable */
+#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc,
size_t cSrcSize, const HUF_DTable* DTable);
+#endif
+#ifndef HUF_FORCE_DECOMPRESS_X1
size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc,
size_t cSrcSize, const HUF_DTable* DTable);
+#endif
/* BMI2 variants.
* If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
*/
size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc,
size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
+#ifndef HUF_FORCE_DECOMPRESS_X2
size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2);
+#endif
size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc,
size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2);
diff --git a/drivers/filesystems/btrfs/zstd/huf_compress.c
b/drivers/filesystems/btrfs/zstd/huf_compress.c
index 1510fda2db9..4efffbb542a 100644
--- a/drivers/filesystems/btrfs/zstd/huf_compress.c
+++ b/drivers/filesystems/btrfs/zstd/huf_compress.c
@@ -1,35 +1,15 @@
/* ******************************************************************
- Huffman encoder, part of New Generation Entropy library
- Copyright (C) 2013-2016, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- You can contact the author at :
- - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
- - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ * Huffman encoder, part of New Generation Entropy library
+ * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ * - Public forum : https://groups.google.com/forum/#!forum/lz4c
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
****************************************************************** */
/* **************************************************************
@@ -53,10 +33,6 @@
#define HUF_STATIC_LINKING_ONLY
#include "huf.h"
#include "error_private.h"
-#include <ntifs.h>
-#include <ntddk.h>
-
-#define HUFC_ALLOC_TAG 0x63465548 // "HUFc"
/* **************************************************************
@@ -64,8 +40,6 @@
****************************************************************/
#define HUF_isError ERR_isError
#define HUF_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) /* use only *after* variable
declarations */
-#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
-#define CHECK_F(f) { CHECK_V_F(_var_err__, f); }
/* **************************************************************
@@ -92,13 +66,13 @@ static size_t HUF_compressWeights (void* dst, size_t dstSize, const
void* weight
BYTE* op = ostart;
BYTE* const oend = ostart + dstSize;
- U32 maxSymbolValue = HUF_TABLELOG_MAX;
+ unsigned maxSymbolValue = HUF_TABLELOG_MAX;
U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER;
FSE_CTable CTable[FSE_CTABLE_SIZE_U32(MAX_FSE_TABLELOG_FOR_HUFF_HEADER,
HUF_TABLELOG_MAX)];
BYTE scratchBuffer[1<<MAX_FSE_TABLELOG_FOR_HUFF_HEADER];
- U32 count[HUF_TABLELOG_MAX+1];
+ unsigned count[HUF_TABLELOG_MAX+1];
S16 norm[HUF_TABLELOG_MAX+1];
/* init conditions */
@@ -114,18 +88,18 @@ static size_t HUF_compressWeights (void* dst, size_t dstSize, const
void* weight
CHECK_F( FSE_normalizeCount(norm, tableLog, count, wtSize, maxSymbolValue) );
/* Write table description header */
- { CHECK_V_F(hSize, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) );
+ { CHECK_V_F(hSize, FSE_writeNCount(op, (size_t)(oend-op), norm, maxSymbolValue,
tableLog) );
op += hSize;
}
/* Compress */
CHECK_F( FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer,
sizeof(scratchBuffer)) );
- { CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, weightTable, wtSize,
CTable) );
+ { CHECK_V_F(cSize, FSE_compress_usingCTable(op, (size_t)(oend - op), weightTable,
wtSize, CTable) );
if (cSize == 0) return 0; /* not enough space for compressed data */
op += cSize;
}
- return op-ostart;
+ return (size_t)(op-ostart);
}
@@ -138,7 +112,7 @@ struct HUF_CElt_s {
`CTable` : Huffman tree to save, using huf representation.
@return : size of saved CTable */
size_t HUF_writeCTable (void* dst, size_t maxDstSize,
- const HUF_CElt* CTable, U32 maxSymbolValue, U32 huffLog)
+ const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned
huffLog)
{
BYTE bitsToWeight[HUF_TABLELOG_MAX + 1]; /* precomputed conversion table */
BYTE huffWeight[HUF_SYMBOLVALUE_MAX];
@@ -173,7 +147,7 @@ size_t HUF_writeCTable (void* dst, size_t maxDstSize,
}
-size_t HUF_readCTable (HUF_CElt* CTable, U32* maxSymbolValuePtr, const void* src, size_t
srcSize)
+size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src,
size_t srcSize, unsigned* hasZeroWeights)
{
BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1]; /* init not required, even though some
static analyzer may complain */
U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1]; /* large enough for values from 0 to 16
*/
@@ -196,9 +170,11 @@ size_t HUF_readCTable (HUF_CElt* CTable, U32* maxSymbolValuePtr,
const void* src
} }
/* fill nbBits */
+ *hasZeroWeights = 0;
{ U32 n; for (n=0; n<nbSymbols; n++) {
const U32 w = huffWeight[n];
- CTable[n].nbBits = (BYTE)(tableLog + 1 - w);
+ *hasZeroWeights |= (w == 0);
+ CTable[n].nbBits = (BYTE)(tableLog + 1 - w) & -(w != 0);
} }
/* fill val */
@@ -244,7 +220,7 @@ static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32
maxNbBits)
/* there are several too large elements (at least >= 2) */
{ int totalCost = 0;
const U32 baseCost = 1 << (largestBits - maxNbBits);
- U32 n = lastNonNull;
+ int n = (int)lastNonNull;
while (huffNode[n].nbBits > maxNbBits) {
totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits));
@@ -259,22 +235,22 @@ static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32
maxNbBits)
/* repay normalized cost */
{ U32 const noSymbol = 0xF0F0F0F0;
U32 rankLast[HUF_TABLELOG_MAX+2];
- int pos;
/* Get pos of last (smallest) symbol per rank */
memset(rankLast, 0xF0, sizeof(rankLast));
{ U32 currentNbBits = maxNbBits;
+ int pos;
for (pos=n ; pos >= 0; pos--) {
if (huffNode[pos].nbBits >= currentNbBits) continue;
currentNbBits = huffNode[pos].nbBits; /* < maxNbBits */
- rankLast[maxNbBits-currentNbBits] = pos;
+ rankLast[maxNbBits-currentNbBits] = (U32)pos;
} }
while (totalCost > 0) {
- U32 nBitsToDecrease = BIT_highbit32(totalCost) + 1;
+ U32 nBitsToDecrease = BIT_highbit32((U32)totalCost) + 1;
for ( ; nBitsToDecrease > 1; nBitsToDecrease--) {
- U32 highPos = rankLast[nBitsToDecrease];
- U32 lowPos = rankLast[nBitsToDecrease-1];
+ U32 const highPos = rankLast[nBitsToDecrease];
+ U32 const lowPos = rankLast[nBitsToDecrease-1];
if (highPos == noSymbol) continue;
if (lowPos == noSymbol) break;
{ U32 const highTotal = huffNode[highPos].count;
@@ -301,7 +277,8 @@ static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32
maxNbBits)
if (rankLast[1] == noSymbol) { /* special case : no rank 1 symbol (using
maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */
while (huffNode[n].nbBits == maxNbBits) n--;
huffNode[n+1].nbBits--;
- rankLast[1] = n+1;
+ assert(n >= 0);
+ rankLast[1] = (U32)(n+1);
totalCost++;
continue;
}
@@ -313,29 +290,36 @@ static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32
maxNbBits)
return maxNbBits;
}
-
typedef struct {
U32 base;
U32 current;
} rankPos;
-static void HUF_sort(nodeElt* huffNode, const U32* count, U32 maxSymbolValue)
+typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32];
+
+#define RANK_POSITION_TABLE_SIZE 32
+
+typedef struct {
+ huffNodeTable huffNodeTbl;
+ rankPos rankPosition[RANK_POSITION_TABLE_SIZE];
+} HUF_buildCTable_wksp_tables;
+
+static void HUF_sort(nodeElt* huffNode, const unsigned* count, U32 maxSymbolValue,
rankPos* rankPosition)
{
- rankPos rank[32];
U32 n;
- memset(rank, 0, sizeof(rank));
+ memset(rankPosition, 0, sizeof(*rankPosition) * RANK_POSITION_TABLE_SIZE);
for (n=0; n<=maxSymbolValue; n++) {
U32 r = BIT_highbit32(count[n] + 1);
- rank[r].base ++;
+ rankPosition[r].base ++;
}
- for (n=30; n>0; n--) rank[n-1].base += rank[n].base;
- for (n=0; n<32; n++) rank[n].current = rank[n].base;
+ for (n=30; n>0; n--) rankPosition[n-1].base += rankPosition[n].base;
+ for (n=0; n<32; n++) rankPosition[n].current = rankPosition[n].base;
for (n=0; n<=maxSymbolValue; n++) {
U32 const c = count[n];
U32 const r = BIT_highbit32(c+1) + 1;
- U32 pos = rank[r].current++;
- while ((pos > rank[r].base) && (c > huffNode[pos-1].count)) {
+ U32 pos = rankPosition[r].current++;
+ while ((pos > rankPosition[r].base) && (c > huffNode[pos-1].count))
{
huffNode[pos] = huffNode[pos-1];
pos--;
}
@@ -347,45 +331,48 @@ static void HUF_sort(nodeElt* huffNode, const U32* count, U32
maxSymbolValue)
/** HUF_buildCTable_wksp() :
* Same as HUF_buildCTable(), but using externally allocated scratch buffer.
- * `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as a
table of HUF_CTABLE_WORKSPACE_SIZE_U32 unsigned.
+ * `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as
sizeof(HUF_buildCTable_wksp_tables).
*/
#define STARTNODE (HUF_SYMBOLVALUE_MAX+1)
-typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32];
-size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32
maxNbBits, void* workSpace, size_t wkspSize)
+
+size_t HUF_buildCTable_wksp (HUF_CElt* tree, const unsigned* count, U32 maxSymbolValue,
U32 maxNbBits, void* workSpace, size_t wkspSize)
{
- nodeElt* const huffNode0 = (nodeElt*)workSpace;
+ HUF_buildCTable_wksp_tables* const wksp_tables =
(HUF_buildCTable_wksp_tables*)workSpace;
+ nodeElt* const huffNode0 = wksp_tables->huffNodeTbl;
nodeElt* const huffNode = huffNode0+1;
- U32 n, nonNullRank;
+ int nonNullRank;
int lowS, lowN;
- U16 nodeNb = STARTNODE;
- U32 nodeRoot;
+ int nodeNb = STARTNODE;
+ int n, nodeRoot;
/* safety checks */
if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC); /* must be aligned on
4-bytes boundaries */
- if (wkspSize < sizeof(huffNodeTable)) return ERROR(workSpace_tooSmall);
+ if (wkspSize < sizeof(HUF_buildCTable_wksp_tables))
+ return ERROR(workSpace_tooSmall);
if (maxNbBits == 0) maxNbBits = HUF_TABLELOG_DEFAULT;
- if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
+ if (maxSymbolValue > HUF_SYMBOLVALUE_MAX)
+ return ERROR(maxSymbolValue_tooLarge);
memset(huffNode0, 0, sizeof(huffNodeTable));
/* sort, decreasing order */
- HUF_sort(huffNode, count, maxSymbolValue);
+ HUF_sort(huffNode, count, maxSymbolValue, wksp_tables->rankPosition);
/* init for parents */
- nonNullRank = maxSymbolValue;
+ nonNullRank = (int)maxSymbolValue;
while(huffNode[nonNullRank].count == 0) nonNullRank--;
lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb;
huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count;
- huffNode[lowS].parent = huffNode[lowS-1].parent = nodeNb;
+ huffNode[lowS].parent = huffNode[lowS-1].parent = (U16)nodeNb;
nodeNb++; lowS-=2;
for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30);
huffNode0[0].count = (U32)(1U<<31); /* fake entry, strong barrier */
/* create parents */
while (nodeNb <= nodeRoot) {
- U32 n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
- U32 n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
+ int const n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- :
lowN++;
+ int const n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- :
lowN++;
huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count;
- huffNode[n1].parent = huffNode[n2].parent = nodeNb;
+ huffNode[n1].parent = huffNode[n2].parent = (U16)nodeNb;
nodeNb++;
}
@@ -397,24 +384,25 @@ size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32
maxSymbolValu
huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;
/* enforce maxTableLog */
- maxNbBits = HUF_setMaxHeight(huffNode, nonNullRank, maxNbBits);
+ maxNbBits = HUF_setMaxHeight(huffNode, (U32)nonNullRank, maxNbBits);
/* fill result into tree (val, nbBits) */
{ U16 nbPerRank[HUF_TABLELOG_MAX+1] = {0};
U16 valPerRank[HUF_TABLELOG_MAX+1] = {0};
+ int const alphabetSize = (int)(maxSymbolValue + 1);
if (maxNbBits > HUF_TABLELOG_MAX) return ERROR(GENERIC); /* check fit into
table */
for (n=0; n<=nonNullRank; n++)
nbPerRank[huffNode[n].nbBits]++;
/* determine stating value per rank */
{ U16 min = 0;
- for (n=maxNbBits; n>0; n--) {
+ for (n=(int)maxNbBits; n>0; n--) {
valPerRank[n] = min; /* get starting value within each rank */
min += nbPerRank[n];
min >>= 1;
} }
- for (n=0; n<=maxSymbolValue; n++)
+ for (n=0; n<alphabetSize; n++)
tree[huffNode[n].byte].nbBits = huffNode[n].nbBits; /* push nbBits per
symbol, symbol order */
- for (n=0; n<=maxSymbolValue; n++)
+ for (n=0; n<alphabetSize; n++)
tree[n].val = valPerRank[tree[n].nbBits]++; /* assign value within rank,
symbol order */
}
@@ -425,22 +413,13 @@ size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32
maxSymbolValu
* @return : maxNbBits
* Note : count is used before tree is written, so they can safely overlap
*/
-size_t HUF_buildCTable (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32
maxNbBits)
+size_t HUF_buildCTable (HUF_CElt* tree, const unsigned* count, unsigned maxSymbolValue,
unsigned maxNbBits)
{
- huffNodeTable* nodeTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(huffNodeTable),
HUFC_ALLOC_TAG);
- size_t ret;
-
- if (!nodeTable)
- return 0;
-
- ret = HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable,
sizeof(huffNodeTable));
-
- ExFreePool(nodeTable);
-
- return ret;
+ HUF_buildCTable_wksp_tables workspace;
+ return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, &workspace,
sizeof(workspace));
}
-static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count,
unsigned maxSymbolValue)
+size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned
maxSymbolValue)
{
size_t nbBits = 0;
int s;
@@ -450,7 +429,7 @@ static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const
unsigned* count
return nbBits >> 3;
}
-static int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned
maxSymbolValue) {
+int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned
maxSymbolValue) {
int bad = 0;
int s;
for (s = 0; s <= (int)maxSymbolValue; ++s) {
@@ -489,7 +468,7 @@ HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,
/* init */
if (dstSize < 8) return 0; /* not enough space to compress */
- { size_t const initErr = BIT_initCStream(&bitC, op, oend-op);
+ { size_t const initErr = BIT_initCStream(&bitC, op, (size_t)(oend-op));
if (HUF_isError(initErr)) return 0; }
n = srcSize & ~3; /* join to mod 4 */
@@ -586,7 +565,8 @@ HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
if (srcSize < 12) return 0; /* no saving possible : too small input */
op += 6; /* jumpTable */
- { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip,
segmentSize, CTable, bmi2) );
+ assert(op <= oend);
+ { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip,
segmentSize, CTable, bmi2) );
if (cSize==0) return 0;
assert(cSize <= 65535);
MEM_writeLE16(ostart, (U16)cSize);
@@ -594,7 +574,8 @@ HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
}
ip += segmentSize;
- { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip,
segmentSize, CTable, bmi2) );
+ assert(op <= oend);
+ { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip,
segmentSize, CTable, bmi2) );
if (cSize==0) return 0;
assert(cSize <= 65535);
MEM_writeLE16(ostart+2, (U16)cSize);
@@ -602,7 +583,8 @@ HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
}
ip += segmentSize;
- { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip,
segmentSize, CTable, bmi2) );
+ assert(op <= oend);
+ { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip,
segmentSize, CTable, bmi2) );
if (cSize==0) return 0;
assert(cSize <= 65535);
MEM_writeLE16(ostart+4, (U16)cSize);
@@ -610,12 +592,14 @@ HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
}
ip += segmentSize;
- { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, iend-ip,
CTable, bmi2) );
+ assert(op <= oend);
+ assert(ip <= iend);
+ { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip,
(size_t)(iend-ip), CTable, bmi2) );
if (cSize==0) return 0;
op += cSize;
}
- return op-ostart;
+ return (size_t)(op-ostart);
}
size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t
srcSize, const HUF_CElt* CTable)
@@ -623,48 +607,52 @@ size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const
void* src, si
return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /*
bmi2 */ 0);
}
+typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;
static size_t HUF_compressCTable_internal(
BYTE* const ostart, BYTE* op, BYTE* const oend,
const void* src, size_t srcSize,
- unsigned singleStream, const HUF_CElt* CTable, const int bmi2)
+ HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int bmi2)
{
- size_t const cSize = singleStream ?
- HUF_compress1X_usingCTable_internal(op, oend - op, src, srcSize,
CTable, bmi2) :
- HUF_compress4X_usingCTable_internal(op, oend - op, src, srcSize,
CTable, bmi2);
+ size_t const cSize = (nbStreams==HUF_singleStream) ?
+ HUF_compress1X_usingCTable_internal(op, (size_t)(oend - op),
src, srcSize, CTable, bmi2) :
+ HUF_compress4X_usingCTable_internal(op, (size_t)(oend - op),
src, srcSize, CTable, bmi2);
if (HUF_isError(cSize)) { return cSize; }
if (cSize==0) { return 0; } /* uncompressible */
op += cSize;
/* check compressibility */
+ assert(op >= ostart);
if ((size_t)(op-ostart) >= srcSize-1) { return 0; }
- return op-ostart;
+ return (size_t)(op-ostart);
}
typedef struct {
- U32 count[HUF_SYMBOLVALUE_MAX + 1];
+ unsigned count[HUF_SYMBOLVALUE_MAX + 1];
HUF_CElt CTable[HUF_SYMBOLVALUE_MAX + 1];
- huffNodeTable nodeTable;
+ HUF_buildCTable_wksp_tables buildCTable_wksp;
} HUF_compress_tables_t;
/* HUF_compress_internal() :
* `workSpace` must a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
-static size_t HUF_compress_internal (
- void* dst, size_t dstSize,
- const void* src, size_t srcSize,
- unsigned maxSymbolValue, unsigned huffLog,
- unsigned singleStream,
- void* workSpace, size_t wkspSize,
- HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat,
- const int bmi2)
+static size_t
+HUF_compress_internal (void* dst, size_t dstSize,
+ const void* src, size_t srcSize,
+ unsigned maxSymbolValue, unsigned huffLog,
+ HUF_nbStreams_e nbStreams,
+ void* workSpace, size_t wkspSize,
+ HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat,
+ const int bmi2)
{
HUF_compress_tables_t* const table = (HUF_compress_tables_t*)workSpace;
BYTE* const ostart = (BYTE*)dst;
BYTE* const oend = ostart + dstSize;
BYTE* op = ostart;
+ HUF_STATIC_ASSERT(sizeof(*table) <= HUF_WORKSPACE_SIZE);
+
/* checks & inits */
if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC); /* must be aligned on
4-bytes boundaries */
- if (wkspSize < sizeof(*table)) return ERROR(workSpace_tooSmall);
+ if (wkspSize < HUF_WORKSPACE_SIZE) return ERROR(workSpace_tooSmall);
if (!srcSize) return 0; /* Uncompressed */
if (!dstSize) return 0; /* cannot fit anything within dst budget */
if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); /* current block
size limit */
@@ -677,11 +665,11 @@ static size_t HUF_compress_internal (
if (preferRepeat && repeat && *repeat == HUF_repeat_valid) {
return HUF_compressCTable_internal(ostart, op, oend,
src, srcSize,
- singleStream, oldHufTable, bmi2);
+ nbStreams, oldHufTable, bmi2);
}
/* Scan input and build symbol stats */
- { CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const
BYTE*)src, srcSize, table->count) );
+ { CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const
BYTE*)src, srcSize, workSpace, wkspSize) );
if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; } /*
single symbol, rle */
if (largest <= (srcSize >> 7)+4) return 0; /* heuristic : probably not
compressible enough */
}
@@ -696,14 +684,15 @@ static size_t HUF_compress_internal (
if (preferRepeat && repeat && *repeat != HUF_repeat_none) {
return HUF_compressCTable_internal(ostart, op, oend,
src, srcSize,
- singleStream, oldHufTable, bmi2);
+ nbStreams, oldHufTable, bmi2);
}
/* Build Huffman Tree */
huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
- { CHECK_V_F(maxBits, HUF_buildCTable_wksp(table->CTable, table->count,
- maxSymbolValue, huffLog,
- table->nodeTable,
sizeof(table->nodeTable)) );
+ { size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count,
+ maxSymbolValue, huffLog,
+ &table->buildCTable_wksp,
sizeof(table->buildCTable_wksp));
+ CHECK_F(maxBits);
huffLog = (U32)maxBits;
/* Zero unused symbols in CTable, so we can check it for validity */
memset(table->CTable + (maxSymbolValue + 1), 0,
@@ -719,7 +708,7 @@ static size_t HUF_compress_internal (
if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) {
return HUF_compressCTable_internal(ostart, op, oend,
src, srcSize,
- singleStream, oldHufTable, bmi2);
+ nbStreams, oldHufTable, bmi2);
} }
/* Use the new huffman table */
@@ -731,7 +720,7 @@ static size_t HUF_compress_internal (
}
return HUF_compressCTable_internal(ostart, op, oend,
src, srcSize,
- singleStream, table->CTable, bmi2);
+ nbStreams, table->CTable, bmi2);
}
@@ -741,7 +730,7 @@ size_t HUF_compress1X_wksp (void* dst, size_t dstSize,
void* workSpace, size_t wkspSize)
{
return HUF_compress_internal(dst, dstSize, src, srcSize,
- maxSymbolValue, huffLog, 1 /*single stream*/,
+ maxSymbolValue, huffLog, HUF_singleStream,
workSpace, wkspSize,
NULL, NULL, 0, 0 /*bmi2*/);
}
@@ -753,7 +742,7 @@ size_t HUF_compress1X_repeat (void* dst, size_t dstSize,
HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int
bmi2)
{
return HUF_compress_internal(dst, dstSize, src, srcSize,
- maxSymbolValue, huffLog, 1 /*single stream*/,
+ maxSymbolValue, huffLog, HUF_singleStream,
workSpace, wkspSize, hufTable,
repeat, preferRepeat, bmi2);
}
@@ -762,17 +751,8 @@ size_t HUF_compress1X (void* dst, size_t dstSize,
const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog)
{
- unsigned* workSpace = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) *
HUF_WORKSPACE_SIZE_U32, HUFC_ALLOC_TAG);
- size_t ret;
-
- if (!workSpace)
- return 0;
-
- ret = HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog,
workSpace, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32);
-
- ExFreePool(workSpace);
-
- return ret;
+ unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
+ return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog,
workSpace, sizeof(workSpace));
}
/* HUF_compress4X_repeat():
@@ -784,7 +764,7 @@ size_t HUF_compress4X_wksp (void* dst, size_t dstSize,
void* workSpace, size_t wkspSize)
{
return HUF_compress_internal(dst, dstSize, src, srcSize,
- maxSymbolValue, huffLog, 0 /*4 streams*/,
+ maxSymbolValue, huffLog, HUF_fourStreams,
workSpace, wkspSize,
NULL, NULL, 0, 0 /*bmi2*/);
}
@@ -799,7 +779,7 @@ size_t HUF_compress4X_repeat (void* dst, size_t dstSize,
HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int
bmi2)
{
return HUF_compress_internal(dst, dstSize, src, srcSize,
- maxSymbolValue, huffLog, 0 /* 4 streams */,
+ maxSymbolValue, huffLog, HUF_fourStreams,
workSpace, wkspSize,
hufTable, repeat, preferRepeat, bmi2);
}
@@ -808,17 +788,8 @@ size_t HUF_compress2 (void* dst, size_t dstSize,
const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog)
{
- unsigned* workSpace = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) *
HUF_WORKSPACE_SIZE_U32, HUFC_ALLOC_TAG);
- size_t ret;
-
- if (!workSpace)
- return 0;
-
- ret = HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog,
workSpace, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32);
-
- ExFreePool(workSpace);
-
- return ret;
+ unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
+ return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog,
workSpace, sizeof(workSpace));
}
size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)
diff --git a/drivers/filesystems/btrfs/zstd/huf_decompress.c
b/drivers/filesystems/btrfs/zstd/huf_decompress.c
index 51bb417f179..ab5db481c36 100644
--- a/drivers/filesystems/btrfs/zstd/huf_decompress.c
+++ b/drivers/filesystems/btrfs/zstd/huf_decompress.c
@@ -1,35 +1,15 @@
/* ******************************************************************
- huff0 huffman decoder,
- part of Finite State Entropy library
- Copyright (C) 2013-present, Yann Collet.
-
- BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer
- in the documentation and/or other materials provided with the
- distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
... 19742 lines suppressed ...