Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-22 08:25:03 +00:00
Code Issues Projects Releases Packages Wiki Activity

[UBTRFS] Upgrade to 1.4

Browse source 
CORE-16354
This commit is contained in:
Pierre Schweitzer 2019-09-02 08:18:48 +02:00
parent 318da0c18c
commit 255ef2c332
No known key found for this signature in database
GPG key ID: 7545556C3D585B0B
3 changed files with 97 additions and 214 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
dll/win32/ubtrfs/ubtrfs.rc
View file

@ -51,8 +51,8 @@ END
// //
VS_VERSION_INFO VERSIONINFO VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,3,0,0 FILEVERSION 1,4,0,0
PRODUCTVERSION 1,3,0,0 PRODUCTVERSION 1,4,0,0
FILEFLAGSMASK 0x17L FILEFLAGSMASK 0x17L
#ifdef _DEBUG #ifdef _DEBUG
FILEFLAGS 0x1L FILEFLAGS 0x1L
@ -68,12 +68,12 @@ BEGIN
BLOCK "080904b0" BLOCK "080904b0"
BEGIN BEGIN
VALUE "FileDescription", "Btrfs utility DLL" VALUE "FileDescription", "Btrfs utility DLL"
VALUE "FileVersion", "1.3" VALUE "FileVersion", "1.4"
VALUE "InternalName", "ubtrfs" VALUE "InternalName", "ubtrfs"
VALUE "LegalCopyright", "Copyright (c) Mark Harmstone 2016-19" VALUE "LegalCopyright", "Copyright (c) Mark Harmstone 2016-19"
VALUE "OriginalFilename", "ubtrfs.dll" VALUE "OriginalFilename", "ubtrfs.dll"
VALUE "ProductName", "WinBtrfs" VALUE "ProductName", "WinBtrfs"
VALUE "ProductVersion", "1.3" VALUE "ProductVersion", "1.4"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

2
media/doc/README.FSD
View file

@ -5,7 +5,7 @@ The following FSD are shared with: https://github.com/maharmstone/btrfs.
reactos/drivers/filesystems/btrfs # Synced to 1.4 reactos/drivers/filesystems/btrfs # Synced to 1.4
reactos/dll/shellext/shellbtrfs # Synced to 1.1 reactos/dll/shellext/shellbtrfs # Synced to 1.1
reactos/sdk/lib/fslib/btrfslib # Synced to 1.3 reactos/sdk/lib/fslib/btrfslib # Synced to 1.4
The following FSD are shared with: http://www.ext2fsd.com/ The following FSD are shared with: http://www.ext2fsd.com/

301
sdk/lib/fslib/btrfslib/btrfslib.c
View file

@ -36,9 +36,11 @@
#include <ata.h> #include <ata.h>
#include <mountmgr.h> #include <mountmgr.h>
#ifdef __REACTOS__ #ifdef __REACTOS__
#include <winnls.h>
#include "btrfs.h" #include "btrfs.h"
#include "btrfsioctl.h" #include "btrfsioctl.h"
#else #else
#include <stringapiset.h>
#include "../btrfs.h" #include "../btrfs.h"
#include "../btrfsioctl.h" #include "../btrfsioctl.h"
#endif #endif
@ -62,9 +64,6 @@ NTSTATUS NTAPI NtWriteFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcR
NTSTATUS NTAPI NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, NTSTATUS NTAPI NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer,
ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key); ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key);
NTSYSAPI NTSTATUS NTAPI RtlUnicodeToUTF8N(PCHAR UTF8StringDestination, ULONG UTF8StringMaxByteCount, PULONG UTF8StringActualByteCount,
PCWCH UnicodeStringSource, ULONG UnicodeStringByteCount);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
@ -89,9 +88,9 @@ typedef struct {
#define FORMAT_FLAG_INTEGRITY_DISABLE 0x00000100 #define FORMAT_FLAG_INTEGRITY_DISABLE 0x00000100
typedef struct { typedef struct {
UINT16 unk1; uint16_t unk1;
UINT16 unk2; uint16_t unk2;
UINT32 flags; uint32_t flags;
DSTRING* label; DSTRING* label;
} options; } options;
@ -111,33 +110,27 @@ FORCEINLINE VOID InsertTailList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry) {
} }
#endif #endif
#if defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_WIN7)
NTSTATUS NTAPI RtlUnicodeToUTF8N(CHAR *utf8_dest, ULONG utf8_bytes_max,
ULONG *utf8_bytes_written,
const WCHAR *uni_src, ULONG uni_bytes);
#endif /* defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_WIN7) */
#ifdef __REACTOS__ #ifdef __REACTOS__
ULONG NTAPI NtGetTickCount(VOID); ULONG NTAPI NtGetTickCount(VOID);
#endif #endif
typedef struct { typedef struct {
KEY key; KEY key;
UINT16 size; uint16_t size;
void* data; void* data;
LIST_ENTRY list_entry; LIST_ENTRY list_entry;
} btrfs_item; } btrfs_item;
typedef struct { typedef struct {
UINT64 offset; uint64_t offset;
CHUNK_ITEM* chunk_item; CHUNK_ITEM* chunk_item;
UINT64 lastoff; uint64_t lastoff;
UINT64 used; uint64_t used;
LIST_ENTRY list_entry; LIST_ENTRY list_entry;
} btrfs_chunk; } btrfs_chunk;
typedef struct { typedef struct {
UINT64 id; uint64_t id;
tree_header header; tree_header header;
btrfs_chunk* c; btrfs_chunk* c;
LIST_ENTRY items; LIST_ENTRY items;
@ -146,7 +139,7 @@ typedef struct {
typedef struct { typedef struct {
DEV_ITEM dev_item; DEV_ITEM dev_item;
UINT64 last_alloc; uint64_t last_alloc;
} btrfs_dev; } btrfs_dev;
#define keycmp(key1, key2)\ #define keycmp(key1, key2)\
@ -160,7 +153,7 @@ typedef struct {
HMODULE module; HMODULE module;
ULONG def_sector_size = 0, def_node_size = 0; ULONG def_sector_size = 0, def_node_size = 0;
UINT64 def_incompat_flags = BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA; uint64_t def_incompat_flags = BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA;
// the following definitions come from fmifs.h in ReactOS // the following definitions come from fmifs.h in ReactOS
@ -218,7 +211,7 @@ typedef enum {
typedef BOOLEAN (NTAPI* PFMIFSCALLBACK)(CALLBACKCOMMAND Command, ULONG SubAction, PVOID ActionInfo); typedef BOOLEAN (NTAPI* PFMIFSCALLBACK)(CALLBACKCOMMAND Command, ULONG SubAction, PVOID ActionInfo);
static const UINT32 crctable[] = { static const uint32_t crctable[] = {
0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb, 0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24, 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384, 0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
@ -253,8 +246,8 @@ static const UINT32 crctable[] = {
0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e, 0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351, 0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e, 0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351,
}; };
static UINT32 calc_crc32c(UINT32 seed, UINT8* msg, ULONG msglen) { static uint32_t calc_crc32c(uint32_t seed, uint8_t* msg, ULONG msglen) {
UINT32 rem; uint32_t rem;
ULONG i; ULONG i;
rem = seed; rem = seed;
@ -286,7 +279,7 @@ NTSTATUS NTAPI BtrfsChkdskEx(PUNICODE_STRING DriveRoot, BOOLEAN FixErrors, BOOLE
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
static btrfs_root* add_root(LIST_ENTRY* roots, UINT64 id) { static btrfs_root* add_root(LIST_ENTRY* roots, uint64_t id) {
btrfs_root* root; btrfs_root* root;
#ifdef __REACTOS__ #ifdef __REACTOS__
@ -362,7 +355,7 @@ static void free_chunks(LIST_ENTRY* chunks) {
} }
} }
static void add_item(btrfs_root* r, UINT64 obj_id, UINT8 obj_type, UINT64 offset, void* data, UINT16 size) { static void add_item(btrfs_root* r, uint64_t obj_id, uint8_t obj_type, uint64_t offset, void* data, uint16_t size) {
LIST_ENTRY* le; LIST_ENTRY* le;
btrfs_item* item; btrfs_item* item;
@ -403,8 +396,8 @@ static void add_item(btrfs_root* r, UINT64 obj_id, UINT8 obj_type, UINT64 offset
InsertTailList(&r->items, &item->list_entry); InsertTailList(&r->items, &item->list_entry);
} }
static UINT64 find_chunk_offset(UINT64 size, UINT64 offset, btrfs_dev* dev, btrfs_root* dev_root, BTRFS_UUID* chunkuuid) { static uint64_t find_chunk_offset(uint64_t size, uint64_t offset, btrfs_dev* dev, btrfs_root* dev_root, BTRFS_UUID* chunkuuid) {
UINT64 off; uint64_t off;
DEV_EXTENT de; DEV_EXTENT de;
off = dev->last_alloc; off = dev->last_alloc;
@ -423,9 +416,9 @@ static UINT64 find_chunk_offset(UINT64 size, UINT64 offset, btrfs_dev* dev, btrf
return off; return off;
} }
static btrfs_chunk* add_chunk(LIST_ENTRY* chunks, UINT64 flags, btrfs_root* chunk_root, btrfs_dev* dev, btrfs_root* dev_root, BTRFS_UUID* chunkuuid, UINT32 sector_size) { static btrfs_chunk* add_chunk(LIST_ENTRY* chunks, uint64_t flags, btrfs_root* chunk_root, btrfs_dev* dev, btrfs_root* dev_root, BTRFS_UUID* chunkuuid, uint32_t sector_size) {
UINT64 off, size; uint64_t off, size;
UINT16 stripes, i; uint16_t stripes, i;
btrfs_chunk* c; btrfs_chunk* c;
LIST_ENTRY* le; LIST_ENTRY* le;
CHUNK_ITEM_STRIPE* cis; CHUNK_ITEM_STRIPE* cis;
@ -497,16 +490,16 @@ static btrfs_chunk* add_chunk(LIST_ENTRY* chunks, UINT64 flags, btrfs_root* chun
return c; return c;
} }
static BOOL superblock_collision(btrfs_chunk* c, UINT64 address) { static BOOL superblock_collision(btrfs_chunk* c, uint64_t address) {
CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1]; CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
UINT64 stripe = (address - c->offset) / c->chunk_item->stripe_length; uint64_t stripe = (address - c->offset) / c->chunk_item->stripe_length;
UINT16 i, j; uint16_t i, j;
for (i = 0; i < c->chunk_item->num_stripes; i++) { for (i = 0; i < c->chunk_item->num_stripes; i++) {
j = 0; j = 0;
while (superblock_addrs[j] != 0) { while (superblock_addrs[j] != 0) {
if (superblock_addrs[j] >= cis[i].offset) { if (superblock_addrs[j] >= cis[i].offset) {
UINT64 stripe2 = (superblock_addrs[j] - cis[i].offset) / c->chunk_item->stripe_length; uint64_t stripe2 = (superblock_addrs[j] - cis[i].offset) / c->chunk_item->stripe_length;
if (stripe2 == stripe) if (stripe2 == stripe)
return TRUE; return TRUE;
@ -518,8 +511,8 @@ static BOOL superblock_collision(btrfs_chunk* c, UINT64 address) {
return FALSE; return FALSE;
} }
static UINT64 get_next_address(btrfs_chunk* c) { static uint64_t get_next_address(btrfs_chunk* c) {
UINT64 addr; uint64_t addr;
addr = c->lastoff; addr = c->lastoff;
@ -535,18 +528,18 @@ static UINT64 get_next_address(btrfs_chunk* c) {
typedef struct { typedef struct {
EXTENT_ITEM ei; EXTENT_ITEM ei;
UINT8 type; uint8_t type;
TREE_BLOCK_REF tbr; TREE_BLOCK_REF tbr;
} EXTENT_ITEM_METADATA; } EXTENT_ITEM_METADATA;
typedef struct { typedef struct {
EXTENT_ITEM ei; EXTENT_ITEM ei;
EXTENT_ITEM2 ei2; EXTENT_ITEM2 ei2;
UINT8 type; uint8_t type;
TREE_BLOCK_REF tbr; TREE_BLOCK_REF tbr;
} EXTENT_ITEM_METADATA2; } EXTENT_ITEM_METADATA2;
static void assign_addresses(LIST_ENTRY* roots, btrfs_chunk* sys_chunk, btrfs_chunk* metadata_chunk, UINT32 node_size, static void assign_addresses(LIST_ENTRY* roots, btrfs_chunk* sys_chunk, btrfs_chunk* metadata_chunk, uint32_t node_size,
btrfs_root* root_root, btrfs_root* extent_root, BOOL skinny) { btrfs_root* root_root, btrfs_root* extent_root, BOOL skinny) {
LIST_ENTRY* le; LIST_ENTRY* le;
@ -619,9 +612,9 @@ static void assign_addresses(LIST_ENTRY* roots, btrfs_chunk* sys_chunk, btrfs_ch
} }
} }
static NTSTATUS write_data(HANDLE h, UINT64 address, btrfs_chunk* c, void* data, ULONG size) { static NTSTATUS write_data(HANDLE h, uint64_t address, btrfs_chunk* c, void* data, ULONG size) {
NTSTATUS Status; NTSTATUS Status;
UINT16 i; uint16_t i;
IO_STATUS_BLOCK iosb; IO_STATUS_BLOCK iosb;
LARGE_INTEGER off; LARGE_INTEGER off;
CHUNK_ITEM_STRIPE* cis; CHUNK_ITEM_STRIPE* cis;
@ -639,10 +632,10 @@ static NTSTATUS write_data(HANDLE h, UINT64 address, btrfs_chunk* c, void* data,
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
static NTSTATUS write_roots(HANDLE h, LIST_ENTRY* roots, UINT32 node_size, BTRFS_UUID* fsuuid, BTRFS_UUID* chunkuuid) { static NTSTATUS write_roots(HANDLE h, LIST_ENTRY* roots, uint32_t node_size, BTRFS_UUID* fsuuid, BTRFS_UUID* chunkuuid) {
LIST_ENTRY *le, *le2; LIST_ENTRY *le, *le2;
NTSTATUS Status; NTSTATUS Status;
UINT8* tree; uint8_t* tree;
#ifndef __REACTOS__ #ifndef __REACTOS__
tree = malloc(node_size); tree = malloc(node_size);
@ -653,9 +646,9 @@ static NTSTATUS write_roots(HANDLE h, LIST_ENTRY* roots, UINT32 node_size, BTRFS
le = roots->Flink; le = roots->Flink;
while (le != roots) { while (le != roots) {
btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry); btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry);
UINT8* dp; uint8_t* dp;
leaf_node* ln; leaf_node* ln;
UINT32 crc32; uint32_t crc32;
memset(tree, 0, node_size); memset(tree, 0, node_size);
@ -694,8 +687,8 @@ static NTSTATUS write_roots(HANDLE h, LIST_ENTRY* roots, UINT32 node_size, BTRFS
memcpy(tree, &r->header, sizeof(tree_header)); memcpy(tree, &r->header, sizeof(tree_header));
crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&((tree_header*)tree)->fs_uuid, node_size - sizeof(((tree_header*)tree)->csum)); crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&((tree_header*)tree)->fs_uuid, node_size - sizeof(((tree_header*)tree)->csum));
memcpy(tree, &crc32, sizeof(UINT32)); memcpy(tree, &crc32, sizeof(uint32_t));
Status = write_data(h, r->header.address, r->c, tree, node_size); Status = write_data(h, r->header.address, r->c, tree, node_size);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
@ -724,7 +717,7 @@ static void get_uuid(BTRFS_UUID* uuid) {
#else #else
static void get_uuid(BTRFS_UUID* uuid, ULONG* seed) { static void get_uuid(BTRFS_UUID* uuid, ULONG* seed) {
#endif #endif
UINT8 i; uint8_t i;
for (i = 0; i < 16; i+=2) { for (i = 0; i < 16; i+=2) {
#ifndef __REACTOS__ #ifndef __REACTOS__
@ -739,9 +732,9 @@ static void get_uuid(BTRFS_UUID* uuid, ULONG* seed) {
} }
#ifndef __REACTOS__ #ifndef __REACTOS__
static void init_device(btrfs_dev* dev, UINT64 id, UINT64 size, BTRFS_UUID* fsuuid, UINT32 sector_size) { static void init_device(btrfs_dev* dev, uint64_t id, uint64_t size, BTRFS_UUID* fsuuid, uint32_t sector_size) {
#else #else
static void init_device(btrfs_dev* dev, UINT64 id, UINT64 size, BTRFS_UUID* fsuuid, UINT32 sector_size, ULONG* seed) { static void init_device(btrfs_dev* dev, uint64_t id, uint64_t size, BTRFS_UUID* fsuuid, uint32_t sector_size, ULONG* seed) {
#endif #endif
dev->dev_item.dev_id = id; dev->dev_item.dev_id = id;
dev->dev_item.num_bytes = size; dev->dev_item.num_bytes = size;
@ -765,126 +758,16 @@ static void init_device(btrfs_dev* dev, UINT64 id, UINT64 size, BTRFS_UUID* fsuu
dev->last_alloc = 0x100000; // skip first megabyte dev->last_alloc = 0x100000; // skip first megabyte
} }
#ifdef __REACTOS__
NTSTATUS NTAPI RtlUnicodeToUTF8N(CHAR *utf8_dest, ULONG utf8_bytes_max,
ULONG *utf8_bytes_written,
const WCHAR *uni_src, ULONG uni_bytes)
{
NTSTATUS status;
ULONG i;
ULONG written;
ULONG ch;
BYTE utf8_ch[4];
ULONG utf8_ch_len;
if (!uni_src)
return STATUS_INVALID_PARAMETER_4;
if (!utf8_bytes_written)
return STATUS_INVALID_PARAMETER;
if (utf8_dest && uni_bytes % sizeof(WCHAR))
return STATUS_INVALID_PARAMETER_5;
written = 0;
status = STATUS_SUCCESS;
for (i = 0; i < uni_bytes / sizeof(WCHAR); i++)
{
/* decode UTF-16 into ch */
ch = uni_src[i];
if (ch >= 0xdc00 && ch <= 0xdfff)
{
ch = 0xfffd;
status = STATUS_SOME_NOT_MAPPED;
}
else if (ch >= 0xd800 && ch <= 0xdbff)
{
if (i + 1 < uni_bytes / sizeof(WCHAR))
{
ch -= 0xd800;
ch <<= 10;
if (uni_src[i + 1] >= 0xdc00 && uni_src[i + 1] <= 0xdfff)
{
ch |= uni_src[i + 1] - 0xdc00;
ch += 0x010000;
i++;
}
else
{
ch = 0xfffd;
status = STATUS_SOME_NOT_MAPPED;
}
}
else
{
ch = 0xfffd;
status = STATUS_SOME_NOT_MAPPED;
}
}
/* encode ch as UTF-8 */
ASSERT(ch <= 0x10ffff);
if (ch < 0x80)
{
utf8_ch[0] = ch & 0x7f;
utf8_ch_len = 1;
}
else if (ch < 0x800)
{
utf8_ch[0] = 0xc0 | (ch >> 6 & 0x1f);
utf8_ch[1] = 0x80 | (ch >> 0 & 0x3f);
utf8_ch_len = 2;
}
else if (ch < 0x10000)
{
utf8_ch[0] = 0xe0 | (ch >> 12 & 0x0f);
utf8_ch[1] = 0x80 | (ch >> 6 & 0x3f);
utf8_ch[2] = 0x80 | (ch >> 0 & 0x3f);
utf8_ch_len = 3;
}
else if (ch < 0x200000)
{
utf8_ch[0] = 0xf0 | (ch >> 18 & 0x07);
utf8_ch[1] = 0x80 | (ch >> 12 & 0x3f);
utf8_ch[2] = 0x80 | (ch >> 6 & 0x3f);
utf8_ch[3] = 0x80 | (ch >> 0 & 0x3f);
utf8_ch_len = 4;
}
if (!utf8_dest)
{
written += utf8_ch_len;
continue;
}
if (utf8_bytes_max >= utf8_ch_len)
{
memcpy(utf8_dest, utf8_ch, utf8_ch_len);
utf8_dest += utf8_ch_len;
utf8_bytes_max -= utf8_ch_len;
written += utf8_ch_len;
}
else
{
utf8_bytes_max = 0;
status = STATUS_BUFFER_TOO_SMALL;
}
}
*utf8_bytes_written = written;
return status;
}
#endif
static NTSTATUS write_superblocks(HANDLE h, btrfs_dev* dev, btrfs_root* chunk_root, btrfs_root* root_root, btrfs_root* extent_root, static NTSTATUS write_superblocks(HANDLE h, btrfs_dev* dev, btrfs_root* chunk_root, btrfs_root* root_root, btrfs_root* extent_root,
btrfs_chunk* sys_chunk, UINT32 node_size, BTRFS_UUID* fsuuid, UINT32 sector_size, PUNICODE_STRING label, UINT64 incompat_flags) { btrfs_chunk* sys_chunk, uint32_t node_size, BTRFS_UUID* fsuuid, uint32_t sector_size, PUNICODE_STRING label, uint64_t incompat_flags) {
NTSTATUS Status; NTSTATUS Status;
IO_STATUS_BLOCK iosb; IO_STATUS_BLOCK iosb;
ULONG sblen; ULONG sblen;
int i; int i;
UINT32 crc32; uint32_t crc32;
superblock* sb; superblock* sb;
KEY* key; KEY* key;
UINT64 bytes_used; uint64_t bytes_used;
LIST_ENTRY* le; LIST_ENTRY* le;
sblen = sizeof(*sb); sblen = sizeof(*sb);
@ -932,10 +815,16 @@ static NTSTATUS write_superblocks(HANDLE h, btrfs_dev* dev, btrfs_root* chunk_ro
memcpy(&sb->dev_item, &dev->dev_item, sizeof(DEV_ITEM)); memcpy(&sb->dev_item, &dev->dev_item, sizeof(DEV_ITEM));
if (label->Length > 0) { if (label->Length > 0) {
int i; #ifdef __REACTOS__
ULONG utf8len; ANSI_STRING as;
unsigned int i;
for (i = 0; i < label->Length / sizeof(WCHAR); i++) { for (i = 0; i < label->Length / sizeof(WCHAR); i++) {
#else
ULONG utf8len;
for (unsigned int i = 0; i < label->Length / sizeof(WCHAR); i++) {
#endif
if (label->Buffer[i] == '/' || label->Buffer[i] == '\\') { if (label->Buffer[i] == '/' || label->Buffer[i] == '\\') {
#ifndef __REACTOS__ #ifndef __REACTOS__
free(sb); free(sb);
@ -946,34 +835,29 @@ static NTSTATUS write_superblocks(HANDLE h, btrfs_dev* dev, btrfs_root* chunk_ro
} }
} }
Status = RtlUnicodeToUTF8N(NULL, 0, &utf8len, label->Buffer, label->Length);
if (!NT_SUCCESS(Status)) {
#ifndef __REACTOS__ #ifndef __REACTOS__
free(sb); utf8len = WideCharToMultiByte(CP_UTF8, 0, label->Buffer, label->Length, NULL, 0, NULL, NULL);
#else
RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif
return Status;
}
if (utf8len > MAX_LABEL_SIZE) { if (utf8len == 0 || utf8len > MAX_LABEL_SIZE) {
#ifndef __REACTOS__
free(sb); free(sb);
#else
RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif
return STATUS_INVALID_VOLUME_LABEL; return STATUS_INVALID_VOLUME_LABEL;
} }
Status = RtlUnicodeToUTF8N((PCHAR)&sb->label, MAX_LABEL_SIZE, &utf8len, label->Buffer, label->Length); if (WideCharToMultiByte(CP_UTF8, 0, label->Buffer, label->Length, sb->label, utf8len, NULL, NULL) == 0) {
if (!NT_SUCCESS(Status)) {
#ifndef __REACTOS__
free(sb); free(sb);
#else return STATUS_INVALID_VOLUME_LABEL;
RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif
return Status;
} }
#else
as.Buffer = sb->label;
as.Length = 0;
as.MaximumLength = MAX_LABEL_SIZE;
if (!NT_SUCCESS(RtlUnicodeStringToAnsiString(&as, label, FALSE)))
{
RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
return STATUS_INVALID_VOLUME_LABEL;
}
#endif
} }
sb->cache_generation = 0xffffffffffffffff; sb->cache_generation = 0xffffffffffffffff;
@ -992,8 +876,8 @@ static NTSTATUS write_superblocks(HANDLE h, btrfs_dev* dev, btrfs_root* chunk_ro
sb->sb_phys_addr = superblock_addrs[i]; sb->sb_phys_addr = superblock_addrs[i];
crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum)); crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
memcpy(&sb->checksum, &crc32, sizeof(UINT32)); memcpy(&sb->checksum, &crc32, sizeof(uint32_t));
off.QuadPart = superblock_addrs[i]; off.QuadPart = superblock_addrs[i];
@ -1045,7 +929,7 @@ GetSystemTimeAsFileTime(OUT PFILETIME lpFileTime)
} }
#endif #endif
static void init_fs_tree(btrfs_root* r, UINT32 node_size) { static void init_fs_tree(btrfs_root* r, uint32_t node_size) {
INODE_ITEM ii; INODE_ITEM ii;
INODE_REF* ir; INODE_REF* ir;
FILETIME filetime; FILETIME filetime;
@ -1108,8 +992,7 @@ static NTSTATUS clear_first_megabyte(HANDLE h) {
NTSTATUS Status; NTSTATUS Status;
IO_STATUS_BLOCK iosb; IO_STATUS_BLOCK iosb;
LARGE_INTEGER zero; LARGE_INTEGER zero;
UINT8* mb; uint8_t* mb;
#ifndef __REACTOS__ #ifndef __REACTOS__
mb = malloc(0x100000); mb = malloc(0x100000);
@ -1157,7 +1040,7 @@ static BOOL is_ssd(HANDLE h) {
Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_ATA_PASS_THROUGH, apte, aptelen, apte, aptelen); Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_ATA_PASS_THROUGH, apte, aptelen, apte, aptelen);
if (NT_SUCCESS(Status)) { if (NT_SUCCESS(Status)) {
idd = (IDENTIFY_DEVICE_DATA*)((UINT8*)apte + sizeof(ATA_PASS_THROUGH_EX)); idd = (IDENTIFY_DEVICE_DATA*)((uint8_t*)apte + sizeof(ATA_PASS_THROUGH_EX));
if (idd->NominalMediaRotationRate == 1) { if (idd->NominalMediaRotationRate == 1) {
#ifndef __REACTOS__ #ifndef __REACTOS__
@ -1178,7 +1061,7 @@ static BOOL is_ssd(HANDLE h) {
return FALSE; return FALSE;
} }
static NTSTATUS write_btrfs(HANDLE h, UINT64 size, PUNICODE_STRING label, UINT32 sector_size, UINT32 node_size, UINT64 incompat_flags) { static NTSTATUS write_btrfs(HANDLE h, uint64_t size, PUNICODE_STRING label, uint32_t sector_size, uint32_t node_size, uint64_t incompat_flags) {
NTSTATUS Status; NTSTATUS Status;
LIST_ENTRY roots, chunks; LIST_ENTRY roots, chunks;
btrfs_root *root_root, *chunk_root, *extent_root, *dev_root, *fs_root, *reloc_root; btrfs_root *root_root, *chunk_root, *extent_root, *dev_root, *fs_root, *reloc_root;
@ -1186,13 +1069,13 @@ static NTSTATUS write_btrfs(HANDLE h, UINT64 size, PUNICODE_STRING label, UINT32
btrfs_dev dev; btrfs_dev dev;
BTRFS_UUID fsuuid, chunkuuid; BTRFS_UUID fsuuid, chunkuuid;
BOOL ssd; BOOL ssd;
UINT64 metadata_flags; uint64_t metadata_flags;
#ifdef __REACTOS__ #ifdef __REACTOS__
ULONG seed; ULONG seed;
#endif #endif
#ifndef __REACTOS__ #ifndef __REACTOS__
srand(time(0)); srand((unsigned int)time(0));
get_uuid(&fsuuid); get_uuid(&fsuuid);
get_uuid(&chunkuuid); get_uuid(&chunkuuid);
#else #else
@ -1264,14 +1147,14 @@ static NTSTATUS write_btrfs(HANDLE h, UINT64 size, PUNICODE_STRING label, UINT32
} }
static BOOL look_for_device(btrfs_filesystem* bfs, BTRFS_UUID* devuuid) { static BOOL look_for_device(btrfs_filesystem* bfs, BTRFS_UUID* devuuid) {
UINT32 i; uint32_t i;
btrfs_filesystem_device* dev; btrfs_filesystem_device* dev;
for (i = 0; i < bfs->num_devices; i++) { for (i = 0; i < bfs->num_devices; i++) {
if (i == 0) if (i == 0)
dev = &bfs->device; dev = &bfs->device;
else else
dev = (btrfs_filesystem_device*)((UINT8*)dev + offsetof(btrfs_filesystem_device, name[0]) + dev->name_length); dev = (btrfs_filesystem_device*)((uint8_t*)dev + offsetof(btrfs_filesystem_device, name[0]) + dev->name_length);
if (RtlCompareMemory(&dev->uuid, devuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) if (RtlCompareMemory(&dev->uuid, devuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID))
return TRUE; return TRUE;
@ -1280,14 +1163,14 @@ static BOOL look_for_device(btrfs_filesystem* bfs, BTRFS_UUID* devuuid) {
return FALSE; return FALSE;
} }
static BOOL is_mounted_multi_device(HANDLE h, UINT32 sector_size) { static BOOL is_mounted_multi_device(HANDLE h, uint32_t sector_size) {
NTSTATUS Status; NTSTATUS Status;
superblock* sb; superblock* sb;
ULONG sblen; ULONG sblen;
IO_STATUS_BLOCK iosb; IO_STATUS_BLOCK iosb;
LARGE_INTEGER off; LARGE_INTEGER off;
BTRFS_UUID fsuuid, devuuid; BTRFS_UUID fsuuid, devuuid;
UINT32 crc32; uint32_t crc32;
UNICODE_STRING us; UNICODE_STRING us;
OBJECT_ATTRIBUTES atts; OBJECT_ATTRIBUTES atts;
HANDLE h2; HANDLE h2;
@ -1328,8 +1211,8 @@ static BOOL is_mounted_multi_device(HANDLE h, UINT32 sector_size) {
return FALSE; return FALSE;
} }
crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum)); crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
if (crc32 != *((UINT32*)sb)) { if (crc32 != *((uint32_t*)sb)) {
#ifndef __REACTOS__ #ifndef __REACTOS__
free(sb); free(sb);
#else #else
@ -1347,7 +1230,7 @@ static BOOL is_mounted_multi_device(HANDLE h, UINT32 sector_size) {
RtlFreeHeap(RtlGetProcessHeap(), 0, sb); RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif #endif
us.Length = us.MaximumLength = wcslen(btrfs) * sizeof(WCHAR); us.Length = us.MaximumLength = (USHORT)(wcslen(btrfs) * sizeof(WCHAR));
us.Buffer = btrfs; us.Buffer = btrfs;
InitializeObjectAttributes(&atts, &us, 0, NULL, NULL); InitializeObjectAttributes(&atts, &us, 0, NULL, NULL);
@ -1395,7 +1278,7 @@ static BOOL is_mounted_multi_device(HANDLE h, UINT32 sector_size) {
if (bfs2->next_entry == 0) if (bfs2->next_entry == 0)
break; break;
else else
bfs2 = (btrfs_filesystem*)((UINT8*)bfs2 + bfs2->next_entry); bfs2 = (btrfs_filesystem*)((uint8_t*)bfs2 + bfs2->next_entry);
} }
} }
@ -1446,14 +1329,14 @@ NTSTATUS NTAPI BtrfsFormatEx(PUNICODE_STRING DriveRoot, FMIFS_MEDIA_FLAG MediaFl
IO_STATUS_BLOCK iosb; IO_STATUS_BLOCK iosb;
GET_LENGTH_INFORMATION gli; GET_LENGTH_INFORMATION gli;
DISK_GEOMETRY dg; DISK_GEOMETRY dg;
UINT32 sector_size, node_size; uint32_t sector_size, node_size;
UNICODE_STRING btrfsus; UNICODE_STRING btrfsus;
#ifndef __REACTOS__ #ifndef __REACTOS__
HANDLE token; HANDLE token;
TOKEN_PRIVILEGES tp; TOKEN_PRIVILEGES tp;
LUID luid; LUID luid;
#endif #endif
UINT64 incompat_flags; uint64_t incompat_flags;
UNICODE_STRING empty_label; UNICODE_STRING empty_label;
static WCHAR btrfs[] = L"\\Btrfs"; static WCHAR btrfs[] = L"\\Btrfs";
@ -1561,7 +1444,7 @@ end:
if (NT_SUCCESS(Status)) { if (NT_SUCCESS(Status)) {
btrfsus.Buffer = btrfs; btrfsus.Buffer = btrfs;
btrfsus.Length = btrfsus.MaximumLength = wcslen(btrfs) * sizeof(WCHAR); btrfsus.Length = btrfsus.MaximumLength = (USHORT)(wcslen(btrfs) * sizeof(WCHAR));
InitializeObjectAttributes(&attr, &btrfsus, 0, NULL, NULL); InitializeObjectAttributes(&attr, &btrfsus, 0, NULL, NULL);
@ -1604,18 +1487,18 @@ end:
return Status; return Status;
} }
BOOL __stdcall FormatEx(DSTRING* root, STREAM_MESSAGE* message, options* opts, UINT32 unk1) { BOOL __stdcall FormatEx(DSTRING* root, STREAM_MESSAGE* message, options* opts, uint32_t unk1) {
UNICODE_STRING DriveRoot, Label; UNICODE_STRING DriveRoot, Label;
NTSTATUS Status; NTSTATUS Status;
if (!root || !root->string) if (!root || !root->string)
return FALSE; return FALSE;
DriveRoot.Length = DriveRoot.MaximumLength = wcslen(root->string) * sizeof(WCHAR); DriveRoot.Length = DriveRoot.MaximumLength = (USHORT)(wcslen(root->string) * sizeof(WCHAR));
DriveRoot.Buffer = root->string; DriveRoot.Buffer = root->string;
if (opts && opts->label && opts->label->string) { if (opts && opts->label && opts->label->string) {
Label.Length = Label.MaximumLength = wcslen(opts->label->string) * sizeof(WCHAR); Label.Length = Label.MaximumLength = (USHORT)(wcslen(opts->label->string) * sizeof(WCHAR));
Label.Buffer = opts->label->string; Label.Buffer = opts->label->string;
} else { } else {
Label.Length = Label.MaximumLength = 0; Label.Length = Label.MaximumLength = 0;
@ -1639,11 +1522,11 @@ void __stdcall SetSizes(ULONG sector, ULONG node) {
def_node_size = node; def_node_size = node;
} }
void __stdcall SetIncompatFlags(UINT64 incompat_flags) { void __stdcall SetIncompatFlags(uint64_t incompat_flags) {
def_incompat_flags = incompat_flags; def_incompat_flags = incompat_flags;
} }
BOOL __stdcall GetFilesystemInformation(UINT32 unk1, UINT32 unk2, void* unk3) { BOOL __stdcall GetFilesystemInformation(uint32_t unk1, uint32_t unk2, void* unk3) {
// STUB - undocumented // STUB - undocumented
return TRUE; return TRUE;