ReactOS 0.4.15-dev-5893-g1bb4167
Classes | Macros | Typedefs | Enumerations | Functions | Variables
btrfslib.c File Reference
#include <stdlib.h>
#include <stddef.h>
#include <time.h>
#include <ntstatus.h>
#include <windef.h>
#include <winbase.h>
#include <winternl.h>
#include <devioctl.h>
#include <ntdddisk.h>
#include <ntddscsi.h>
#include <ntddstor.h>
#include <ata.h>
#include <mountmgr.h>
#include <stringapiset.h>
#include <stdbool.h>
#include "../btrfs.h"
#include "../btrfsioctl.h"
#include "../crc32c.h"
#include "../xxhash.h"
Include dependency graph for btrfslib.c:

Go to the source code of this file.

Classes

struct  DSTRING
 
struct  STREAM_MESSAGE
 
struct  options
 
struct  btrfs_item
 
struct  btrfs_chunk
 
struct  btrfs_root
 
struct  btrfs_dev
 
struct  TEXTOUTPUT
 
struct  EXTENT_ITEM_METADATA
 
struct  EXTENT_ITEM_METADATA2
 

Macros

#define WIN32_NO_STATUS
 
#define SHA256_HASH_SIZE   32
 
#define BLAKE2_HASH_SIZE   32
 
#define FSCTL_LOCK_VOLUME   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
#define FSCTL_UNLOCK_VOLUME   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
#define FSCTL_DISMOUNT_VOLUME   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
#define DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED   0x80000000
 
#define FORMAT_FLAG_QUICK_FORMAT   0x00000001
 
#define FORMAT_FLAG_UNKNOWN1   0x00000002
 
#define FORMAT_FLAG_DISMOUNT_FIRST   0x00000004
 
#define FORMAT_FLAG_UNKNOWN2   0x00000040
 
#define FORMAT_FLAG_LARGE_RECORDS   0x00000100
 
#define FORMAT_FLAG_INTEGRITY_DISABLE   0x00000100
 
#define keycmp(key1, key2)
 

Typedefs

typedef struct TEXTOUTPUT * PTEXTOUTPUT
 
typedef BOOLEAN(NTAPI * PFMIFSCALLBACK) (CALLBACKCOMMAND Command, ULONG SubAction, PVOID ActionInfo)
 

Enumerations

enum  FMIFS_MEDIA_FLAG {
  FMIFS_UNKNOWN0 , FMIFS_UNKNOWN1 , FMIFS_UNKNOWN2 , FMIFS_UNKNOWN3 ,
  FMIFS_UNKNOWN4 , FMIFS_UNKNOWN5 , FMIFS_UNKNOWN6 , FMIFS_UNKNOWN7 ,
  FMIFS_FLOPPY , FMIFS_UNKNOWN9 , FMIFS_UNKNOWN10 , FMIFS_REMOVABLE ,
  FMIFS_HARDDISK , FMIFS_UNKNOWN13 , FMIFS_UNKNOWN14 , FMIFS_UNKNOWN15 ,
  FMIFS_UNKNOWN16 , FMIFS_UNKNOWN17 , FMIFS_UNKNOWN18 , FMIFS_UNKNOWN19 ,
  FMIFS_UNKNOWN20 , FMIFS_UNKNOWN21 , FMIFS_UNKNOWN22 , FMIFS_UNKNOWN23 ,
  FMIFS_UNKNOWN0 , FMIFS_UNKNOWN1 , FMIFS_UNKNOWN2 , FMIFS_UNKNOWN3 ,
  FMIFS_UNKNOWN4 , FMIFS_UNKNOWN5 , FMIFS_UNKNOWN6 , FMIFS_UNKNOWN7 ,
  FMIFS_FLOPPY , FMIFS_UNKNOWN9 , FMIFS_UNKNOWN10 , FMIFS_REMOVABLE ,
  FMIFS_HARDDISK , FMIFS_UNKNOWN13 , FMIFS_UNKNOWN14 , FMIFS_UNKNOWN15 ,
  FMIFS_UNKNOWN16 , FMIFS_UNKNOWN17 , FMIFS_UNKNOWN18 , FMIFS_UNKNOWN19 ,
  FMIFS_UNKNOWN20 , FMIFS_UNKNOWN21 , FMIFS_UNKNOWN22 , FMIFS_UNKNOWN23
}
 
enum  CALLBACKCOMMAND {
  PROGRESS , DONEWITHSTRUCTURE , UNKNOWN2 , UNKNOWN3 ,
  UNKNOWN4 , UNKNOWN5 , INSUFFICIENTRIGHTS , FSNOTSUPPORTED ,
  VOLUMEINUSE , UNKNOWN9 , UNKNOWNA , DONE ,
  UNKNOWNC , UNKNOWND , OUTPUT , STRUCTUREPROGRESS ,
  CLUSTERSIZETOOSMALL , PROGRESS , DONEWITHSTRUCTURE , UNKNOWN2 ,
  UNKNOWN3 , UNKNOWN4 , UNKNOWN5 , INSUFFICIENTRIGHTS ,
  FSNOTSUPPORTED , VOLUMEINUSE , UNKNOWN9 , UNKNOWNA ,
  DONE , UNKNOWNC , UNKNOWND , OUTPUT ,
  STRUCTUREPROGRESS , CLUSTERSIZETOOSMALL
}
 

Functions

void calc_sha256 (uint8_t *hash, const void *input, size_t len)
 
void blake2b (void *out, size_t outlen, const void *in, size_t inlen)
 
NTSTATUS NTAPI NtWriteFile (HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key)
 
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)
 
FORCEINLINE VOID InitializeListHead (PLIST_ENTRY ListHead)
 
FORCEINLINE VOID InsertTailList (PLIST_ENTRY ListHead, PLIST_ENTRY Entry)
 
NTSTATUS WINAPI ChkdskEx (PUNICODE_STRING DriveRoot, BOOLEAN FixErrors, BOOLEAN Verbose, BOOLEAN CheckOnlyIfDirty, BOOLEAN ScanDrive, PFMIFSCALLBACK Callback)
 
static btrfs_root * add_root (LIST_ENTRY *roots, uint64_t id)
 
static void free_roots (LIST_ENTRY *roots)
 
static void free_chunks (LIST_ENTRY *chunks)
 
static void add_item (btrfs_root *r, uint64_t obj_id, uint8_t obj_type, uint64_t offset, void *data, uint16_t size)
 
static uint64_t find_chunk_offset (uint64_t size, uint64_t offset, btrfs_dev *dev, btrfs_root *dev_root, BTRFS_UUID *chunkuuid)
 
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)
 
static bool superblock_collision (btrfs_chunk *c, uint64_t address)
 
static uint64_t get_next_address (btrfs_chunk *c)
 
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)
 
static NTSTATUS write_data (HANDLE h, uint64_t address, btrfs_chunk *c, void *data, ULONG size)
 
static void calc_tree_checksum (tree_header *th, uint32_t node_size)
 
static NTSTATUS write_roots (HANDLE h, LIST_ENTRY *roots, uint32_t node_size, BTRFS_UUID *fsuuid, BTRFS_UUID *chunkuuid)
 
static void get_uuid (BTRFS_UUID *uuid)
 
static void init_device (btrfs_dev *dev, uint64_t id, uint64_t size, BTRFS_UUID *fsuuid, uint32_t sector_size)
 
static void calc_superblock_checksum (superblock *sb)
 
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_t node_size, BTRFS_UUID *fsuuid, uint32_t sector_size, PUNICODE_STRING label, uint64_t incompat_flags)
 
static __inline void win_time_to_unix (LARGE_INTEGER t, BTRFS_TIME *out)
 
static void add_inode_ref (btrfs_root *r, uint64_t inode, uint64_t parent, uint64_t index, const char *name)
 
static void init_fs_tree (btrfs_root *r, uint32_t node_size)
 
static void add_block_group_items (LIST_ENTRY *chunks, btrfs_root *extent_root)
 
static NTSTATUS clear_first_megabyte (HANDLE h)
 
static bool is_ssd (HANDLE h)
 
static void add_dir_item (btrfs_root *root, uint64_t inode, uint32_t hash, uint64_t key_objid, uint8_t key_type, uint64_t key_offset, uint64_t transid, uint8_t type, const char *name)
 
static void set_default_subvol (btrfs_root *root_root, uint32_t node_size)
 
static NTSTATUS write_btrfs (HANDLE h, uint64_t size, PUNICODE_STRING label, uint32_t sector_size, uint32_t node_size, uint64_t incompat_flags)
 
static bool look_for_device (btrfs_filesystem *bfs, BTRFS_UUID *devuuid)
 
static bool check_superblock_checksum (superblock *sb)
 
static bool is_mounted_multi_device (HANDLE h, uint32_t sector_size)
 
static void do_full_trim (HANDLE h)
 
static bool is_power_of_two (ULONG i)
 
static NTSTATUS NTAPI FormatEx2 (PUNICODE_STRING DriveRoot, FMIFS_MEDIA_FLAG MediaFlag, PUNICODE_STRING Label, BOOLEAN QuickFormat, ULONG ClusterSize, PFMIFSCALLBACK Callback)
 
BOOL __stdcall FormatEx (DSTRING *root, STREAM_MESSAGE *message, options *opts, uint32_t unk1)
 
void __stdcall SetSizes (ULONG sector, ULONG node)
 
void __stdcall SetIncompatFlags (uint64_t incompat_flags)
 
void __stdcall SetCsumType (uint16_t csum_type)
 
BOOL __stdcall GetFilesystemInformation (uint32_t unk1, uint32_t unk2, void *unk3)
 
BOOL APIENTRY DllMain (HANDLE hModule, DWORD dwReason, void *lpReserved)
 

Variables

HMODULE module
 
ULONG def_sector_size = 0
 
ULONG def_node_size = 0
 
uint64_t def_incompat_flags = BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA
 
uint16_t def_csum_type = CSUM_TYPE_CRC32C
 

Macro Definition Documentation

◆ BLAKE2_HASH_SIZE

#define BLAKE2_HASH_SIZE   32

Definition at line 70 of file btrfslib.c.

◆ DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED

#define DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED   0x80000000

Definition at line 79 of file btrfslib.c.

◆ FORMAT_FLAG_DISMOUNT_FIRST

#define FORMAT_FLAG_DISMOUNT_FIRST   0x00000004

Definition at line 108 of file btrfslib.c.

◆ FORMAT_FLAG_INTEGRITY_DISABLE

#define FORMAT_FLAG_INTEGRITY_DISABLE   0x00000100

Definition at line 111 of file btrfslib.c.

◆ FORMAT_FLAG_LARGE_RECORDS

#define FORMAT_FLAG_LARGE_RECORDS   0x00000100

Definition at line 110 of file btrfslib.c.

◆ FORMAT_FLAG_QUICK_FORMAT

#define FORMAT_FLAG_QUICK_FORMAT   0x00000001

Definition at line 106 of file btrfslib.c.

◆ FORMAT_FLAG_UNKNOWN1

#define FORMAT_FLAG_UNKNOWN1   0x00000002

Definition at line 107 of file btrfslib.c.

◆ FORMAT_FLAG_UNKNOWN2

#define FORMAT_FLAG_UNKNOWN2   0x00000040

Definition at line 109 of file btrfslib.c.

◆ FSCTL_DISMOUNT_VOLUME

#define FSCTL_DISMOUNT_VOLUME   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 76 of file btrfslib.c.

◆ FSCTL_LOCK_VOLUME

#define FSCTL_LOCK_VOLUME   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 74 of file btrfslib.c.

◆ FSCTL_UNLOCK_VOLUME

#define FSCTL_UNLOCK_VOLUME   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 75 of file btrfslib.c.

◆ keycmp

#define keycmp (   key1,
  key2 
)
Value:
((key1.obj_id < key2.obj_id) ? -1 :\
((key1.obj_id > key2.obj_id) ? 1 :\
((key1.obj_type < key2.obj_type) ? -1 :\
((key1.obj_type > key2.obj_type) ? 1 :\
((key1.offset < key2.offset) ? -1 :\
((key1.offset > key2.offset) ? 1 :\
0))))))
key1
GLuint64EXT GLuint GLuint GLenum GLenum GLuint GLuint GLenum GLuint GLuint key1
Definition: glext.h:10608

Definition at line 168 of file btrfslib.c.

◆ SHA256_HASH_SIZE

#define SHA256_HASH_SIZE   32

Definition at line 67 of file btrfslib.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 22 of file btrfslib.c.

Typedef Documentation

◆ PFMIFSCALLBACK

typedef BOOLEAN(NTAPI * PFMIFSCALLBACK) (CALLBACKCOMMAND Command, ULONG SubAction, PVOID ActionInfo)

Definition at line 237 of file btrfslib.c.

◆ PTEXTOUTPUT

typedef struct TEXTOUTPUT * PTEXTOUTPUT

Enumeration Type Documentation

◆ CALLBACKCOMMAND

enum CALLBACKCOMMAND
Enumerator
PROGRESS 
DONEWITHSTRUCTURE 
UNKNOWN2 
UNKNOWN3 
UNKNOWN4 
UNKNOWN5 
INSUFFICIENTRIGHTS 
FSNOTSUPPORTED 
VOLUMEINUSE 
UNKNOWN9 
UNKNOWNA 
DONE 
UNKNOWNC 
UNKNOWND 
OUTPUT 
STRUCTUREPROGRESS 
CLUSTERSIZETOOSMALL 
PROGRESS 
DONEWITHSTRUCTURE 
UNKNOWN2 
UNKNOWN3 
UNKNOWN4 
UNKNOWN5 
INSUFFICIENTRIGHTS 
FSNOTSUPPORTED 
VOLUMEINUSE 
UNKNOWN9 
UNKNOWNA 
DONE 
UNKNOWNC 
UNKNOWND 
OUTPUT 
STRUCTUREPROGRESS 
CLUSTERSIZETOOSMALL 

Definition at line 217 of file btrfslib.c.

217 {
218 PROGRESS,
219 DONEWITHSTRUCTURE,
220 UNKNOWN2,
221 UNKNOWN3,
222 UNKNOWN4,
223 UNKNOWN5,
224 INSUFFICIENTRIGHTS,
225 FSNOTSUPPORTED,
226 VOLUMEINUSE,
227 UNKNOWN9,
228 UNKNOWNA,
229 DONE,
230 UNKNOWNC,
231 UNKNOWND,
232 OUTPUT,
233 STRUCTUREPROGRESS,
234 CLUSTERSIZETOOSMALL,
235} CALLBACKCOMMAND;
CALLBACKCOMMAND
CALLBACKCOMMAND
Definition: btrfslib.c:217
UNKNOWN9
@ UNKNOWN9
Definition: btrfslib.c:227
OUTPUT
@ OUTPUT
Definition: btrfslib.c:232
FSNOTSUPPORTED
@ FSNOTSUPPORTED
Definition: btrfslib.c:225
UNKNOWND
@ UNKNOWND
Definition: btrfslib.c:231
VOLUMEINUSE
@ VOLUMEINUSE
Definition: btrfslib.c:226
UNKNOWN4
@ UNKNOWN4
Definition: btrfslib.c:222
UNKNOWNA
@ UNKNOWNA
Definition: btrfslib.c:228
STRUCTUREPROGRESS
@ STRUCTUREPROGRESS
Definition: btrfslib.c:233
DONE
@ DONE
Definition: btrfslib.c:229
CLUSTERSIZETOOSMALL
@ CLUSTERSIZETOOSMALL
Definition: btrfslib.c:234
DONEWITHSTRUCTURE
@ DONEWITHSTRUCTURE
Definition: btrfslib.c:219
INSUFFICIENTRIGHTS
@ INSUFFICIENTRIGHTS
Definition: btrfslib.c:224
PROGRESS
@ PROGRESS
Definition: btrfslib.c:218
UNKNOWN5
@ UNKNOWN5
Definition: btrfslib.c:223
UNKNOWN2
@ UNKNOWN2
Definition: btrfslib.c:220
UNKNOWN3
@ UNKNOWN3
Definition: btrfslib.c:221
UNKNOWNC
@ UNKNOWNC
Definition: btrfslib.c:230

◆ FMIFS_MEDIA_FLAG

enum FMIFS_MEDIA_FLAG
Enumerator
FMIFS_UNKNOWN0 
FMIFS_UNKNOWN1 
FMIFS_UNKNOWN2 
FMIFS_UNKNOWN3 
FMIFS_UNKNOWN4 
FMIFS_UNKNOWN5 
FMIFS_UNKNOWN6 
FMIFS_UNKNOWN7 
FMIFS_FLOPPY 
FMIFS_UNKNOWN9 
FMIFS_UNKNOWN10 
FMIFS_REMOVABLE 
FMIFS_HARDDISK 
FMIFS_UNKNOWN13 
FMIFS_UNKNOWN14 
FMIFS_UNKNOWN15 
FMIFS_UNKNOWN16 
FMIFS_UNKNOWN17 
FMIFS_UNKNOWN18 
FMIFS_UNKNOWN19 
FMIFS_UNKNOWN20 
FMIFS_UNKNOWN21 
FMIFS_UNKNOWN22 
FMIFS_UNKNOWN23 
FMIFS_UNKNOWN0 
FMIFS_UNKNOWN1 
FMIFS_UNKNOWN2 
FMIFS_UNKNOWN3 
FMIFS_UNKNOWN4 
FMIFS_UNKNOWN5 
FMIFS_UNKNOWN6 
FMIFS_UNKNOWN7 
FMIFS_FLOPPY 
FMIFS_UNKNOWN9 
FMIFS_UNKNOWN10 
FMIFS_REMOVABLE 
FMIFS_HARDDISK 
FMIFS_UNKNOWN13 
FMIFS_UNKNOWN14 
FMIFS_UNKNOWN15 
FMIFS_UNKNOWN16 
FMIFS_UNKNOWN17 
FMIFS_UNKNOWN18 
FMIFS_UNKNOWN19 
FMIFS_UNKNOWN20 
FMIFS_UNKNOWN21 
FMIFS_UNKNOWN22 
FMIFS_UNKNOWN23 

Definition at line 190 of file btrfslib.c.

190 {
191 FMIFS_UNKNOWN0,
192 FMIFS_UNKNOWN1,
193 FMIFS_UNKNOWN2,
194 FMIFS_UNKNOWN3,
195 FMIFS_UNKNOWN4,
196 FMIFS_UNKNOWN5,
197 FMIFS_UNKNOWN6,
198 FMIFS_UNKNOWN7,
199 FMIFS_FLOPPY,
200 FMIFS_UNKNOWN9,
201 FMIFS_UNKNOWN10,
202 FMIFS_REMOVABLE,
203 FMIFS_HARDDISK,
204 FMIFS_UNKNOWN13,
205 FMIFS_UNKNOWN14,
206 FMIFS_UNKNOWN15,
207 FMIFS_UNKNOWN16,
208 FMIFS_UNKNOWN17,
209 FMIFS_UNKNOWN18,
210 FMIFS_UNKNOWN19,
211 FMIFS_UNKNOWN20,
212 FMIFS_UNKNOWN21,
213 FMIFS_UNKNOWN22,
214 FMIFS_UNKNOWN23,
215} FMIFS_MEDIA_FLAG;
FMIFS_MEDIA_FLAG
FMIFS_MEDIA_FLAG
Definition: btrfslib.c:190
FMIFS_UNKNOWN14
@ FMIFS_UNKNOWN14
Definition: btrfslib.c:205
FMIFS_UNKNOWN23
@ FMIFS_UNKNOWN23
Definition: btrfslib.c:214
FMIFS_UNKNOWN13
@ FMIFS_UNKNOWN13
Definition: btrfslib.c:204
FMIFS_UNKNOWN22
@ FMIFS_UNKNOWN22
Definition: btrfslib.c:213
FMIFS_UNKNOWN17
@ FMIFS_UNKNOWN17
Definition: btrfslib.c:208
FMIFS_UNKNOWN4
@ FMIFS_UNKNOWN4
Definition: btrfslib.c:195
FMIFS_UNKNOWN1
@ FMIFS_UNKNOWN1
Definition: btrfslib.c:192
FMIFS_FLOPPY
@ FMIFS_FLOPPY
Definition: btrfslib.c:199
FMIFS_UNKNOWN3
@ FMIFS_UNKNOWN3
Definition: btrfslib.c:194
FMIFS_UNKNOWN10
@ FMIFS_UNKNOWN10
Definition: btrfslib.c:201
FMIFS_UNKNOWN18
@ FMIFS_UNKNOWN18
Definition: btrfslib.c:209
FMIFS_UNKNOWN0
@ FMIFS_UNKNOWN0
Definition: btrfslib.c:191
FMIFS_UNKNOWN21
@ FMIFS_UNKNOWN21
Definition: btrfslib.c:212
FMIFS_UNKNOWN15
@ FMIFS_UNKNOWN15
Definition: btrfslib.c:206
FMIFS_UNKNOWN16
@ FMIFS_UNKNOWN16
Definition: btrfslib.c:207
FMIFS_UNKNOWN7
@ FMIFS_UNKNOWN7
Definition: btrfslib.c:198
FMIFS_UNKNOWN20
@ FMIFS_UNKNOWN20
Definition: btrfslib.c:211
FMIFS_UNKNOWN19
@ FMIFS_UNKNOWN19
Definition: btrfslib.c:210
FMIFS_UNKNOWN6
@ FMIFS_UNKNOWN6
Definition: btrfslib.c:197
FMIFS_REMOVABLE
@ FMIFS_REMOVABLE
Definition: btrfslib.c:202
FMIFS_UNKNOWN5
@ FMIFS_UNKNOWN5
Definition: btrfslib.c:196
FMIFS_UNKNOWN9
@ FMIFS_UNKNOWN9
Definition: btrfslib.c:200
FMIFS_HARDDISK
@ FMIFS_HARDDISK
Definition: btrfslib.c:203
FMIFS_UNKNOWN2
@ FMIFS_UNKNOWN2
Definition: btrfslib.c:193

Function Documentation

◆ add_block_group_items()

static void add_block_group_items ( LIST_ENTRY *  chunks,
btrfs_root *  extent_root 
)
static

Definition at line 940 of file btrfslib.c.

940 {
941 LIST_ENTRY* le;
942
943 le = chunks->Flink;
944 while (le != chunks) {
945 btrfs_chunk* c = CONTAINING_RECORD(le, btrfs_chunk, list_entry);
946 BLOCK_GROUP_ITEM bgi;
947
948 bgi.used = c->used;
949 bgi.chunk_tree = 0x100;
950 bgi.flags = c->chunk_item->type;
951 add_item(extent_root, c->offset, TYPE_BLOCK_GROUP_ITEM, c->chunk_item->size, &bgi, sizeof(BLOCK_GROUP_ITEM));
952
953 le = le->Flink;
954 }
955}
add_item
static void add_item(btrfs_root *r, uint64_t obj_id, uint8_t obj_type, uint64_t offset, void *data, uint16_t size)
Definition: btrfslib.c:339
TYPE_BLOCK_GROUP_ITEM
#define TYPE_BLOCK_GROUP_ITEM
Definition: btrfs.h:42
c
const GLubyte * c
Definition: glext.h:8905
BLOCK_GROUP_ITEM
Definition: btrfs.h:423
BLOCK_GROUP_ITEM::chunk_tree
uint64_t chunk_tree
Definition: btrfs.h:425
BLOCK_GROUP_ITEM::flags
uint64_t flags
Definition: btrfs.h:426
BLOCK_GROUP_ITEM::used
uint64_t used
Definition: btrfs.h:424
_LIST_ENTRY
Definition: typedefs.h:120
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
btrfs_chunk
Definition: btrfs.h:184
list_entry
Definition: list.h:27
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by write_btrfs().

◆ add_chunk()

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 
)
static

Definition at line 392 of file btrfslib.c.

392 {
393 uint64_t off, size;
394 uint16_t stripes, i;
395 btrfs_chunk* c;
396 LIST_ENTRY* le;
397 CHUNK_ITEM_STRIPE* cis;
398
399 off = 0xc00000;
400 le = chunks->Flink;
401 while (le != chunks) {
402 c = CONTAINING_RECORD(le, btrfs_chunk, list_entry);
403
404 if (c->offset + c->chunk_item->size > off)
405 off = c->offset + c->chunk_item->size;
406
407 le = le->Flink;
408 }
409
410 if (flags & BLOCK_FLAG_METADATA) {
411 if (dev->dev_item.num_bytes > 0xC80000000) // 50 GB
412 size = 0x40000000; // 1 GB
413 else
414 size = 0x10000000; // 256 MB
415 } else if (flags & BLOCK_FLAG_SYSTEM)
416 size = 0x800000;
417
418 size = min(size, dev->dev_item.num_bytes / 10); // cap at 10%
419 size &= ~(sector_size - 1);
420
421 stripes = flags & BLOCK_FLAG_DUPLICATE ? 2 : 1;
422
423 if (dev->dev_item.num_bytes - dev->dev_item.bytes_used < stripes * size) // not enough space
424 return NULL;
425
426 c = malloc(sizeof(btrfs_chunk));
427 c->offset = off;
428 c->lastoff = off;
429 c->used = 0;
430
431 c->chunk_item = malloc(sizeof(CHUNK_ITEM) + (stripes * sizeof(CHUNK_ITEM_STRIPE)));
432
433 c->chunk_item->size = size;
434 c->chunk_item->root_id = BTRFS_ROOT_EXTENT;
435 c->chunk_item->stripe_length = max(sector_size, 0x10000);
436 c->chunk_item->type = flags;
437 c->chunk_item->opt_io_alignment = max(sector_size, 0x10000);
438 c->chunk_item->opt_io_width = max(sector_size, 0x10000);
439 c->chunk_item->sector_size = sector_size;
440 c->chunk_item->num_stripes = stripes;
441 c->chunk_item->sub_stripes = 0;
442
443 cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
444
445 for (i = 0; i < stripes; i++) {
446 cis[i].dev_id = dev->dev_item.dev_id;
447 cis[i].offset = find_chunk_offset(size, c->offset, dev, dev_root, chunkuuid);
448 cis[i].dev_uuid = dev->dev_item.device_uuid;
449 }
450
451 add_item(chunk_root, 0x100, TYPE_CHUNK_ITEM, c->offset, c->chunk_item, sizeof(CHUNK_ITEM) + (stripes * sizeof(CHUNK_ITEM_STRIPE)));
452
453 InsertTailList(chunks, &c->list_entry);
454
455 return c;
456}
uint16_t
unsigned short int uint16_t
Definition: acefiex.h:54
find_chunk_offset
static uint64_t find_chunk_offset(uint64_t size, uint64_t offset, btrfs_dev *dev, btrfs_root *dev_root, BTRFS_UUID *chunkuuid)
Definition: btrfslib.c:372
malloc
#define malloc
Definition: debug_ros.c:4
NULL
#define NULL
Definition: types.h:112
uint64_t
UINT64 uint64_t
Definition: types.h:77
TYPE_CHUNK_ITEM
#define TYPE_CHUNK_ITEM
Definition: btrfs.h:48
BTRFS_ROOT_EXTENT
#define BTRFS_ROOT_EXTENT
Definition: btrfs.h:55
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
size
GLsizeiptr size
Definition: glext.h:5919
flags
GLbitfield flags
Definition: glext.h:7161
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
c
#define c
Definition: ke_i.h:80
sector_size
__u8 sector_size[2]
Definition: mkdosfs.c:3
for
#define for
Definition: utility.h:88
min
#define min(a, b)
Definition: monoChain.cc:55
BLOCK_FLAG_DUPLICATE
#define BLOCK_FLAG_DUPLICATE
Definition: shellext.h:80
BLOCK_FLAG_SYSTEM
#define BLOCK_FLAG_SYSTEM
Definition: shellext.h:76
BLOCK_FLAG_METADATA
#define BLOCK_FLAG_METADATA
Definition: shellext.h:77
CHUNK_ITEM_STRIPE
Definition: btrfs.h:351
CHUNK_ITEM_STRIPE::dev_uuid
BTRFS_UUID dev_uuid
Definition: btrfs.h:354
CHUNK_ITEM_STRIPE::offset
uint64_t offset
Definition: btrfs.h:353
CHUNK_ITEM_STRIPE::dev_id
uint64_t dev_id
Definition: btrfs.h:352
CHUNK_ITEM
Definition: btrfs.h:339
dev::dev_id
uint64_t dev_id
Definition: volpropsheet.cpp:159
max
#define max(a, b)
Definition: svc.c:63

Referenced by write_btrfs().

◆ add_dir_item()

static void add_dir_item ( btrfs_root *  root,
uint64_t  inode,
uint32_t  hash,
uint64_t  key_objid,
uint8_t  key_type,
uint64_t  key_offset,
uint64_t  transid,
uint8_t  type,
const char *  name 
)
static

Definition at line 1010 of file btrfslib.c.

1011 {
1012 uint16_t name_len = (uint16_t)strlen(name);
1013 DIR_ITEM* di = malloc(offsetof(DIR_ITEM, name[0]) + name_len);
1014
1015 di->key.obj_id = key_objid;
1016 di->key.obj_type = key_type;
1017 di->key.offset = key_offset;
1018 di->transid = transid;
1019 di->m = 0;
1020 di->n = name_len;
1021 di->type = type;
1022 memcpy(di->name, name, name_len);
1023
1024 add_item(root, inode, TYPE_DIR_ITEM, hash, di, (uint16_t)(offsetof(DIR_ITEM, name[0]) + di->m + di->n));
1025
1026 free(di);
1027}
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
free
#define free
Definition: debug_ros.c:5
TYPE_DIR_ITEM
#define TYPE_DIR_ITEM
Definition: btrfs.h:28
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
uint16_t
#define uint16_t
Definition: nsiface.idl:60
offsetof
#define offsetof(TYPE, MEMBER)
Definition: sdbstringtable.c:26
DIR_ITEM
Definition: btrfs.h:272
DIR_ITEM::m
uint16_t m
Definition: btrfs.h:275
DIR_ITEM::type
uint8_t type
Definition: btrfs.h:277
DIR_ITEM::name
char name[1]
Definition: btrfs.h:278
DIR_ITEM::transid
uint64_t transid
Definition: btrfs.h:274
DIR_ITEM::n
uint16_t n
Definition: btrfs.h:276
DIR_ITEM::key
KEY key
Definition: btrfs.h:273
KEY::obj_type
uint8_t obj_type
Definition: btrfs.h:145
KEY::obj_id
uint64_t obj_id
Definition: btrfs.h:144
KEY::offset
uint64_t offset
Definition: btrfs.h:146
_root
Definition: btrfs_drv.h:450
hash
Definition: _hash_fun.h:40
inode
Definition: fs.h:78
name
Definition: name.c:39

Referenced by set_default_subvol().

◆ add_inode_ref()

static void add_inode_ref ( btrfs_root *  r,
uint64_t  inode,
uint64_t  parent,
uint64_t  index,
const char *  name 
)
static

Definition at line 903 of file btrfslib.c.

903 {
904 uint16_t name_len = (uint16_t)strlen(name);
905 INODE_REF* ir = malloc(offsetof(INODE_REF, name[0]) + name_len);
906
907 ir->index = 0;
908 ir->n = name_len;
909 memcpy(ir->name, name, name_len);
910
911 add_item(r, inode, TYPE_INODE_REF, parent, ir, (uint16_t)offsetof(INODE_REF, name[0]) + ir->n);
912
913 free(ir);
914}
parent
r parent
Definition: btrfs.c:3010
TYPE_INODE_REF
#define TYPE_INODE_REF
Definition: btrfs.h:24
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
INODE_REF
Definition: btrfs.h:374
INODE_REF::index
uint64_t index
Definition: btrfs.h:375
INODE_REF::name
char name[1]
Definition: btrfs.h:377
INODE_REF::n
uint16_t n
Definition: btrfs.h:376

Referenced by init_fs_tree(), and set_default_subvol().

◆ add_item()

static void add_item ( btrfs_root *  r,
uint64_t  obj_id,
uint8_t  obj_type,
uint64_t  offset,
void *  data,
uint16_t  size 
)
static

Definition at line 339 of file btrfslib.c.

339 {
340 LIST_ENTRY* le;
341 btrfs_item* item;
342
343 item = malloc(sizeof(btrfs_item));
344
345 item->key.obj_id = obj_id;
346 item->key.obj_type = obj_type;
347 item->key.offset = offset;
348 item->size = size;
349
350 if (size == 0)
351 item->data = NULL;
352 else {
353 item->data = malloc(size);
354 memcpy(item->data, data, size);
355 }
356
357 le = r->items.Flink;
358 while (le != &r->items) {
359 btrfs_item* i2 = CONTAINING_RECORD(le, btrfs_item, list_entry);
360
361 if (keycmp(item->key, i2->key) != 1) {
362 InsertTailList(le, &item->list_entry);
363 return;
364 }
365
366 le = le->Flink;
367 }
368
369 InsertTailList(&r->items, &item->list_entry);
370}
keycmp
#define keycmp(key1, key2)
Definition: btrfslib.c:168
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
offset
GLintptr offset
Definition: glext.h:5920
item
static ATOM item
Definition: dde.c:856
btrfs_item
Definition: btrfs.h:109
btrfs_item::key
struct btrfs_disk_key key
Definition: btrfs.h:110

Referenced by add_block_group_items(), add_chunk(), add_dir_item(), add_inode_ref(), assign_addresses(), find_chunk_offset(), init_fs_tree(), set_default_subvol(), and write_btrfs().

◆ add_root()

static btrfs_root * add_root ( LIST_ENTRY *  roots,
uint64_t  id 
)
static

Definition at line 284 of file btrfslib.c.

284 {
285 btrfs_root* root;
286
287 root = malloc(sizeof(btrfs_root));
288
289 root->id = id;
290 RtlZeroMemory(&root->header, sizeof(tree_header));
291 InitializeListHead(&root->items);
292 InsertTailList(roots, &root->list_entry);
293
294 return root;
295}
root
struct _root root
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
id
GLuint id
Definition: glext.h:5910
_root::id
uint64_t id
Definition: btrfs_drv.h:451
_root::list_entry
LIST_ENTRY list_entry
Definition: btrfs_drv.h:466
btrfs_root
Definition: btrfslib.c:155
tree_header
Definition: btrfs.h:153
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

Referenced by look_for_roots(), mount_vol(), and write_btrfs().

◆ assign_addresses()

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 
)
static

Definition at line 507 of file btrfslib.c.

508 {
509 LIST_ENTRY* le;
510
511 le = roots->Flink;
512 while (le != roots) {
513 btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry);
514 btrfs_chunk* c = r->id == BTRFS_ROOT_CHUNK ? sys_chunk : metadata_chunk;
515
516 r->header.address = get_next_address(c);
517 r->c = c;
518 c->lastoff = r->header.address + node_size;
519 c->used += node_size;
520
521 if (skinny) {
522 EXTENT_ITEM_METADATA eim;
523
524 eim.ei.refcount = 1;
525 eim.ei.generation = 1;
526 eim.ei.flags = EXTENT_ITEM_TREE_BLOCK;
527 eim.type = TYPE_TREE_BLOCK_REF;
528 eim.tbr.offset = r->id;
529
530 add_item(extent_root, r->header.address, TYPE_METADATA_ITEM, 0, &eim, sizeof(EXTENT_ITEM_METADATA));
531 } else {
532 EXTENT_ITEM_METADATA2 eim2;
533 KEY firstitem;
534
535 if (r->items.Flink == &r->items) {
536 firstitem.obj_id = 0;
537 firstitem.obj_type = 0;
538 firstitem.offset = 0;
539 } else {
540 btrfs_item* bi = CONTAINING_RECORD(r->items.Flink, btrfs_item, list_entry);
541
542 firstitem = bi->key;
543 }
544
545 eim2.ei.refcount = 1;
546 eim2.ei.generation = 1;
547 eim2.ei.flags = EXTENT_ITEM_TREE_BLOCK;
548 eim2.ei2.firstitem = firstitem;
549 eim2.ei2.level = 0;
550 eim2.type = TYPE_TREE_BLOCK_REF;
551 eim2.tbr.offset = r->id;
552
553 add_item(extent_root, r->header.address, TYPE_EXTENT_ITEM, node_size, &eim2, sizeof(EXTENT_ITEM_METADATA2));
554 }
555
556 if (r->id != BTRFS_ROOT_ROOT && r->id != BTRFS_ROOT_CHUNK) {
557 ROOT_ITEM ri;
558
559 memset(&ri, 0, sizeof(ROOT_ITEM));
560
561 ri.inode.generation = 1;
562 ri.inode.st_size = 3;
563 ri.inode.st_blocks = node_size;
564 ri.inode.st_nlink = 1;
565 ri.inode.st_mode = 040755;
566 ri.generation = 1;
567 ri.objid = r->id == 5 || r->id >= 0x100 ? SUBVOL_ROOT_INODE : 0;
568 ri.block_number = r->header.address;
569 ri.bytes_used = node_size;
570 ri.num_references = 1;
571 ri.generation2 = ri.generation;
572
573 add_item(root_root, r->id, TYPE_ROOT_ITEM, 0, &ri, sizeof(ROOT_ITEM));
574 }
575
576 le = le->Flink;
577 }
578}
get_next_address
static uint64_t get_next_address(btrfs_chunk *c)
Definition: btrfslib.c:479
TYPE_EXTENT_ITEM
#define TYPE_EXTENT_ITEM
Definition: btrfs.h:35
EXTENT_ITEM_TREE_BLOCK
#define EXTENT_ITEM_TREE_BLOCK
Definition: btrfs.h:388
TYPE_TREE_BLOCK_REF
#define TYPE_TREE_BLOCK_REF
Definition: btrfs.h:37
BTRFS_ROOT_CHUNK
#define BTRFS_ROOT_CHUNK
Definition: btrfs.h:56
BTRFS_ROOT_ROOT
#define BTRFS_ROOT_ROOT
Definition: btrfs.h:54
TYPE_ROOT_ITEM
#define TYPE_ROOT_ITEM
Definition: btrfs.h:32
TYPE_METADATA_ITEM
#define TYPE_METADATA_ITEM
Definition: btrfs.h:36
SUBVOL_ROOT_INODE
#define SUBVOL_ROOT_INODE
Definition: propsheet.cpp:42
memset
#define memset(x, y, z)
Definition: compat.h:39
EXTENT_ITEM2::firstitem
KEY firstitem
Definition: btrfs.h:398
EXTENT_ITEM2::level
uint8_t level
Definition: btrfs.h:399
EXTENT_ITEM_METADATA2
Definition: btrfslib.c:500
EXTENT_ITEM_METADATA2::ei
EXTENT_ITEM ei
Definition: btrfslib.c:501
EXTENT_ITEM_METADATA2::ei2
EXTENT_ITEM2 ei2
Definition: btrfslib.c:502
EXTENT_ITEM_METADATA2::tbr
TREE_BLOCK_REF tbr
Definition: btrfslib.c:504
EXTENT_ITEM_METADATA2::type
uint8_t type
Definition: btrfslib.c:503
EXTENT_ITEM_METADATA
Definition: btrfslib.c:494
EXTENT_ITEM_METADATA::type
uint8_t type
Definition: btrfslib.c:496
EXTENT_ITEM_METADATA::tbr
TREE_BLOCK_REF tbr
Definition: btrfslib.c:497
EXTENT_ITEM_METADATA::ei
EXTENT_ITEM ei
Definition: btrfslib.c:495
EXTENT_ITEM::generation
uint64_t generation
Definition: btrfs.h:393
EXTENT_ITEM::flags
uint64_t flags
Definition: btrfs.h:394
EXTENT_ITEM::refcount
uint64_t refcount
Definition: btrfs.h:392
INODE_ITEM::st_mode
uint32_t st_mode
Definition: btrfs.h:295
INODE_ITEM::st_nlink
uint32_t st_nlink
Definition: btrfs.h:292
INODE_ITEM::st_size
uint64_t st_size
Definition: btrfs.h:289
INODE_ITEM::st_blocks
uint64_t st_blocks
Definition: btrfs.h:290
INODE_ITEM::generation
uint64_t generation
Definition: btrfs.h:287
KEY
Definition: btrfs.h:143
ROOT_ITEM
Definition: btrfs.h:311
ROOT_ITEM::bytes_used
uint64_t bytes_used
Definition: btrfs.h:317
ROOT_ITEM::num_references
uint32_t num_references
Definition: btrfs.h:320
ROOT_ITEM::objid
uint64_t objid
Definition: btrfs.h:314
ROOT_ITEM::block_number
uint64_t block_number
Definition: btrfs.h:315
ROOT_ITEM::generation2
uint64_t generation2
Definition: btrfs.h:324
ROOT_ITEM::generation
uint64_t generation
Definition: btrfs.h:313
ROOT_ITEM::inode
INODE_ITEM inode
Definition: btrfs.h:312
TREE_BLOCK_REF::offset
uint64_t offset
Definition: btrfs.h:413
sys_chunk
Definition: btrfs_drv.h:620

Referenced by write_btrfs().

◆ blake2b()

void blake2b ( void *  out,
size_t  outlen,
const void *  in,
size_t  inlen 
)

Definition at line 237 of file blake2b-ref.c.

238{
239 blake2b_state S[1];
240
241 blake2b_init( S, outlen );
242
243 blake2b_update( S, ( const uint8_t * )in, inlen );
244 blake2b_final( S, out, outlen );
245}
blake2b_final
static int blake2b_final(blake2b_state *S, void *out, size_t outlen)
Definition: blake2b-ref.c:212
blake2b_init
static void blake2b_init(blake2b_state *S, size_t outlen)
Definition: blake2b-ref.c:97
blake2b_update
static int blake2b_update(blake2b_state *S, const void *in, size_t inlen)
Definition: blake2b-ref.c:185
in
GLuint in
Definition: glext.h:9616
uint8_t
BYTE uint8_t
Definition: msvideo1.c:66
out
static FILE * out
Definition: regtests2xml.c:44
S
Definition: movable.cpp:9
blake2b_state__
Definition: blake2-impl.h:170

Referenced by calc_superblock_checksum(), calc_thread_main(), calc_tree_checksum(), check_sector_csum(), check_superblock_checksum(), check_tree_checksum(), get_sector_csum(), and get_tree_checksum().

◆ calc_sha256()

void calc_sha256 ( uint8_t *  hash,
const void *  input,
size_t  len 
)

Definition at line 126 of file sha256.c.

127{
128 /*
129 * Note 1: All integers (expect indexes) are 32-bit unsigned integers and addition is calculated modulo 2^32.
130 * Note 2: For each round, there is one round constant k[i] and one entry in the message schedule array w[i], 0 = i = 63
131 * Note 3: The compression function uses 8 working variables, a through h
132 * Note 4: Big-endian convention is used when expressing the constants in this pseudocode,
133 * and when parsing message block data from bytes to words, for example,
134 * the first word of the input message "abc" after padding is 0x61626380
135 */
136
137 /*
138 * Initialize hash values:
139 * (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
140 */
141 uint32_t h[] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
142 unsigned i, j;
143
144 /* 512-bit chunks is what we will operate on. */
145 uint8_t chunk[64];
146
147 struct buffer_state state;
148
149 init_buf_state(&state, input, len);
150
151 while (calc_chunk(chunk, &state)) {
152 uint32_t ah[8];
153
154 const uint8_t *p = chunk;
155
156 /* Initialize working variables to current hash value: */
157 for (i = 0; i < 8; i++)
158 ah[i] = h[i];
159
160 /* Compression function main loop: */
161 for (i = 0; i < 4; i++) {
162 /*
163 * The w-array is really w[64], but since we only need
164 * 16 of them at a time, we save stack by calculating
165 * 16 at a time.
166 *
167 * This optimization was not there initially and the
168 * rest of the comments about w[64] are kept in their
169 * initial state.
170 */
171
172 /*
173 * create a 64-entry message schedule array w[0..63] of 32-bit words
174 * (The initial values in w[0..63] don't matter, so many implementations zero them here)
175 * copy chunk into first 16 words w[0..15] of the message schedule array
176 */
177 uint32_t w[16];
178
179 for (j = 0; j < 16; j++) {
180 if (i == 0) {
181 w[j] = (uint32_t) p[0] << 24 | (uint32_t) p[1] << 16 |
182 (uint32_t) p[2] << 8 | (uint32_t) p[3];
183 p += 4;
184 } else {
185 /* Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array: */
186 const uint32_t s0 = right_rot(w[(j + 1) & 0xf], 7) ^ right_rot(w[(j + 1) & 0xf], 18) ^ (w[(j + 1) & 0xf] >> 3);
187 const uint32_t s1 = right_rot(w[(j + 14) & 0xf], 17) ^ right_rot(w[(j + 14) & 0xf], 19) ^ (w[(j + 14) & 0xf] >> 10);
188 w[j] = w[j] + s0 + w[(j + 9) & 0xf] + s1;
189 }
190 {
191 const uint32_t s1 = right_rot(ah[4], 6) ^ right_rot(ah[4], 11) ^ right_rot(ah[4], 25);
192 const uint32_t ch = (ah[4] & ah[5]) ^ (~ah[4] & ah[6]);
193 const uint32_t temp1 = ah[7] + s1 + ch + k[i << 4 | j] + w[j];
194 const uint32_t s0 = right_rot(ah[0], 2) ^ right_rot(ah[0], 13) ^ right_rot(ah[0], 22);
195 const uint32_t maj = (ah[0] & ah[1]) ^ (ah[0] & ah[2]) ^ (ah[1] & ah[2]);
196 const uint32_t temp2 = s0 + maj;
197
198 ah[7] = ah[6];
199 ah[6] = ah[5];
200 ah[5] = ah[4];
201 ah[4] = ah[3] + temp1;
202 ah[3] = ah[2];
203 ah[2] = ah[1];
204 ah[1] = ah[0];
205 ah[0] = temp1 + temp2;
206 }
207 }
208 }
209
210 /* Add the compressed chunk to the current hash value: */
211 for (i = 0; i < 8; i++)
212 h[i] += ah[i];
213 }
214
215 /* Produce the final hash value (big-endian): */
216 for (i = 0, j = 0; i < 8; i++)
217 {
218 hash[j++] = (uint8_t) (h[i] >> 24);
219 hash[j++] = (uint8_t) (h[i] >> 16);
220 hash[j++] = (uint8_t) (h[i] >> 8);
221 hash[j++] = (uint8_t) h[i];
222 }
223}
state
static int state
Definition: maze.c:121
uint32_t
UINT32 uint32_t
Definition: types.h:75
right_rot
static uint32_t right_rot(uint32_t value, unsigned int count)
Definition: sha256.c:43
init_buf_state
static void init_buf_state(struct buffer_state *state, const void *input, size_t len)
Definition: sha256.c:52
k
static const uint32_t k[]
Definition: sha256.c:24
calc_chunk
static int calc_chunk(uint8_t chunk[CHUNK_SIZE], struct buffer_state *state)
Definition: sha256.c:62
p
GLfloat GLfloat p
Definition: glext.h:8902
len
GLenum GLsizei len
Definition: glext.h:6722
input
GLenum GLenum GLenum input
Definition: glext.h:9031
w
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
h
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
s1
struct S1 s1
uint32_t
#define uint32_t
Definition: nsiface.idl:61
uint8_t
#define uint8_t
Definition: nsiface.idl:59
buffer_state
Definition: sha256.c:35

Referenced by calc_superblock_checksum(), calc_tree_checksum(), and check_superblock_checksum().

◆ calc_superblock_checksum()

static void calc_superblock_checksum ( superblock *  sb)
static

Definition at line 732 of file btrfslib.c.

732 {
733 switch (def_csum_type) {
734 case CSUM_TYPE_CRC32C:
735 *(uint32_t*)sb = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
736 break;
737
738 case CSUM_TYPE_XXHASH:
739 *(uint64_t*)sb = XXH64(&sb->uuid, sizeof(superblock) - sizeof(sb->checksum), 0);
740 break;
741
742 case CSUM_TYPE_SHA256:
743 calc_sha256((uint8_t*)sb, &sb->uuid, sizeof(superblock) - sizeof(sb->checksum));
744 break;
745
746 case CSUM_TYPE_BLAKE2:
747 blake2b((uint8_t*)sb, BLAKE2_HASH_SIZE, &sb->uuid, sizeof(superblock) - sizeof(sb->checksum));
748 break;
749 }
750}
blake2b
void blake2b(void *out, size_t outlen, const void *in, size_t inlen)
Definition: blake2b-ref.c:237
def_csum_type
uint16_t def_csum_type
Definition: btrfslib.c:180
BLAKE2_HASH_SIZE
#define BLAKE2_HASH_SIZE
Definition: btrfslib.c:70
calc_sha256
void calc_sha256(uint8_t *hash, const void *input, size_t len)
Definition: sha256.c:126
calc_crc32c
crc_func calc_crc32c
Definition: crc32c.c:23
sb
superblock * sb
Definition: btrfs.c:4261
CSUM_TYPE_SHA256
#define CSUM_TYPE_SHA256
Definition: btrfs.h:134
CSUM_TYPE_XXHASH
#define CSUM_TYPE_XXHASH
Definition: btrfs.h:133
CSUM_TYPE_BLAKE2
#define CSUM_TYPE_BLAKE2
Definition: btrfs.h:135
CSUM_TYPE_CRC32C
#define CSUM_TYPE_CRC32C
Definition: btrfs.h:132
superblock::uuid
BTRFS_UUID uuid
Definition: btrfs.h:225
superblock::checksum
uint8_t checksum[32]
Definition: btrfs.h:224
ULONG
uint32_t ULONG
Definition: typedefs.h:59
XXH64
XXH_PUBLIC_API unsigned long long XXH64(const void *input, size_t len, unsigned long long seed)
Definition: xxhash.c:555

Referenced by write_superblocks().

◆ calc_tree_checksum()

static void calc_tree_checksum ( tree_header *  th,
uint32_t  node_size 
)
static

Definition at line 600 of file btrfslib.c.

600 {
601 switch (def_csum_type) {
602 case CSUM_TYPE_CRC32C:
603 *(uint32_t*)th = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, node_size - sizeof(th->csum));
604 break;
605
606 case CSUM_TYPE_XXHASH:
607 *(uint64_t*)th = XXH64((uint8_t*)&th->fs_uuid, node_size - sizeof(th->csum), 0);
608 break;
609
610 case CSUM_TYPE_SHA256:
611 calc_sha256((uint8_t*)th, &th->fs_uuid, node_size - sizeof(th->csum));
612 break;
613
614 case CSUM_TYPE_BLAKE2:
615 blake2b((uint8_t*)th, BLAKE2_HASH_SIZE, &th->fs_uuid, node_size - sizeof(th->csum));
616 break;
617 }
618}
tree_header::csum
uint8_t csum[32]
Definition: btrfs.h:154
tree_header::fs_uuid
BTRFS_UUID fs_uuid
Definition: btrfs.h:155

Referenced by write_roots().

◆ check_superblock_checksum()

static bool check_superblock_checksum ( superblock *  sb)
static

Definition at line 1165 of file btrfslib.c.

1165 {
1166 switch (sb->csum_type) {
1167 case CSUM_TYPE_CRC32C: {
1168 uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
1169
1170 return crc32 == *(uint32_t*)sb;
1171 }
1172
1173 case CSUM_TYPE_XXHASH: {
1174 uint64_t hash = XXH64(&sb->uuid, sizeof(superblock) - sizeof(sb->checksum), 0);
1175
1176 return hash == *(uint64_t*)sb;
1177 }
1178
1179 case CSUM_TYPE_SHA256: {
1180 uint8_t hash[SHA256_HASH_SIZE];
1181
1182 calc_sha256(hash, &sb->uuid, sizeof(superblock) - sizeof(sb->checksum));
1183
1184 return !memcmp(hash, sb, SHA256_HASH_SIZE);
1185 }
1186
1187 case CSUM_TYPE_BLAKE2: {
1188 uint8_t hash[BLAKE2_HASH_SIZE];
1189
1190 blake2b(hash, sizeof(hash), &sb->uuid, sizeof(superblock) - sizeof(sb->checksum));
1191
1192 return !memcmp(hash, sb, BLAKE2_HASH_SIZE);
1193 }
1194
1195 default:
1196 return false;
1197 }
1198}
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
SHA256_HASH_SIZE
#define SHA256_HASH_SIZE
Definition: btrfslib.c:67
crc32
#define crc32(crc, buf, len)
Definition: inflate.c:1081
superblock::csum_type
uint16_t csum_type
Definition: btrfs.h:247

Referenced by is_mounted_multi_device().

◆ ChkdskEx()

NTSTATUS WINAPI ChkdskEx ( PUNICODE_STRING  DriveRoot,
BOOLEAN  FixErrors,
BOOLEAN  Verbose,
BOOLEAN  CheckOnlyIfDirty,
BOOLEAN  ScanDrive,
PFMIFSCALLBACK  Callback 
)

Definition at line 246 of file btrfslib.c.

247 {
248#else
249BOOLEAN
250NTAPI
251BtrfsChkdsk(
252 IN PUNICODE_STRING DriveRoot,
253 IN PFMIFSCALLBACK Callback,
254 IN BOOLEAN FixErrors,
255 IN BOOLEAN Verbose,
256 IN BOOLEAN CheckOnlyIfDirty,
257 IN BOOLEAN ScanDrive,
258 IN PVOID pUnknown1,
259 IN PVOID pUnknown2,
260 IN PVOID pUnknown3,
261 IN PVOID pUnknown4,
262 IN PULONG ExitStatus)
263{
264#endif
265 // STUB
266
267 if (Callback) {
268 TEXTOUTPUT TextOut;
269
270 TextOut.Lines = 1;
271 TextOut.Output = "stub, not implemented";
272
273 Callback(OUTPUT, 0, &TextOut);
274 }
275
276#ifndef __REACTOS__
277 return STATUS_SUCCESS;
278#else
279 *ExitStatus = (ULONG)STATUS_SUCCESS;
280 return TRUE;
281#endif
282}
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
FixErrors
BOOL FixErrors
Definition: chkdsk.c:69
Verbose
BOOL Verbose
Definition: chkdsk.c:72
PFMIFSCALLBACK
BOOLEAN(NTAPI * PFMIFSCALLBACK)(CALLBACKCOMMAND Command, ULONG SubAction, PVOID ActionInfo)
Definition: btrfslib.c:237
BtrfsChkdsk
BOOLEAN NTAPI BtrfsChkdsk(IN PUNICODE_STRING DriveRoot, IN PFMIFSCALLBACK Callback, IN BOOLEAN FixErrors, IN BOOLEAN Verbose, IN BOOLEAN CheckOnlyIfDirty, IN BOOLEAN ScanDrive, IN PVOID pUnknown1, IN PVOID pUnknown2, IN PVOID pUnknown3, IN PVOID pUnknown4, IN PULONG ExitStatus)
TRUE
#define TRUE
Definition: types.h:120
ExitStatus
_In_ NTSTATUS ExitStatus
Definition: psfuncs.h:859
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_UNICODE_STRING
Definition: env_spec_w32.h:368
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
NTAPI
#define NTAPI
Definition: typedefs.h:36
IN
#define IN
Definition: typedefs.h:39
Callback
_In_ WDFINTERRUPT _In_ PFN_WDF_INTERRUPT_SYNCHRONIZE Callback
Definition: wdfinterrupt.h:458
TextOut
#define TextOut
Definition: wingdi.h:4483

◆ clear_first_megabyte()

static NTSTATUS clear_first_megabyte ( HANDLE  h)
static

Definition at line 957 of file btrfslib.c.

957 {
958 NTSTATUS Status;
959 IO_STATUS_BLOCK iosb;
960 LARGE_INTEGER zero;
961 uint8_t* mb;
962
963 mb = malloc(0x100000);
964 memset(mb, 0, 0x100000);
965
966 zero.QuadPart = 0;
967
968 Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, mb, 0x100000, &zero, NULL);
969
970 free(mb);
971
972 return Status;
973}
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
NtWriteFile
NTSTATUS NTAPI NtWriteFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key)
Status
Status
Definition: gdiplustypes.h:25
iosb
static PIO_STATUS_BLOCK iosb
Definition: file.c:98
zero
int zero
Definition: sehframes.cpp:29
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
_LARGE_INTEGER
Definition: typedefs.h:103

Referenced by write_btrfs().

◆ DllMain()

BOOL APIENTRY DllMain ( HANDLE  hModule,
DWORD  dwReason,
void *  lpReserved 
)

Definition at line 1581 of file btrfslib.c.

1581 {
1582 if (dwReason == DLL_PROCESS_ATTACH)
1583 module = (HMODULE)hModule;
1584
1585 return true;
1586}
dwReason
DWORD dwReason
Definition: misc.cpp:154
hModule
HMODULE hModule
Definition: animate.c:44
DLL_PROCESS_ATTACH
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
HMODULE
HANDLE HMODULE
Definition: typedefs.h:77

◆ do_full_trim()

static void do_full_trim ( HANDLE  h)
static

Definition at line 1297 of file btrfslib.c.

1297 {
1298 IO_STATUS_BLOCK iosb;
1299 DEVICE_MANAGE_DATA_SET_ATTRIBUTES dmdsa;
1300
1301 RtlZeroMemory(&dmdsa, sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES));
1302
1303 dmdsa.Size = sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES);
1304 dmdsa.Action = DeviceDsmAction_Trim;
1305 dmdsa.Flags = DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE | DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED;
1306 dmdsa.ParameterBlockOffset = 0;
1307 dmdsa.ParameterBlockLength = 0;
1308 dmdsa.DataSetRangesOffset = 0;
1309 dmdsa.DataSetRangesLength = 0;
1310
1311 NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES, &dmdsa, sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), NULL, 0);
1312}
DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED
#define DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED
Definition: btrfslib.c:79
NtDeviceIoControlFile
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
DEVICE_MANAGE_DATA_SET_ATTRIBUTES
struct _DEVICE_MANAGE_DATA_SET_ATTRIBUTES DEVICE_MANAGE_DATA_SET_ATTRIBUTES
DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE
#define DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE
Definition: ntddstor.h:306
IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES
#define IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES
Definition: ntddstor.h:181
DeviceDsmAction_Trim
#define DeviceDsmAction_Trim
Definition: ntddstor.h:276
_DEVICE_MANAGE_DATA_SET_ATTRIBUTES
Definition: ntddstor.h:771
_DEVICE_MANAGE_DATA_SET_ATTRIBUTES::Size
ULONG Size
Definition: ntddstor.h:772
_DEVICE_MANAGE_DATA_SET_ATTRIBUTES::Flags
ULONG Flags
Definition: ntddstor.h:774
_DEVICE_MANAGE_DATA_SET_ATTRIBUTES::Action
DEVICE_DATA_MANAGEMENT_SET_ACTION Action
Definition: ntddstor.h:773
_DEVICE_MANAGE_DATA_SET_ATTRIBUTES::ParameterBlockLength
ULONG ParameterBlockLength
Definition: ntddstor.h:776
_DEVICE_MANAGE_DATA_SET_ATTRIBUTES::ParameterBlockOffset
ULONG ParameterBlockOffset
Definition: ntddstor.h:775
_DEVICE_MANAGE_DATA_SET_ATTRIBUTES::DataSetRangesOffset
ULONG DataSetRangesOffset
Definition: ntddstor.h:777
_DEVICE_MANAGE_DATA_SET_ATTRIBUTES::DataSetRangesLength
ULONG DataSetRangesLength
Definition: ntddstor.h:778

Referenced by FormatEx2().

◆ find_chunk_offset()

static uint64_t find_chunk_offset ( uint64_t  size,
uint64_t  offset,
btrfs_dev *  dev,
btrfs_root *  dev_root,
BTRFS_UUID *  chunkuuid 
)
static

Definition at line 372 of file btrfslib.c.

372 {
373 uint64_t off;
374 DEV_EXTENT de;
375
376 off = dev->last_alloc;
377 dev->last_alloc += size;
378
379 dev->dev_item.bytes_used += size;
380
381 de.chunktree = BTRFS_ROOT_CHUNK;
382 de.objid = 0x100;
383 de.address = offset;
384 de.length = size;
385 de.chunktree_uuid = *chunkuuid;
386
387 add_item(dev_root, dev->dev_item.dev_id, TYPE_DEV_EXTENT, off, &de, sizeof(DEV_EXTENT));
388
389 return off;
390}
TYPE_DEV_EXTENT
#define TYPE_DEV_EXTENT
Definition: btrfs.h:46
DEV_EXTENT
Definition: btrfs.h:468
DEV_EXTENT::address
uint64_t address
Definition: btrfs.h:471
DEV_EXTENT::chunktree_uuid
BTRFS_UUID chunktree_uuid
Definition: btrfs.h:473
DEV_EXTENT::chunktree
uint64_t chunktree
Definition: btrfs.h:469
DEV_EXTENT::objid
uint64_t objid
Definition: btrfs.h:470
DEV_EXTENT::length
uint64_t length
Definition: btrfs.h:472

Referenced by add_chunk().

◆ FormatEx()

BOOL __stdcall FormatEx ( DSTRING *  root,
STREAM_MESSAGE *  message,
options *  opts,
uint32_t  unk1 
)

Definition at line 1533 of file btrfslib.c.

1533 {
1534 UNICODE_STRING DriveRoot, Label;
1535 NTSTATUS Status;
1536
1537 if (!root || !root->string)
1538 return false;
1539
1540 DriveRoot.Length = DriveRoot.MaximumLength = (USHORT)(wcslen(root->string) * sizeof(WCHAR));
1541 DriveRoot.Buffer = root->string;
1542
1543 if (opts && opts->label && opts->label->string) {
1544 Label.Length = Label.MaximumLength = (USHORT)(wcslen(opts->label->string) * sizeof(WCHAR));
1545 Label.Buffer = opts->label->string;
1546 } else {
1547 Label.Length = Label.MaximumLength = 0;
1548 Label.Buffer = NULL;
1549 }
1550
1551 Status = FormatEx2(&DriveRoot, FMIFS_HARDDISK, &Label, opts && opts->flags & FORMAT_FLAG_QUICK_FORMAT, 0, NULL);
1552
1553 return NT_SUCCESS(Status);
1554}
Label
PWCHAR Label
Definition: format.c:70
FORMAT_FLAG_QUICK_FORMAT
#define FORMAT_FLAG_QUICK_FORMAT
Definition: btrfslib.c:106
FormatEx2
static NTSTATUS NTAPI FormatEx2(PUNICODE_STRING DriveRoot, FMIFS_MEDIA_FLAG MediaFlag, PUNICODE_STRING Label, BOOLEAN QuickFormat, ULONG ClusterSize, PFMIFSCALLBACK Callback)
Definition: btrfslib.c:1336
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
wcslen
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
USHORT
unsigned short USHORT
Definition: pedump.c:61
DSTRING::string
WCHAR * string
Definition: btrfslib.c:99
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
_UNICODE_STRING::MaximumLength
USHORT MaximumLength
Definition: env_spec_w32.h:370
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
options::label
DSTRING * label
Definition: btrfslib.c:117
options::flags
uint32_t flags
Definition: btrfslib.c:116
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ FormatEx2()

static NTSTATUS NTAPI FormatEx2 ( PUNICODE_STRING  DriveRoot,
FMIFS_MEDIA_FLAG  MediaFlag,
PUNICODE_STRING  Label,
BOOLEAN  QuickFormat,
ULONG  ClusterSize,
PFMIFSCALLBACK  Callback 
)
static

Definition at line 1336 of file btrfslib.c.

1338{
1339 NTSTATUS Status;
1340 HANDLE h, btrfsh;
1341 OBJECT_ATTRIBUTES attr;
1342 IO_STATUS_BLOCK iosb;
1343 GET_LENGTH_INFORMATION gli;
1344 DISK_GEOMETRY dg;
1345 uint32_t sector_size, node_size;
1346 UNICODE_STRING btrfsus;
1347#ifndef __REACTOS__
1348 HANDLE token;
1349 TOKEN_PRIVILEGES tp;
1350 LUID luid;
1351#endif
1352 uint64_t incompat_flags;
1353 UNICODE_STRING empty_label;
1354
1355 static WCHAR btrfs[] = L"\\Btrfs";
1356
1357#ifndef __REACTOS__
1358 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token))
1359 return STATUS_PRIVILEGE_NOT_HELD;
1360
1361 if (!LookupPrivilegeValueW(NULL, L"SeManageVolumePrivilege", &luid)) {
1362 CloseHandle(token);
1363 return STATUS_PRIVILEGE_NOT_HELD;
1364 }
1365
1366 tp.PrivilegeCount = 1;
1367 tp.Privileges[0].Luid = luid;
1368 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1369
1370 if (!AdjustTokenPrivileges(token, false, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL)) {
1371 CloseHandle(token);
1372 return STATUS_PRIVILEGE_NOT_HELD;
1373 }
1374
1375 CloseHandle(token);
1376
1377#if defined(_X86_) || defined(_AMD64_)
1378 check_cpu();
1379#endif
1380#endif
1381
1382 if (def_csum_type != CSUM_TYPE_CRC32C && def_csum_type != CSUM_TYPE_XXHASH && def_csum_type != CSUM_TYPE_SHA256 &&
1383 def_csum_type != CSUM_TYPE_BLAKE2)
1384 return STATUS_INVALID_PARAMETER;
1385
1386 InitializeObjectAttributes(&attr, DriveRoot, OBJ_CASE_INSENSITIVE, NULL, NULL);
1387
1388 Status = NtOpenFile(&h, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &attr, &iosb,
1389 FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT);
1390
1391 if (!NT_SUCCESS(Status))
1392 return Status;
1393
1394 Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli));
1395 if (!NT_SUCCESS(Status)) {
1396 NtClose(h);
1397 return Status;
1398 }
1399
1400 // MSDN tells us to use IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, but there are
1401 // some instances where it fails and IOCTL_DISK_GET_DRIVE_GEOMETRY succeeds -
1402 // such as with spanned volumes.
1403 Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &dg, sizeof(dg));
1404 if (!NT_SUCCESS(Status)) {
1405 NtClose(h);
1406 return Status;
1407 }
1408
1409 if (def_sector_size == 0) {
1410 sector_size = dg.BytesPerSector;
1411
1412 if (sector_size == 0x200 || sector_size == 0)
1413 sector_size = 0x1000;
1414 } else {
1415 if (dg.BytesPerSector != 0 && (def_sector_size < dg.BytesPerSector || def_sector_size % dg.BytesPerSector != 0 || !is_power_of_two(def_sector_size / dg.BytesPerSector))) {
1416 NtClose(h);
1417 return STATUS_INVALID_PARAMETER;
1418 }
1419
1420 sector_size = def_sector_size;
1421 }
1422
1423 if (def_node_size == 0)
1424 node_size = 0x4000;
1425 else {
1426 if (def_node_size < sector_size || def_node_size % sector_size != 0 || !is_power_of_two(def_node_size / sector_size)) {
1427 NtClose(h);
1428 return STATUS_INVALID_PARAMETER;
1429 }
1430
1431 node_size = def_node_size;
1432 }
1433
1434 if (Callback) {
1435 ULONG pc = 0;
1436 Callback(PROGRESS, 0, (PVOID)&pc);
1437 }
1438
1439 NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0);
1440
1441 if (is_mounted_multi_device(h, sector_size)) {
1442 Status = STATUS_ACCESS_DENIED;
1443 goto end;
1444 }
1445
1446 do_full_trim(h);
1447
1448 incompat_flags = def_incompat_flags;
1449 incompat_flags |= BTRFS_INCOMPAT_FLAGS_MIXED_BACKREF | BTRFS_INCOMPAT_FLAGS_BIG_METADATA;
1450
1451 if (!Label) {
1452 empty_label.Buffer = NULL;
1453 empty_label.Length = empty_label.MaximumLength = 0;
1454 Label = &empty_label;
1455 }
1456
1457 Status = write_btrfs(h, gli.Length.QuadPart, Label, sector_size, node_size, incompat_flags);
1458
1459 NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0);
1460
1461end:
1462 NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0);
1463
1464 NtClose(h);
1465
1466 if (NT_SUCCESS(Status)) {
1467 btrfsus.Buffer = btrfs;
1468 btrfsus.Length = btrfsus.MaximumLength = (USHORT)(wcslen(btrfs) * sizeof(WCHAR));
1469
1470 InitializeObjectAttributes(&attr, &btrfsus, 0, NULL, NULL);
1471
1472 Status = NtOpenFile(&btrfsh, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &attr, &iosb,
1473 FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT);
1474
1475 if (NT_SUCCESS(Status)) {
1476 MOUNTDEV_NAME* mdn;
1477 ULONG mdnsize;
1478
1479 mdnsize = (ULONG)(offsetof(MOUNTDEV_NAME, Name[0]) + DriveRoot->Length);
1480 mdn = malloc(mdnsize);
1481
1482 mdn->NameLength = DriveRoot->Length;
1483 memcpy(mdn->Name, DriveRoot->Buffer, DriveRoot->Length);
1484
1485 NtDeviceIoControlFile(btrfsh, NULL, NULL, NULL, &iosb, IOCTL_BTRFS_PROBE_VOLUME, mdn, mdnsize, NULL, 0);
1486
1487 free(mdn);
1488
1489 NtClose(btrfsh);
1490 }
1491
1492 Status = STATUS_SUCCESS;
1493 }
1494
1495#ifndef __REACTOS__
1496 if (Callback) {
1497 bool success = NT_SUCCESS(Status);
1498 Callback(DONE, 0, (PVOID)&success);
1499 }
1500#endif
1501
1502 return Status;
1503}
STATUS_PRIVILEGE_NOT_HELD
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
IOCTL_BTRFS_PROBE_VOLUME
#define IOCTL_BTRFS_PROBE_VOLUME
Definition: btrfsioctl.h:28
def_incompat_flags
uint64_t def_incompat_flags
Definition: btrfslib.c:179
FSCTL_LOCK_VOLUME
#define FSCTL_LOCK_VOLUME
Definition: btrfslib.c:74
is_power_of_two
static bool is_power_of_two(ULONG i)
Definition: btrfslib.c:1314
FSCTL_UNLOCK_VOLUME
#define FSCTL_UNLOCK_VOLUME
Definition: btrfslib.c:75
write_btrfs
static NTSTATUS write_btrfs(HANDLE h, uint64_t size, PUNICODE_STRING label, uint32_t sector_size, uint32_t node_size, uint64_t incompat_flags)
Definition: btrfslib.c:1061
def_node_size
ULONG def_node_size
Definition: btrfslib.c:178
is_mounted_multi_device
static bool is_mounted_multi_device(HANDLE h, uint32_t sector_size)
Definition: btrfslib.c:1200
do_full_trim
static void do_full_trim(HANDLE h)
Definition: btrfslib.c:1297
FSCTL_DISMOUNT_VOLUME
#define FSCTL_DISMOUNT_VOLUME
Definition: btrfslib.c:76
def_sector_size
ULONG def_sector_size
Definition: btrfslib.c:178
IOCTL_DISK_GET_DRIVE_GEOMETRY
#define IOCTL_DISK_GET_DRIVE_GEOMETRY
Definition: cdrw_usr.h:169
LookupPrivilegeValueW
BOOL WINAPI LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpPrivilegeName, PLUID lpLuid)
Definition: misc.c:782
AdjustTokenPrivileges
BOOL WINAPI AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength)
Definition: security.c:376
OpenProcessToken
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:296
CloseHandle
#define CloseHandle
Definition: compat.h:739
GetCurrentProcess
#define GetCurrentProcess()
Definition: compat.h:759
FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:136
tp
_In_ uint64_t _In_ uint64_t _In_ uint64_t _In_opt_ traverse_ptr * tp
Definition: btrfs.c:2996
BTRFS_INCOMPAT_FLAGS_MIXED_BACKREF
#define BTRFS_INCOMPAT_FLAGS_MIXED_BACKREF
Definition: btrfs.h:115
BTRFS_INCOMPAT_FLAGS_BIG_METADATA
#define BTRFS_INCOMPAT_FLAGS_BIG_METADATA
Definition: btrfs.h:120
FILE_SYNCHRONOUS_IO_ALERT
#define FILE_SYNCHRONOUS_IO_ALERT
Definition: from_kernel.h:30
end
GLuint GLuint end
Definition: gl.h:1545
token
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat token
Definition: glfuncs.h:210
OBJ_CASE_INSENSITIVE
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
IOCTL_DISK_GET_LENGTH_INFO
#define IOCTL_DISK_GET_LENGTH_INFO
Definition: imports.h:192
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
NtOpenFile
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3952
NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NtFsControlFile
NTSYSAPI NTSTATUS NTAPI NtFsControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
FILE_GENERIC_READ
#define FILE_GENERIC_READ
Definition: nt_native.h:653
FILE_GENERIC_WRITE
#define FILE_GENERIC_WRITE
Definition: nt_native.h:660
L
#define L(x)
Definition: ntvdm.h:50
GET_LENGTH_INFORMATION
Definition: winioctl.h:559
GET_LENGTH_INFORMATION::Length
LARGE_INTEGER Length
Definition: winioctl.h:560
NameRec_
Definition: apinames.c:49
_DISK_GEOMETRY
Definition: ntdddisk.h:404
_DISK_GEOMETRY::BytesPerSector
ULONG BytesPerSector
Definition: ntdddisk.h:409
_LUID
Definition: devicetopology.idl:137
_MOUNTDEV_NAME
Definition: imports.h:142
_MOUNTDEV_NAME::NameLength
USHORT NameLength
Definition: imports.h:143
_MOUNTDEV_NAME::Name
WCHAR Name[1]
Definition: imports.h:144
_OBJECT_ATTRIBUTES
Definition: umtypes.h:182
_TOKEN_PRIVILEGES
Definition: setypes.h:1018
attr
Definition: cookie.c:202
STATUS_ACCESS_DENIED
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
success
#define success(from, fromstr, to, tostr)
Definition: win_iconv_test.c:158
TOKEN_ADJUST_PRIVILEGES
#define TOKEN_ADJUST_PRIVILEGES
Definition: setypes.h:926
TOKEN_QUERY
#define TOKEN_QUERY
Definition: setypes.h:924
SE_PRIVILEGE_ENABLED
#define SE_PRIVILEGE_ENABLED
Definition: setypes.h:63

Referenced by FormatEx().

◆ free_chunks()

static void free_chunks ( LIST_ENTRY *  chunks)
static

Definition at line 324 of file btrfslib.c.

324 {
325 LIST_ENTRY* le;
326
327 le = chunks->Flink;
328 while (le != chunks) {
329 LIST_ENTRY *le2 = le->Flink;
330 btrfs_chunk* c = CONTAINING_RECORD(le, btrfs_chunk, list_entry);
331
332 free(c->chunk_item);
333 free(c);
334
335 le = le2;
336 }
337}

Referenced by write_btrfs().

◆ free_roots()

static void free_roots ( LIST_ENTRY *  roots)
static

Definition at line 297 of file btrfslib.c.

297 {
298 LIST_ENTRY* le;
299
300 le = roots->Flink;
301 while (le != roots) {
302 LIST_ENTRY *le2 = le->Flink, *le3;
303 btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry);
304
305 le3 = r->items.Flink;
306 while (le3 != &r->items) {
307 LIST_ENTRY* le4 = le3->Flink;
308 btrfs_item* item = CONTAINING_RECORD(le3, btrfs_item, list_entry);
309
310 if (item->data)
311 free(item->data);
312
313 free(item);
314
315 le3 = le4;
316 }
317
318 free(r);
319
320 le = le2;
321 }
322}

Referenced by write_btrfs().

◆ get_next_address()

static uint64_t get_next_address ( btrfs_chunk *  c)
static

Definition at line 479 of file btrfslib.c.

479 {
480 uint64_t addr;
481
482 addr = c->lastoff;
483
484 while (superblock_collision(c, addr)) {
485 addr = addr - ((addr - c->offset) % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;
486
487 if (addr >= c->offset + c->chunk_item->size) // chunk has been exhausted
488 return 0;
489 }
490
491 return addr;
492}
superblock_collision
static bool superblock_collision(btrfs_chunk *c, uint64_t address)
Definition: btrfslib.c:458
addr
GLenum const GLvoid * addr
Definition: glext.h:9621

Referenced by assign_addresses().

◆ get_uuid()

static void get_uuid ( BTRFS_UUID *  uuid)
static

Definition at line 687 of file btrfslib.c.

687 {
688#else
689static void get_uuid(BTRFS_UUID* uuid, ULONG* seed) {
690#endif
691 uint8_t i;
692
693 for (i = 0; i < 16; i+=2) {
694#ifndef __REACTOS__
695 ULONG r = rand();
696#else
697 ULONG r = RtlRandom(seed);
698#endif
699
700 uuid->uuid[i] = (r & 0xff00) >> 8;
701 uuid->uuid[i+1] = r & 0xff;
702 }
703}
get_uuid
static void get_uuid(BTRFS_UUID *uuid)
Definition: btrfslib.c:687
rand
_Check_return_ int __cdecl rand(void)
Definition: rand.c:10
uuid
Definition: msctf.idl:511
RtlRandom
NTSYSAPI ULONG NTAPI RtlRandom(_Inout_ PULONG Seed)
BTRFS_UUID
Definition: btrfs.h:139

Referenced by get_uuid(), init_device(), and write_btrfs().

◆ GetFilesystemInformation()

BOOL __stdcall GetFilesystemInformation ( uint32_t  unk1,
uint32_t  unk2,
void *  unk3 
)

Definition at line 1574 of file btrfslib.c.

1574 {
1575 // STUB - undocumented
1576
1577 return true;
1578}

◆ init_device()

static void init_device ( btrfs_dev *  dev,
uint64_t  id,
uint64_t  size,
BTRFS_UUID *  fsuuid,
uint32_t  sector_size 
)
static

Definition at line 706 of file btrfslib.c.

706 {
707#else
708static void init_device(btrfs_dev* dev, uint64_t id, uint64_t size, BTRFS_UUID* fsuuid, uint32_t sector_size, ULONG* seed) {
709#endif
710 dev->dev_item.dev_id = id;
711 dev->dev_item.num_bytes = size;
712 dev->dev_item.bytes_used = 0;
713 dev->dev_item.optimal_io_align = sector_size;
714 dev->dev_item.optimal_io_width = sector_size;
715 dev->dev_item.minimal_io_size = sector_size;
716 dev->dev_item.type = 0;
717 dev->dev_item.generation = 0;
718 dev->dev_item.start_offset = 0;
719 dev->dev_item.dev_group = 0;
720 dev->dev_item.seek_speed = 0;
721 dev->dev_item.bandwidth = 0;
722#ifndef __REACTOS__
723 get_uuid(&dev->dev_item.device_uuid);
724#else
725 get_uuid(&dev->dev_item.device_uuid, seed);
726#endif
727 dev->dev_item.fs_uuid = *fsuuid;
728
729 dev->last_alloc = 0x100000; // skip first megabyte
730}
init_device
static void init_device(btrfs_dev *dev, uint64_t id, uint64_t size, BTRFS_UUID *fsuuid, uint32_t sector_size)
Definition: btrfslib.c:706
btrfs_dev
Definition: btrfslib.c:163

Referenced by init_device(), and write_btrfs().

◆ init_fs_tree()

static void init_fs_tree ( btrfs_root *  r,
uint32_t  node_size 
)
static

Definition at line 916 of file btrfslib.c.

916 {
917 INODE_ITEM ii;
918 FILETIME filetime;
919 LARGE_INTEGER time;
920
921 memset(&ii, 0, sizeof(INODE_ITEM));
922
923 ii.generation = 1;
924 ii.st_blocks = node_size;
925 ii.st_nlink = 1;
926 ii.st_mode = 040755;
927
928 GetSystemTimeAsFileTime(&filetime);
929 time.LowPart = filetime.dwLowDateTime;
930 time.HighPart = filetime.dwHighDateTime;
931
932 win_time_to_unix(time, &ii.st_atime);
933 ii.st_ctime = ii.st_mtime = ii.st_atime;
934
935 add_item(r, SUBVOL_ROOT_INODE, TYPE_INODE_ITEM, 0, &ii, sizeof(INODE_ITEM));
936
937 add_inode_ref(r, SUBVOL_ROOT_INODE, SUBVOL_ROOT_INODE, 0, "..");
938}
add_inode_ref
static void add_inode_ref(btrfs_root *r, uint64_t inode, uint64_t parent, uint64_t index, const char *name)
Definition: btrfslib.c:903
win_time_to_unix
static __inline void win_time_to_unix(LARGE_INTEGER t, BTRFS_TIME *out)
Definition: btrfslib.c:877
GetSystemTimeAsFileTime
VOID WINAPI GetSystemTimeAsFileTime(OUT PFILETIME lpFileTime)
Definition: time.c:128
TYPE_INODE_ITEM
#define TYPE_INODE_ITEM
Definition: btrfs.h:23
time
__u16 time
Definition: mkdosfs.c:8
INODE_ITEM
Definition: btrfs.h:286
INODE_ITEM::st_mtime
BTRFS_TIME st_mtime
Definition: btrfs.h:303
INODE_ITEM::st_atime
BTRFS_TIME st_atime
Definition: btrfs.h:301
INODE_ITEM::st_ctime
BTRFS_TIME st_ctime
Definition: btrfs.h:302
_FILETIME
Definition: mapidefs.h:60

Referenced by write_btrfs().

◆ InitializeListHead()

FORCEINLINE VOID InitializeListHead ( PLIST_ENTRY  ListHead)

Definition at line 121 of file btrfslib.c.

121 {
122 ListHead->Flink = ListHead->Blink = ListHead;
123}
_LIST_ENTRY::Blink
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122

◆ InsertTailList()

FORCEINLINE VOID InsertTailList ( PLIST_ENTRY  ListHead,
PLIST_ENTRY  Entry 
)

Definition at line 125 of file btrfslib.c.

125 {
126 PLIST_ENTRY Blink;
127
128 Blink = ListHead->Blink;
129 Entry->Flink = ListHead;
130 Entry->Blink = Blink;
131 Blink->Flink = Entry;
132 ListHead->Blink = Entry;
133}
Entry
base of all file and directory entries
Definition: entries.h:83

◆ is_mounted_multi_device()

static bool is_mounted_multi_device ( HANDLE  h,
uint32_t  sector_size 
)
static

Definition at line 1200 of file btrfslib.c.

1200 {
1201 NTSTATUS Status;
1202 superblock* sb;
1203 ULONG sblen;
1204 IO_STATUS_BLOCK iosb;
1205 LARGE_INTEGER off;
1206 BTRFS_UUID fsuuid, devuuid;
1207 UNICODE_STRING us;
1208 OBJECT_ATTRIBUTES atts;
1209 HANDLE h2;
1210 btrfs_filesystem *bfs = NULL, *bfs2;
1211 ULONG bfssize;
1212 bool ret = false;
1213
1214 static WCHAR btrfs[] = L"\\Btrfs";
1215
1216 sblen = sizeof(*sb);
1217 if (sblen & (sector_size - 1))
1218 sblen = (sblen & sector_size) + sector_size;
1219
1220 sb = malloc(sblen);
1221
1222 off.QuadPart = superblock_addrs[0];
1223
1224 Status = NtReadFile(h, NULL, NULL, NULL, &iosb, sb, sblen, &off, NULL);
1225 if (!NT_SUCCESS(Status)) {
1226 free(sb);
1227 return false;
1228 }
1229
1230 if (sb->magic != BTRFS_MAGIC) {
1231 free(sb);
1232 return false;
1233 }
1234
1235 if (!check_superblock_checksum(sb)) {
1236 free(sb);
1237 return false;
1238 }
1239
1240 fsuuid = sb->uuid;
1241 devuuid = sb->dev_item.device_uuid;
1242
1243 free(sb);
1244
1245 us.Length = us.MaximumLength = (USHORT)(wcslen(btrfs) * sizeof(WCHAR));
1246 us.Buffer = btrfs;
1247
1248 InitializeObjectAttributes(&atts, &us, 0, NULL, NULL);
1249
1250 Status = NtOpenFile(&h2, SYNCHRONIZE | FILE_READ_ATTRIBUTES, &atts, &iosb,
1251 FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_ALERT);
1252 if (!NT_SUCCESS(Status)) // not a problem, it usually just means the driver isn't loaded
1253 return false;
1254
1255 bfssize = 0;
1256
1257 do {
1258 bfssize += 1024;
1259
1260 if (bfs) free(bfs);
1261 bfs = malloc(bfssize);
1262
1263 Status = NtDeviceIoControlFile(h2, NULL, NULL, NULL, &iosb, IOCTL_BTRFS_QUERY_FILESYSTEMS, NULL, 0, bfs, bfssize);
1264 } while (Status == STATUS_BUFFER_OVERFLOW);
1265
1266 if (!NT_SUCCESS(Status))
1267 goto end;
1268
1269 if (bfs->num_devices != 0) {
1270 bfs2 = bfs;
1271 while (true) {
1272 if (RtlCompareMemory(&bfs2->uuid, &fsuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
1273 if (bfs2->num_devices == 1)
1274 ret = false;
1275 else
1276 ret = look_for_device(bfs2, &devuuid);
1277
1278 goto end;
1279 }
1280
1281 if (bfs2->next_entry == 0)
1282 break;
1283 else
1284 bfs2 = (btrfs_filesystem*)((uint8_t*)bfs2 + bfs2->next_entry);
1285 }
1286 }
1287
1288end:
1289 NtClose(h2);
1290
1291 if (bfs)
1292 free(bfs);
1293
1294 return ret;
1295}
BTRFS_MAGIC
#define BTRFS_MAGIC
Definition: btrfs.h:42
atts
_In_ uint16_t _Out_ ULONG * atts
Definition: btrfs_drv.h:1107
IOCTL_BTRFS_QUERY_FILESYSTEMS
#define IOCTL_BTRFS_QUERY_FILESYSTEMS
Definition: btrfsioctl.h:21
check_superblock_checksum
static bool check_superblock_checksum(superblock *sb)
Definition: btrfslib.c:1165
look_for_device
static bool look_for_device(btrfs_filesystem *bfs, BTRFS_UUID *devuuid)
Definition: btrfslib.c:1148
NtReadFile
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)
superblock_addrs
static const uint64_t superblock_addrs[]
Definition: btrfs.h:16
RtlCompareMemory
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
us
static const BYTE us[]
Definition: encode.c:689
FILE_SHARE_WRITE
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
SYNCHRONIZE
#define SYNCHRONIZE
Definition: nt_native.h:61
FILE_READ_ATTRIBUTES
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
STATUS_BUFFER_OVERFLOW
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
DEV_ITEM::device_uuid
BTRFS_UUID device_uuid
Definition: btrfs.h:190
btrfs_filesystem
Definition: btrfsioctl.h:188
btrfs_filesystem::num_devices
uint32_t num_devices
Definition: btrfsioctl.h:191
superblock::magic
uint64_t magic
Definition: btrfs.h:228
superblock::dev_item
DEV_ITEM dev_item
Definition: btrfs.h:251
ret
int ret
Definition: wcstombs-tests.c:31

Referenced by FormatEx2().

◆ is_power_of_two()

static bool is_power_of_two ( ULONG  i)
static

Definition at line 1314 of file btrfslib.c.

1314 {
1315 return ((i != 0) && !(i & (i - 1)));
1316}

Referenced by FormatEx2().

◆ is_ssd()

static bool is_ssd ( HANDLE  h)
static

Definition at line 975 of file btrfslib.c.

975 {
976 ULONG aptelen;
977 ATA_PASS_THROUGH_EX* apte;
978 IO_STATUS_BLOCK iosb;
979 NTSTATUS Status;
980 IDENTIFY_DEVICE_DATA* idd;
981
982 aptelen = sizeof(ATA_PASS_THROUGH_EX) + 512;
983 apte = malloc(aptelen);
984
985 RtlZeroMemory(apte, aptelen);
986
987 apte->Length = sizeof(ATA_PASS_THROUGH_EX);
988 apte->AtaFlags = ATA_FLAGS_DATA_IN;
989 apte->DataTransferLength = aptelen - sizeof(ATA_PASS_THROUGH_EX);
990 apte->TimeOutValue = 3;
991 apte->DataBufferOffset = apte->Length;
992 apte->CurrentTaskFile[6] = IDE_COMMAND_IDENTIFY;
993
994 Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_ATA_PASS_THROUGH, apte, aptelen, apte, aptelen);
995
996 if (NT_SUCCESS(Status)) {
997 idd = (IDENTIFY_DEVICE_DATA*)((uint8_t*)apte + sizeof(ATA_PASS_THROUGH_EX));
998
999 if (idd->NominalMediaRotationRate == 1) {
1000 free(apte);
1001 return true;
1002 }
1003 }
1004
1005 free(apte);
1006
1007 return false;
1008}
IDE_COMMAND_IDENTIFY
#define IDE_COMMAND_IDENTIFY
Definition: atapi.h:118
IOCTL_ATA_PASS_THROUGH
#define IOCTL_ATA_PASS_THROUGH
Definition: ntddscsi.h:40
ATA_PASS_THROUGH_EX
struct _ATA_PASS_THROUGH_EX ATA_PASS_THROUGH_EX
_ATA_PASS_THROUGH_EX
Definition: ntddscsi.h:191
_ATA_PASS_THROUGH_EX::DataTransferLength
ULONG DataTransferLength
Definition: ntddscsi.h:198
_ATA_PASS_THROUGH_EX::CurrentTaskFile
UCHAR CurrentTaskFile[8]
Definition: ntddscsi.h:203
_ATA_PASS_THROUGH_EX::TimeOutValue
ULONG TimeOutValue
Definition: ntddscsi.h:199
_ATA_PASS_THROUGH_EX::Length
USHORT Length
Definition: ntddscsi.h:192
_ATA_PASS_THROUGH_EX::AtaFlags
USHORT AtaFlags
Definition: ntddscsi.h:193
_ATA_PASS_THROUGH_EX::DataBufferOffset
ULONG_PTR DataBufferOffset
Definition: ntddscsi.h:201
_IDENTIFY_DEVICE_DATA
Definition: ata.h:5
_IDENTIFY_DEVICE_DATA::NominalMediaRotationRate
USHORT NominalMediaRotationRate
Definition: ata.h:243
ATA_FLAGS_DATA_IN
#define ATA_FLAGS_DATA_IN
Definition: uata_ctl.h:222

Referenced by write_btrfs().

◆ look_for_device()

static bool look_for_device ( btrfs_filesystem *  bfs,
BTRFS_UUID *  devuuid 
)
static

Definition at line 1148 of file btrfslib.c.

1148 {
1149 uint32_t i;
1150 btrfs_filesystem_device* dev;
1151
1152 for (i = 0; i < bfs->num_devices; i++) {
1153 if (i == 0)
1154 dev = &bfs->device;
1155 else
1156 dev = (btrfs_filesystem_device*)((uint8_t*)dev + offsetof(btrfs_filesystem_device, name[0]) + dev->name_length);
1157
1158 if (RtlCompareMemory(&dev->uuid, devuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID))
1159 return true;
1160 }
1161
1162 return false;
1163}
btrfs_filesystem_device
Definition: btrfsioctl.h:181
btrfs_filesystem::device
btrfs_filesystem_device device
Definition: btrfsioctl.h:192

Referenced by is_mounted_multi_device().

◆ NtReadFile()

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 
)

Referenced by is_mounted_multi_device().

◆ NtWriteFile()

NTSTATUS NTAPI NtWriteFile ( HANDLE  FileHandle,
HANDLE  Event,
PIO_APC_ROUTINE  ApcRoutine,
PVOID  ApcContext,
PIO_STATUS_BLOCK  IoStatusBlock,
PVOID  Buffer,
ULONG  Length,
PLARGE_INTEGER  ByteOffset,
PULONG  Key 
)

Referenced by clear_first_megabyte(), write_data(), and write_superblocks().

◆ set_default_subvol()

static void set_default_subvol ( btrfs_root *  root_root,
uint32_t  node_size 
)
static

Definition at line 1029 of file btrfslib.c.

1029 {
1030 INODE_ITEM ii;
1031 FILETIME filetime;
1032 LARGE_INTEGER time;
1033
1034 static const char default_subvol[] = "default";
1035 static const uint32_t default_hash = 0x8dbfc2d2;
1036
1037 add_inode_ref(root_root, BTRFS_ROOT_FSTREE, BTRFS_ROOT_TREEDIR, 0, default_subvol);
1038
1039 memset(&ii, 0, sizeof(INODE_ITEM));
1040
1041 ii.generation = 1;
1042 ii.st_blocks = node_size;
1043 ii.st_nlink = 1;
1044 ii.st_mode = 040755;
1045
1046 GetSystemTimeAsFileTime(&filetime);
1047 time.LowPart = filetime.dwLowDateTime;
1048 time.HighPart = filetime.dwHighDateTime;
1049
1050 win_time_to_unix(time, &ii.st_atime);
1051 ii.st_ctime = ii.st_mtime = ii.otime = ii.st_atime;
1052
1053 add_item(root_root, BTRFS_ROOT_TREEDIR, TYPE_INODE_ITEM, 0, &ii, sizeof(INODE_ITEM));
1054
1055 add_inode_ref(root_root, BTRFS_ROOT_TREEDIR, BTRFS_ROOT_TREEDIR, 0, "..");
1056
1057 add_dir_item(root_root, BTRFS_ROOT_TREEDIR, default_hash, BTRFS_ROOT_FSTREE, TYPE_ROOT_ITEM,
1058 0xffffffffffffffff, 0, BTRFS_TYPE_DIRECTORY, default_subvol);
1059}
add_dir_item
static void add_dir_item(btrfs_root *root, uint64_t inode, uint32_t hash, uint64_t key_objid, uint8_t key_type, uint64_t key_offset, uint64_t transid, uint8_t type, const char *name)
Definition: btrfslib.c:1010
BTRFS_ROOT_TREEDIR
#define BTRFS_ROOT_TREEDIR
Definition: btrfs.h:59
BTRFS_ROOT_FSTREE
#define BTRFS_ROOT_FSTREE
Definition: btrfs.h:58
BTRFS_TYPE_DIRECTORY
#define BTRFS_TYPE_DIRECTORY
Definition: shellext.h:86
INODE_ITEM::otime
BTRFS_TIME otime
Definition: btrfs.h:304

Referenced by write_btrfs().

◆ SetCsumType()

void __stdcall SetCsumType ( uint16_t  csum_type)

Definition at line 1570 of file btrfslib.c.

1570 {
1571 def_csum_type = csum_type;
1572}

◆ SetIncompatFlags()

void __stdcall SetIncompatFlags ( uint64_t  incompat_flags)

Definition at line 1566 of file btrfslib.c.

1566 {
1567 def_incompat_flags = incompat_flags;
1568}

◆ SetSizes()

void __stdcall SetSizes ( ULONG  sector,
ULONG  node 
)

Definition at line 1558 of file btrfslib.c.

1558 {
1559 if (sector != 0)
1560 def_sector_size = sector;
1561
1562 if (node != 0)
1563 def_node_size = node;
1564}
sector
uint32_t sector
Definition: isohybrid.c:61
node
Definition: dlist.c:348

◆ superblock_collision()

static bool superblock_collision ( btrfs_chunk *  c,
uint64_t  address 
)
static

Definition at line 458 of file btrfslib.c.

458 {
459 CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
460 uint64_t stripe = (address - c->offset) / c->chunk_item->stripe_length;
461 uint16_t i, j;
462
463 for (i = 0; i < c->chunk_item->num_stripes; i++) {
464 j = 0;
465 while (superblock_addrs[j] != 0) {
466 if (superblock_addrs[j] >= cis[i].offset) {
467 uint64_t stripe2 = (superblock_addrs[j] - cis[i].offset) / c->chunk_item->stripe_length;
468
469 if (stripe2 == stripe)
470 return true;
471 }
472 j++;
473 }
474 }
475
476 return false;
477}
address
GLuint address
Definition: glext.h:9393
if
if(dx< 0)
Definition: linetemp.h:194
stripe
Definition: write.c:113

Referenced by get_next_address().

◆ win_time_to_unix()

static __inline void win_time_to_unix ( LARGE_INTEGER  t,
BTRFS_TIME *  out 
)
static

Definition at line 877 of file btrfslib.c.

877 {
878 ULONGLONG l = t.QuadPart - 116444736000000000;
879
880 out->seconds = l / 10000000;
881 out->nanoseconds = (l % 10000000) * 100;
882}
l
r l[0]
Definition: byte_order.h:167
t
GLdouble GLdouble t
Definition: gl.h:2047
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67

Referenced by init_fs_tree(), and set_default_subvol().

◆ write_btrfs()

static NTSTATUS write_btrfs ( HANDLE  h,
uint64_t  size,
PUNICODE_STRING  label,
uint32_t  sector_size,
uint32_t  node_size,
uint64_t  incompat_flags 
)
static

Definition at line 1061 of file btrfslib.c.

1061 {
1062 NTSTATUS Status;
1063 LIST_ENTRY roots, chunks;
1064 btrfs_root *root_root, *chunk_root, *extent_root, *dev_root, *fs_root, *reloc_root;
1065 btrfs_chunk *sys_chunk, *metadata_chunk;
1066 btrfs_dev dev;
1067 BTRFS_UUID fsuuid, chunkuuid;
1068 bool ssd;
1069 uint64_t metadata_flags;
1070#ifdef __REACTOS__
1071 ULONG seed;
1072#endif
1073
1074#ifndef __REACTOS__
1075 srand((unsigned int)time(0));
1076 get_uuid(&fsuuid);
1077 get_uuid(&chunkuuid);
1078#else
1079 seed = NtGetTickCount();
1080 get_uuid(&fsuuid, &seed);
1081 get_uuid(&chunkuuid, &seed);
1082#endif
1083
1084 InitializeListHead(&roots);
1085 InitializeListHead(&chunks);
1086
1087 root_root = add_root(&roots, BTRFS_ROOT_ROOT);
1088 chunk_root = add_root(&roots, BTRFS_ROOT_CHUNK);
1089 extent_root = add_root(&roots, BTRFS_ROOT_EXTENT);
1090 dev_root = add_root(&roots, BTRFS_ROOT_DEVTREE);
1091 add_root(&roots, BTRFS_ROOT_CHECKSUM);
1092 fs_root = add_root(&roots, BTRFS_ROOT_FSTREE);
1093 reloc_root = add_root(&roots, BTRFS_ROOT_DATA_RELOC);
1094
1095#ifndef __REACTOS__
1096 init_device(&dev, 1, size, &fsuuid, sector_size);
1097#else
1098 init_device(&dev, 1, size, &fsuuid, sector_size, &seed);
1099#endif
1100
1101 ssd = is_ssd(h);
1102
1103 sys_chunk = add_chunk(&chunks, BLOCK_FLAG_SYSTEM | (ssd ? 0 : BLOCK_FLAG_DUPLICATE), chunk_root, &dev, dev_root, &chunkuuid, sector_size);
1104 if (!sys_chunk)
1105 return STATUS_INTERNAL_ERROR;
1106
1107 metadata_flags = BLOCK_FLAG_METADATA;
1108
1109 if (!ssd && !(incompat_flags & BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS))
1110 metadata_flags |= BLOCK_FLAG_DUPLICATE;
1111
1112 if (incompat_flags & BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS)
1113 metadata_flags |= BLOCK_FLAG_DATA;
1114
1115 metadata_chunk = add_chunk(&chunks, metadata_flags, chunk_root, &dev, dev_root, &chunkuuid, sector_size);
1116 if (!metadata_chunk)
1117 return STATUS_INTERNAL_ERROR;
1118
1119 add_item(chunk_root, 1, TYPE_DEV_ITEM, dev.dev_item.dev_id, &dev.dev_item, sizeof(DEV_ITEM));
1120
1121 set_default_subvol(root_root, node_size);
1122
1123 init_fs_tree(fs_root, node_size);
1124 init_fs_tree(reloc_root, node_size);
1125
1126 assign_addresses(&roots, sys_chunk, metadata_chunk, node_size, root_root, extent_root, incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA);
1127
1128 add_block_group_items(&chunks, extent_root);
1129
1130 Status = write_roots(h, &roots, node_size, &fsuuid, &chunkuuid);
1131 if (!NT_SUCCESS(Status))
1132 return Status;
1133
1134 Status = clear_first_megabyte(h);
1135 if (!NT_SUCCESS(Status))
1136 return Status;
1137
1138 Status = write_superblocks(h, &dev, chunk_root, root_root, extent_root, sys_chunk, node_size, &fsuuid, sector_size, label, incompat_flags);
1139 if (!NT_SUCCESS(Status))
1140 return Status;
1141
1142 free_roots(&roots);
1143 free_chunks(&chunks);
1144
1145 return STATUS_SUCCESS;
1146}
is_ssd
static bool is_ssd(HANDLE h)
Definition: btrfslib.c:975
add_chunk
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)
Definition: btrfslib.c:392
write_superblocks
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_t node_size, BTRFS_UUID *fsuuid, uint32_t sector_size, PUNICODE_STRING label, uint64_t incompat_flags)
Definition: btrfslib.c:752
clear_first_megabyte
static NTSTATUS clear_first_megabyte(HANDLE h)
Definition: btrfslib.c:957
add_block_group_items
static void add_block_group_items(LIST_ENTRY *chunks, btrfs_root *extent_root)
Definition: btrfslib.c:940
add_root
static btrfs_root * add_root(LIST_ENTRY *roots, uint64_t id)
Definition: btrfslib.c:284
write_roots
static NTSTATUS write_roots(HANDLE h, LIST_ENTRY *roots, uint32_t node_size, BTRFS_UUID *fsuuid, BTRFS_UUID *chunkuuid)
Definition: btrfslib.c:620
init_fs_tree
static void init_fs_tree(btrfs_root *r, uint32_t node_size)
Definition: btrfslib.c:916
free_roots
static void free_roots(LIST_ENTRY *roots)
Definition: btrfslib.c:297
set_default_subvol
static void set_default_subvol(btrfs_root *root_root, uint32_t node_size)
Definition: btrfslib.c:1029
free_chunks
static void free_chunks(LIST_ENTRY *chunks)
Definition: btrfslib.c:324
assign_addresses
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)
Definition: btrfslib.c:507
BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA
#define BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA
Definition: btrfs.h:123
BTRFS_ROOT_DATA_RELOC
#define BTRFS_ROOT_DATA_RELOC
Definition: btrfs.h:63
TYPE_DEV_ITEM
#define TYPE_DEV_ITEM
Definition: btrfs.h:47
BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS
#define BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS
Definition: btrfs.h:117
BTRFS_ROOT_DEVTREE
#define BTRFS_ROOT_DEVTREE
Definition: btrfs.h:57
BTRFS_ROOT_CHECKSUM
#define BTRFS_ROOT_CHECKSUM
Definition: btrfs.h:60
srand
void __cdecl srand(_In_ unsigned int _Seed)
reloc_root
char * reloc_root
Definition: mkisofs.c:177
label
static const WCHAR label[]
Definition: itemdlg.c:1546
STATUS_INTERNAL_ERROR
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
NtGetTickCount
#define NtGetTickCount
Definition: rtlp.h:163
BLOCK_FLAG_DATA
#define BLOCK_FLAG_DATA
Definition: shellext.h:75
DEV_ITEM
Definition: btrfs.h:177

Referenced by FormatEx2().

◆ write_data()

static NTSTATUS write_data ( HANDLE  h,
uint64_t  address,
btrfs_chunk *  c,
void *  data,
ULONG  size 
)
static

Definition at line 580 of file btrfslib.c.

580 {
581 NTSTATUS Status;
582 uint16_t i;
583 IO_STATUS_BLOCK iosb;
584 LARGE_INTEGER off;
585 CHUNK_ITEM_STRIPE* cis;
586
587 cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
588
589 for (i = 0; i < c->chunk_item->num_stripes; i++) {
590 off.QuadPart = cis[i].offset + address - c->offset;
591
592 Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, data, size, &off, NULL);
593 if (!NT_SUCCESS(Status))
594 return Status;
595 }
596
597 return STATUS_SUCCESS;
598}

◆ write_roots()

static NTSTATUS write_roots ( HANDLE  h,
LIST_ENTRY *  roots,
uint32_t  node_size,
BTRFS_UUID *  fsuuid,
BTRFS_UUID *  chunkuuid 
)
static

Definition at line 620 of file btrfslib.c.

620 {
621 LIST_ENTRY *le, *le2;
622 NTSTATUS Status;
623 uint8_t* tree;
624
625 tree = malloc(node_size);
626
627 le = roots->Flink;
628 while (le != roots) {
629 btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry);
630 uint8_t* dp;
631 leaf_node* ln;
632
633 memset(tree, 0, node_size);
634
635 r->header.num_items = 0;
636 r->header.fs_uuid = *fsuuid;
637 r->header.flags = HEADER_FLAG_MIXED_BACKREF | HEADER_FLAG_WRITTEN;
638 r->header.chunk_tree_uuid = *chunkuuid;
639 r->header.generation = 1;
640 r->header.tree_id = r->id;
641
642 ln = (leaf_node*)(tree + sizeof(tree_header));
643
644 dp = tree + node_size;
645
646 le2 = r->items.Flink;
647 while (le2 != &r->items) {
648 btrfs_item* item = CONTAINING_RECORD(le2, btrfs_item, list_entry);
649
650 ln->key = item->key;
651 ln->size = item->size;
652
653 if (item->size > 0) {
654 dp -= item->size;
655 memcpy(dp, item->data, item->size);
656
657 ln->offset = (uint32_t)(dp - tree - sizeof(tree_header));
658 } else
659 ln->offset = 0;
660
661 ln = &ln[1];
662
663 r->header.num_items++;
664
665 le2 = le2->Flink;
666 }
667
668 memcpy(tree, &r->header, sizeof(tree_header));
669
670 calc_tree_checksum((tree_header*)tree, node_size);
671
672 Status = write_data(h, r->header.address, r->c, tree, node_size);
673 if (!NT_SUCCESS(Status)) {
674 free(tree);
675 return Status;
676 }
677
678 le = le->Flink;
679 }
680
681 free(tree);
682
683 return STATUS_SUCCESS;
684}
tree
struct _tree tree
calc_tree_checksum
static void calc_tree_checksum(tree_header *th, uint32_t node_size)
Definition: btrfslib.c:600
HEADER_FLAG_WRITTEN
#define HEADER_FLAG_WRITTEN
Definition: btrfs.h:149
HEADER_FLAG_MIXED_BACKREF
#define HEADER_FLAG_MIXED_BACKREF
Definition: btrfs.h:151
_tree
Definition: btrfs_drv.h:424
_tree::header
tree_header header
Definition: btrfs_drv.h:426
leaf_node
Definition: btrfs.h:165
leaf_node::offset
uint32_t offset
Definition: btrfs.h:167
leaf_node::key
KEY key
Definition: btrfs.h:166
leaf_node::size
uint32_t size
Definition: btrfs.h:168
write_data
Definition: winhttp_private.h:259

Referenced by write_btrfs().

◆ write_superblocks()

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_t  node_size,
BTRFS_UUID *  fsuuid,
uint32_t  sector_size,
PUNICODE_STRING  label,
uint64_t  incompat_flags 
)
static

Definition at line 752 of file btrfslib.c.

753 {
754 NTSTATUS Status;
755 IO_STATUS_BLOCK iosb;
756 ULONG sblen;
757 int i;
758 superblock* sb;
759 KEY* key;
760 uint64_t bytes_used;
761 LIST_ENTRY* le;
762
763 sblen = sizeof(*sb);
764 if (sblen & (sector_size - 1))
765 sblen = (sblen & sector_size) + sector_size;
766
767 bytes_used = 0;
768
769 le = extent_root->items.Flink;
770 while (le != &extent_root->items) {
771 btrfs_item* item = CONTAINING_RECORD(le, btrfs_item, list_entry);
772
773 if (item->key.obj_type == TYPE_EXTENT_ITEM)
774 bytes_used += item->key.offset;
775 else if (item->key.obj_type == TYPE_METADATA_ITEM)
776 bytes_used += node_size;
777
778 le = le->Flink;
779 }
780
781 sb = malloc(sblen);
782 memset(sb, 0, sblen);
783
784 sb->uuid = *fsuuid;
785 sb->flags = 1;
786 sb->magic = BTRFS_MAGIC;
787 sb->generation = 1;
788 sb->root_tree_addr = root_root->header.address;
789 sb->chunk_tree_addr = chunk_root->header.address;
790 sb->total_bytes = dev->dev_item.num_bytes;
791 sb->bytes_used = bytes_used;
792 sb->root_dir_objectid = BTRFS_ROOT_TREEDIR;
793 sb->num_devices = 1;
794 sb->sector_size = sector_size;
795 sb->node_size = node_size;
796 sb->leaf_size = node_size;
797 sb->stripe_size = sector_size;
798 sb->n = sizeof(KEY) + sizeof(CHUNK_ITEM) + (sys_chunk->chunk_item->num_stripes * sizeof(CHUNK_ITEM_STRIPE));
799 sb->chunk_root_generation = 1;
800 sb->incompat_flags = incompat_flags;
801 sb->csum_type = def_csum_type;
802 memcpy(&sb->dev_item, &dev->dev_item, sizeof(DEV_ITEM));
803
804 if (label->Length > 0) {
805#ifdef __REACTOS__
806 ANSI_STRING as;
807 unsigned int i;
808
809 for (i = 0; i < label->Length / sizeof(WCHAR); i++) {
810#else
811 ULONG utf8len;
812
813 for (unsigned int i = 0; i < label->Length / sizeof(WCHAR); i++) {
814#endif
815 if (label->Buffer[i] == '/' || label->Buffer[i] == '\\') {
816 free(sb);
817 return STATUS_INVALID_VOLUME_LABEL;
818 }
819 }
820
821#ifndef __REACTOS__
822 utf8len = WideCharToMultiByte(CP_UTF8, 0, label->Buffer, label->Length / sizeof(WCHAR), NULL, 0, NULL, NULL);
823
824 if (utf8len == 0 || utf8len > MAX_LABEL_SIZE) {
825 free(sb);
826 return STATUS_INVALID_VOLUME_LABEL;
827 }
828
829 if (WideCharToMultiByte(CP_UTF8, 0, label->Buffer, label->Length / sizeof(WCHAR), sb->label, utf8len, NULL, NULL) == 0) {
830#else
831 as.Buffer = sb->label;
832 as.Length = 0;
833 as.MaximumLength = MAX_LABEL_SIZE;
834
835 if (!NT_SUCCESS(RtlUnicodeStringToAnsiString(&as, label, FALSE)))
836 {
837#endif
838 free(sb);
839 return STATUS_INVALID_VOLUME_LABEL;
840 }
841 }
842 sb->cache_generation = 0xffffffffffffffff;
843
844 key = (KEY*)sb->sys_chunk_array;
845 key->obj_id = 0x100;
846 key->obj_type = TYPE_CHUNK_ITEM;
847 key->offset = sys_chunk->offset;
848 memcpy(&key[1], sys_chunk->chunk_item, sizeof(CHUNK_ITEM) + (sys_chunk->chunk_item->num_stripes * sizeof(CHUNK_ITEM_STRIPE)));
849
850 i = 0;
851 while (superblock_addrs[i] != 0) {
852 LARGE_INTEGER off;
853
854 if (superblock_addrs[i] > dev->dev_item.num_bytes)
855 break;
856
857 sb->sb_phys_addr = superblock_addrs[i];
858
859 calc_superblock_checksum(sb);
860
861 off.QuadPart = superblock_addrs[i];
862
863 Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, sb, sblen, &off, NULL);
864 if (!NT_SUCCESS(Status)) {
865 free(sb);
866 return Status;
867 }
868
869 i++;
870 }
871
872 free(sb);
873
874 return STATUS_SUCCESS;
875}
calc_superblock_checksum
static void calc_superblock_checksum(superblock *sb)
Definition: btrfslib.c:732
FALSE
#define FALSE
Definition: types.h:117
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
MAX_LABEL_SIZE
#define MAX_LABEL_SIZE
Definition: btrfs.h:19
KEY
#define KEY
Definition: profile.c:30
RtlUnicodeStringToAnsiString
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
CP_UTF8
#define CP_UTF8
Definition: nls.h:20
_ANSI_STRING
Definition: env_spec_w32.h:375
_ANSI_STRING::Buffer
PSTR Buffer
Definition: env_spec_w32.h:378
_ANSI_STRING::MaximumLength
USHORT MaximumLength
Definition: env_spec_w32.h:377
_ANSI_STRING::Length
USHORT Length
Definition: env_spec_w32.h:376
btrfs_root::items
LIST_ENTRY items
Definition: btrfslib.c:159
btrfs_root::header
tree_header header
Definition: btrfslib.c:157
key
Definition: copy.c:22
superblock::flags
uint64_t flags
Definition: btrfs.h:227
superblock::sector_size
uint32_t sector_size
Definition: btrfs.h:238
superblock::bytes_used
uint64_t bytes_used
Definition: btrfs.h:235
superblock::root_tree_addr
uint64_t root_tree_addr
Definition: btrfs.h:230
superblock::chunk_root_generation
uint64_t chunk_root_generation
Definition: btrfs.h:243
superblock::root_dir_objectid
uint64_t root_dir_objectid
Definition: btrfs.h:236
superblock::node_size
uint32_t node_size
Definition: btrfs.h:239
superblock::leaf_size
uint32_t leaf_size
Definition: btrfs.h:240
superblock::stripe_size
uint32_t stripe_size
Definition: btrfs.h:241
superblock::sb_phys_addr
uint64_t sb_phys_addr
Definition: btrfs.h:226
superblock::sys_chunk_array
uint8_t sys_chunk_array[SYS_CHUNK_ARRAY_SIZE]
Definition: btrfs.h:257
superblock::incompat_flags
uint64_t incompat_flags
Definition: btrfs.h:246
superblock::generation
uint64_t generation
Definition: btrfs.h:229
superblock::label
char label[MAX_LABEL_SIZE]
Definition: btrfs.h:252
superblock::cache_generation
uint64_t cache_generation
Definition: btrfs.h:253
superblock::num_devices
uint64_t num_devices
Definition: btrfs.h:237
superblock::chunk_tree_addr
uint64_t chunk_tree_addr
Definition: btrfs.h:231
superblock::n
uint32_t n
Definition: btrfs.h:242
superblock::total_bytes
uint64_t total_bytes
Definition: btrfs.h:234
tree_header::address
uint64_t address
Definition: btrfs.h:156
STATUS_INVALID_VOLUME_LABEL
#define STATUS_INVALID_VOLUME_LABEL
Definition: udferr_usr.h:156

Referenced by write_btrfs().

Variable Documentation

◆ def_csum_type

uint16_t def_csum_type = CSUM_TYPE_CRC32C

Definition at line 180 of file btrfslib.c.

Referenced by calc_superblock_checksum(), calc_tree_checksum(), FormatEx2(), SetCsumType(), and write_superblocks().

◆ def_incompat_flags

uint64_t def_incompat_flags = BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA

Definition at line 179 of file btrfslib.c.

Referenced by FormatEx2(), and SetIncompatFlags().

◆ def_node_size

ULONG def_node_size = 0

Definition at line 178 of file btrfslib.c.

Referenced by FormatEx2(), and SetSizes().

◆ def_sector_size

ULONG def_sector_size = 0

Definition at line 178 of file btrfslib.c.

Referenced by FormatEx2(), and SetSizes().

◆ module

HMODULE module

Definition at line 177 of file btrfslib.c.