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 "../btrfs.h"
#include "../btrfsioctl.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	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
NTSYSCALLAPI NTSTATUS NTAPI	NtFsControlFile (HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG FsControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength)
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)
static uint32_t	calc_crc32c (uint32_t seed, uint8_t *msg, ULONG msglen)
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 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 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	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 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	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)
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
static const uint32_t	crctable []

Macro Definition Documentation

DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED

#define DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED   0x80000000

Definition at line 54 of file btrfslib.c.

FORMAT_FLAG_DISMOUNT_FIRST

#define FORMAT_FLAG_DISMOUNT_FIRST   0x00000004

Definition at line 85 of file btrfslib.c.

FORMAT_FLAG_INTEGRITY_DISABLE

#define FORMAT_FLAG_INTEGRITY_DISABLE   0x00000100

Definition at line 88 of file btrfslib.c.

FORMAT_FLAG_LARGE_RECORDS

#define FORMAT_FLAG_LARGE_RECORDS   0x00000100

Definition at line 87 of file btrfslib.c.

FORMAT_FLAG_QUICK_FORMAT

#define FORMAT_FLAG_QUICK_FORMAT   0x00000001

Definition at line 83 of file btrfslib.c.

FORMAT_FLAG_UNKNOWN1

#define FORMAT_FLAG_UNKNOWN1   0x00000002

Definition at line 84 of file btrfslib.c.

FORMAT_FLAG_UNKNOWN2

#define FORMAT_FLAG_UNKNOWN2   0x00000040

Definition at line 86 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 51 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 49 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 50 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))))))

Definition at line 145 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 212 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 192 of file btrfslib.c.

             {
    PROGRESS,
    DONEWITHSTRUCTURE,
    UNKNOWN2,
    UNKNOWN3,
    UNKNOWN4,
    UNKNOWN5,
    INSUFFICIENTRIGHTS,
    FSNOTSUPPORTED,
    VOLUMEINUSE,
    UNKNOWN9,
    UNKNOWNA,
    DONE,
    UNKNOWNC,
    UNKNOWND,
    OUTPUT,
    STRUCTUREPROGRESS,
    CLUSTERSIZETOOSMALL,
} CALLBACKCOMMAND;

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 165 of file btrfslib.c.

             {
    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_MEDIA_FLAG;

Function Documentation

add_block_group_items()

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

static

Definition at line 974 of file btrfslib.c.

                                                                               {
    LIST_ENTRY* le;

    le = chunks->Flink;
    while (le != chunks) {
        btrfs_chunk* c = CONTAINING_RECORD(le, btrfs_chunk, list_entry);
        BLOCK_GROUP_ITEM bgi;

        bgi.used = c->used;
        bgi.chunk_tree = 0x100;
        bgi.flags = c->chunk_item->type;
        add_item(extent_root, c->offset, TYPE_BLOCK_GROUP_ITEM, c->chunk_item->size, &bgi, sizeof(BLOCK_GROUP_ITEM));

        le = le->Flink;
    }
}

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 419 of file btrfslib.c.

                                                                                                                                                                             {
    uint64_t off, size;
    uint16_t stripes, i;
    btrfs_chunk* c;
    LIST_ENTRY* le;
    CHUNK_ITEM_STRIPE* cis;

    off = 0xc00000;
    le = chunks->Flink;
    while (le != chunks) {
        c = CONTAINING_RECORD(le, btrfs_chunk, list_entry);

        if (c->offset + c->chunk_item->size > off)
            off = c->offset + c->chunk_item->size;

        le = le->Flink;
    }

    if (flags & BLOCK_FLAG_METADATA) {
        if (dev->dev_item.num_bytes > 0xC80000000) // 50 GB
            size = 0x40000000; // 1 GB
        else
            size = 0x10000000; // 256 MB
    } else if (flags & BLOCK_FLAG_SYSTEM)
        size = 0x800000;

    size = min(size, dev->dev_item.num_bytes / 10); // cap at 10%
    size &= ~(sector_size - 1);

    stripes = flags & BLOCK_FLAG_DUPLICATE ? 2 : 1;

    if (dev->dev_item.num_bytes - dev->dev_item.bytes_used < stripes * size) // not enough space
        return NULL;

#ifndef __REACTOS__
    c = malloc(sizeof(btrfs_chunk));
#else
    c = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(btrfs_chunk));
#endif
    c->offset = off;
    c->lastoff = off;
    c->used = 0;

#ifndef __REACTOS__
    c->chunk_item = malloc(sizeof(CHUNK_ITEM) + (stripes * sizeof(CHUNK_ITEM_STRIPE)));
#else
    c->chunk_item = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(CHUNK_ITEM) + (stripes * sizeof(CHUNK_ITEM_STRIPE)));
#endif

    c->chunk_item->size = size;
    c->chunk_item->root_id = BTRFS_ROOT_EXTENT;
    c->chunk_item->stripe_length = max(sector_size, 0x10000);
    c->chunk_item->type = flags;
    c->chunk_item->opt_io_alignment = max(sector_size, 0x10000);
    c->chunk_item->opt_io_width = max(sector_size, 0x10000);
    c->chunk_item->sector_size = sector_size;
    c->chunk_item->num_stripes = stripes;
    c->chunk_item->sub_stripes = 0;

    cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];

    for (i = 0; i < stripes; i++) {
        cis[i].dev_id = dev->dev_item.dev_id;
        cis[i].offset = find_chunk_offset(size, c->offset, dev, dev_root, chunkuuid);
        cis[i].dev_uuid = dev->dev_item.device_uuid;
    }

    add_item(chunk_root, 0x100, TYPE_CHUNK_ITEM, c->offset, c->chunk_item, sizeof(CHUNK_ITEM) + (stripes * sizeof(CHUNK_ITEM_STRIPE)));

    InsertTailList(chunks, &c->list_entry);

    return c;
}

Referenced by write_btrfs().

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 358 of file btrfslib.c.

                                                                                                                   {
    LIST_ENTRY* le;
    btrfs_item* item;

#ifndef __REACTOS__
    item = malloc(sizeof(btrfs_item));
#else
    item = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(btrfs_item));
#endif

    item->key.obj_id = obj_id;
    item->key.obj_type = obj_type;
    item->key.offset = offset;
    item->size = size;

    if (size == 0)
        item->data = NULL;
    else {
#ifndef __REACTOS__
        item->data = malloc(size);
#else
        item->data = RtlAllocateHeap(RtlGetProcessHeap(), 0, size);
#endif
        memcpy(item->data, data, size);
    }

    le = r->items.Flink;
    while (le != &r->items) {
        btrfs_item* i2 = CONTAINING_RECORD(le, btrfs_item, list_entry);

        if (keycmp(item->key, i2->key) != 1) {
            InsertTailList(le, &item->list_entry);
            return;
        }

        le = le->Flink;
    }

    InsertTailList(&r->items, &item->list_entry);
}

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

add_root()

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

static

Definition at line 282 of file btrfslib.c.

                                                            {
    btrfs_root* root;

#ifdef __REACTOS__
    root = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(btrfs_root));
#else
    root = malloc(sizeof(btrfs_root));
#endif

    root->id = id;
#ifndef __REACTOS__
    RtlZeroMemory(&root->header, sizeof(tree_header));
#endif
    InitializeListHead(&root->items);
    InsertTailList(roots, &root->list_entry);

    return root;
}

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 542 of file btrfslib.c.

                                                                                          {
    LIST_ENTRY* le;

    le = roots->Flink;
    while (le != roots) {
        btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry);
        btrfs_chunk* c = r->id == BTRFS_ROOT_CHUNK ? sys_chunk : metadata_chunk;

        r->header.address = get_next_address(c);
        r->c = c;
        c->lastoff = r->header.address + node_size;
        c->used += node_size;

        if (skinny) {
            EXTENT_ITEM_METADATA eim;

            eim.ei.refcount = 1;
            eim.ei.generation = 1;
            eim.ei.flags = EXTENT_ITEM_TREE_BLOCK;
            eim.type = TYPE_TREE_BLOCK_REF;
            eim.tbr.offset = r->id;

            add_item(extent_root, r->header.address, TYPE_METADATA_ITEM, 0, &eim, sizeof(EXTENT_ITEM_METADATA));
        } else {
            EXTENT_ITEM_METADATA2 eim2;
            KEY firstitem;

            if (r->items.Flink == &r->items) {
                firstitem.obj_id = 0;
                firstitem.obj_type = 0;
                firstitem.offset = 0;
            } else {
                btrfs_item* bi = CONTAINING_RECORD(r->items.Flink, btrfs_item, list_entry);

                firstitem = bi->key;
            }

            eim2.ei.refcount = 1;
            eim2.ei.generation = 1;
            eim2.ei.flags = EXTENT_ITEM_TREE_BLOCK;
            eim2.ei2.firstitem = firstitem;
            eim2.ei2.level = 0;
            eim2.type = TYPE_TREE_BLOCK_REF;
            eim2.tbr.offset = r->id;

            add_item(extent_root, r->header.address, TYPE_EXTENT_ITEM, node_size, &eim2, sizeof(EXTENT_ITEM_METADATA2));
        }

        if (r->id != BTRFS_ROOT_ROOT && r->id != BTRFS_ROOT_CHUNK) {
            ROOT_ITEM ri;

            memset(&ri, 0, sizeof(ROOT_ITEM));

            ri.inode.generation = 1;
            ri.inode.st_size = 3;
            ri.inode.st_blocks = node_size;
            ri.inode.st_nlink = 1;
            ri.inode.st_mode = 040755;
            ri.generation = 1;
            ri.objid = r->id == 5 || r->id >= 0x100 ? SUBVOL_ROOT_INODE : 0;
            ri.block_number = r->header.address;
            ri.bytes_used = node_size;
            ri.num_references = 1;
            ri.generation2 = ri.generation;

            add_item(root_root, r->id, TYPE_ROOT_ITEM, 0, &ri, sizeof(ROOT_ITEM));
        }

        le = le->Flink;
    }
}

Referenced by write_btrfs().

calc_crc32c()

static uint32_t calc_crc32c ( uint32_t  seed, uint8_t *  msg, ULONG  msglen  )

static

Definition at line 249 of file btrfslib.c.

                                                                       {
    uint32_t rem;
    ULONG i;

    rem = seed;

    for (i = 0; i < msglen; i++) {
        rem = crctable[(rem ^ msg[i]) & 0xff] ^ (rem >> 8);
    }

    return rem;
}

Referenced by is_mounted_multi_device(), write_roots(), and write_superblocks().

ChkdskEx()

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

Definition at line 263 of file btrfslib.c.

                                                                     {
    // STUB

    if (Callback) {
        TEXTOUTPUT TextOut;

        TextOut.Lines = 1;
        TextOut.Output = "stub, not implemented";

        Callback(OUTPUT, 0, &TextOut);
    }

    return STATUS_SUCCESS;
}

clear_first_megabyte()

static NTSTATUS clear_first_megabyte ( HANDLE  h )

static

Definition at line 991 of file btrfslib.c.

                                               {
    NTSTATUS Status;
    IO_STATUS_BLOCK iosb;
    LARGE_INTEGER zero;
    uint8_t* mb;

#ifndef __REACTOS__
    mb = malloc(0x100000);
    memset(mb, 0, 0x100000);
#else
    mb = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, 0x100000);
#endif

    zero.QuadPart = 0;

    Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, mb, 0x100000, &zero, NULL);

#ifndef __REACTOS__
    free(mb);
#else
    RtlFreeHeap(RtlGetProcessHeap(), 0, mb);
#endif

    return Status;
}

Referenced by write_btrfs().

DllMain()

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

Definition at line 1536 of file btrfslib.c.

                                                                        {
    if (dwReason == DLL_PROCESS_ATTACH)
        module = (HMODULE)hModule;

    return TRUE;
}

do_full_trim()

static void do_full_trim ( HANDLE  h )

static

Definition at line 1298 of file btrfslib.c.

                                   {
    IO_STATUS_BLOCK iosb;
    DEVICE_MANAGE_DATA_SET_ATTRIBUTES dmdsa;

    RtlZeroMemory(&dmdsa, sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES));

    dmdsa.Size = sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES);
    dmdsa.Action = DeviceDsmAction_Trim;
    dmdsa.Flags = DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE | DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED;
    dmdsa.ParameterBlockOffset = 0;
    dmdsa.ParameterBlockLength = 0;
    dmdsa.DataSetRangesOffset = 0;
    dmdsa.DataSetRangesLength = 0;

    NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES, &dmdsa, sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), NULL, 0);
}

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 399 of file btrfslib.c.

                                                                                                                               {
    uint64_t off;
    DEV_EXTENT de;

    off = dev->last_alloc;
    dev->last_alloc += size;

    dev->dev_item.bytes_used += size;

    de.chunktree = BTRFS_ROOT_CHUNK;
    de.objid = 0x100;
    de.address = offset;
    de.length = size;
    de.chunktree_uuid = *chunkuuid;

    add_item(dev_root, dev->dev_item.dev_id, TYPE_DEV_EXTENT, off, &de, sizeof(DEV_EXTENT));

    return off;
}

Referenced by add_chunk().

FormatEx()

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

Definition at line 1490 of file btrfslib.c.

                                                                                              {
    UNICODE_STRING DriveRoot, Label;
    NTSTATUS Status;

    if (!root || !root->string)
        return FALSE;

    DriveRoot.Length = DriveRoot.MaximumLength = (USHORT)(wcslen(root->string) * sizeof(WCHAR));
    DriveRoot.Buffer = root->string;

    if (opts && opts->label && opts->label->string) {
        Label.Length = Label.MaximumLength = (USHORT)(wcslen(opts->label->string) * sizeof(WCHAR));
        Label.Buffer = opts->label->string;
    } else {
        Label.Length = Label.MaximumLength = 0;
        Label.Buffer = NULL;
    }

#ifndef __REACTOS__
    Status = FormatEx2(&DriveRoot, FMIFS_HARDDISK, &Label, opts && opts->flags & FORMAT_FLAG_QUICK_FORMAT, 0, NULL);
#else
    Status = BtrfsFormatEx(&DriveRoot, FMIFS_HARDDISK, &Label, opts && opts->flags & FORMAT_FLAG_QUICK_FORMAT, 0, NULL);
#endif

    return NT_SUCCESS(Status);
}

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 1320 of file btrfslib.c.

{
    NTSTATUS Status;
    HANDLE h, btrfsh;
    OBJECT_ATTRIBUTES attr;
    IO_STATUS_BLOCK iosb;
    GET_LENGTH_INFORMATION gli;
    DISK_GEOMETRY dg;
    uint32_t sector_size, node_size;
    UNICODE_STRING btrfsus;
#ifndef __REACTOS__
    HANDLE token;
    TOKEN_PRIVILEGES tp;
    LUID luid;
#endif
    uint64_t incompat_flags;
    UNICODE_STRING empty_label;

    static WCHAR btrfs[] = L"\\Btrfs";

#ifndef __REACTOS__
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token))
        return STATUS_PRIVILEGE_NOT_HELD;

    if (!LookupPrivilegeValueW(NULL, L"SeManageVolumePrivilege", &luid)) {
        CloseHandle(token);
        return STATUS_PRIVILEGE_NOT_HELD;
    }

    tp.PrivilegeCount = 1;
    tp.Privileges[0].Luid = luid;
    tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

    if (!AdjustTokenPrivileges(token, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL)) {
        CloseHandle(token);
        return STATUS_PRIVILEGE_NOT_HELD;
    }

    CloseHandle(token);
#endif

    InitializeObjectAttributes(&attr, DriveRoot, OBJ_CASE_INSENSITIVE, NULL, NULL);

    Status = NtOpenFile(&h, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &attr, &iosb,
                        FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT);

    if (!NT_SUCCESS(Status))
        return Status;

    Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli));
    if (!NT_SUCCESS(Status)) {
        NtClose(h);
        return Status;
    }

    // MSDN tells us to use IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, but there are
    // some instances where it fails and IOCTL_DISK_GET_DRIVE_GEOMETRY succeeds -
    // such as with spanned volumes.
    Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &dg, sizeof(dg));
    if (!NT_SUCCESS(Status)) {
        NtClose(h);
        return Status;
    }

    if (def_sector_size == 0) {
        sector_size = dg.BytesPerSector;

        if (sector_size == 0x200 || sector_size == 0)
            sector_size = 0x1000;
    } else {
        if (dg.BytesPerSector != 0 && (def_sector_size < dg.BytesPerSector || def_sector_size % dg.BytesPerSector != 0 || !is_power_of_two(def_sector_size / dg.BytesPerSector))) {
            NtClose(h);
            return STATUS_INVALID_PARAMETER;
        }

        sector_size = def_sector_size;
    }

    if (def_node_size == 0)
        node_size = 0x4000;
    else {
        if (def_node_size < sector_size || def_node_size % sector_size != 0 || !is_power_of_two(def_node_size / sector_size)) {
            NtClose(h);
            return STATUS_INVALID_PARAMETER;
        }

        node_size = def_node_size;
    }

    if (Callback) {
        ULONG pc = 0;
        Callback(PROGRESS, 0, (PVOID)&pc);
    }

    NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0);

    if (is_mounted_multi_device(h, sector_size)) {
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }

    do_full_trim(h);

    incompat_flags = def_incompat_flags;
    incompat_flags |= BTRFS_INCOMPAT_FLAGS_MIXED_BACKREF | BTRFS_INCOMPAT_FLAGS_BIG_METADATA;

    if (!Label) {
        empty_label.Buffer = NULL;
        empty_label.Length = empty_label.MaximumLength = 0;
        Label = &empty_label;
    }

    Status = write_btrfs(h, gli.Length.QuadPart, Label, sector_size, node_size, incompat_flags);

    NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0);

end:
    NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0);

    NtClose(h);

    if (NT_SUCCESS(Status)) {
        btrfsus.Buffer = btrfs;
        btrfsus.Length = btrfsus.MaximumLength = (USHORT)(wcslen(btrfs) * sizeof(WCHAR));

        InitializeObjectAttributes(&attr, &btrfsus, 0, NULL, NULL);

        Status = NtOpenFile(&btrfsh, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &attr, &iosb,
                            FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT);

        if (NT_SUCCESS(Status)) {
            MOUNTDEV_NAME* mdn;
            ULONG mdnsize;

            mdnsize = offsetof(MOUNTDEV_NAME, Name[0]) + DriveRoot->Length;
#ifndef __REACTOS__
            mdn = malloc(mdnsize);
#else
            mdn = RtlAllocateHeap(RtlGetProcessHeap(), 0, mdnsize);
#endif

            mdn->NameLength = DriveRoot->Length;
            memcpy(mdn->Name, DriveRoot->Buffer, DriveRoot->Length);

            NtDeviceIoControlFile(btrfsh, NULL, NULL, NULL, &iosb, IOCTL_BTRFS_PROBE_VOLUME, mdn, mdnsize, NULL, 0);

#ifndef __REACTOS__
            free(mdn);
#else
            RtlFreeHeap(RtlGetProcessHeap(), 0, mdn);
#endif

            NtClose(btrfsh);
        }

        Status = STATUS_SUCCESS;
    }

    if (Callback) {
        BOOL success = NT_SUCCESS(Status);
        Callback(DONE, 0, (PVOID)&success);
    }

    return Status;
}

Referenced by FormatEx().

free_chunks()

static void free_chunks ( LIST_ENTRY *  chunks )

static

Definition at line 338 of file btrfslib.c.

                                            {
    LIST_ENTRY* le;

    le = chunks->Flink;
    while (le != chunks) {
        LIST_ENTRY *le2 = le->Flink;
        btrfs_chunk* c = CONTAINING_RECORD(le, btrfs_chunk, list_entry);

#ifndef __REACTOS__
        free(c->chunk_item);
        free(c);
#else
        RtlFreeHeap(RtlGetProcessHeap(), 0, c->chunk_item);
        RtlFreeHeap(RtlGetProcessHeap(), 0, c);
#endif

        le = le2;
    }
}

Referenced by write_btrfs().

free_roots()

static void free_roots ( LIST_ENTRY *  roots )

static

Definition at line 301 of file btrfslib.c.

                                          {
    LIST_ENTRY* le;

    le = roots->Flink;
    while (le != roots) {
        LIST_ENTRY *le2 = le->Flink, *le3;
        btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry);

        le3 = r->items.Flink;
        while (le3 != &r->items) {
            LIST_ENTRY* le4 = le3->Flink;
            btrfs_item* item = CONTAINING_RECORD(le3, btrfs_item, list_entry);

            if (item->data)
#ifdef __REACTOS__
                RtlFreeHeap(RtlGetProcessHeap(), 0, item->data);

            RtlFreeHeap(RtlGetProcessHeap(), 0, item);
#else
                free(item->data);

            free(item);
#endif

            le3 = le4;
        }

#ifdef __REACTOS__
        RtlFreeHeap(RtlGetProcessHeap(), 0, r);
#else
        free(r);
#endif

        le = le2;
    }
}

Referenced by write_btrfs().

get_next_address()

static uint64_t get_next_address ( btrfs_chunk *  c )

static

Definition at line 514 of file btrfslib.c.

                                                 {
    uint64_t addr;

    addr = c->lastoff;

    while (superblock_collision(c, addr)) {
        addr = addr - ((addr - c->offset) % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;

        if (addr >= c->offset + c->chunk_item->size) // chunk has been exhausted
            return 0;
    }

    return addr;
}

Referenced by assign_addresses().

get_uuid()

static void get_uuid ( BTRFS_UUID *  uuid )

static

Definition at line 716 of file btrfslib.c.

                                       {
#else
static void get_uuid(BTRFS_UUID* uuid, ULONG* seed) {
#endif
    uint8_t i;

    for (i = 0; i < 16; i+=2) {
#ifndef __REACTOS__
        ULONG r = rand();
#else
        ULONG r = RtlRandom(seed);
#endif

        uuid->uuid[i] = (r & 0xff00) >> 8;
        uuid->uuid[i+1] = r & 0xff;
    }
}

Referenced by init_device(), and write_btrfs().

GetFilesystemInformation()

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

Definition at line 1529 of file btrfslib.c.

                                                                                  {
    // STUB - undocumented

    return TRUE;
}

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 735 of file btrfslib.c.

                                                                                                              {
#else
static void init_device(btrfs_dev* dev, uint64_t id, uint64_t size, BTRFS_UUID* fsuuid, uint32_t sector_size, ULONG* seed) {
#endif
    dev->dev_item.dev_id = id;
    dev->dev_item.num_bytes = size;
    dev->dev_item.bytes_used = 0;
    dev->dev_item.optimal_io_align = sector_size;
    dev->dev_item.optimal_io_width = sector_size;
    dev->dev_item.minimal_io_size = sector_size;
    dev->dev_item.type = 0;
    dev->dev_item.generation = 0;
    dev->dev_item.start_offset = 0;
    dev->dev_item.dev_group = 0;
    dev->dev_item.seek_speed = 0;
    dev->dev_item.bandwidth = 0;
#ifndef __REACTOS__
    get_uuid(&dev->dev_item.device_uuid);
#else
    get_uuid(&dev->dev_item.device_uuid, seed);
#endif
    dev->dev_item.fs_uuid = *fsuuid;

    dev->last_alloc = 0x100000; // skip first megabyte
}

Referenced by write_btrfs().

init_fs_tree()

static void init_fs_tree ( btrfs_root *  r, uint32_t  node_size  )

static

Definition at line 932 of file btrfslib.c.

                                                            {
    INODE_ITEM ii;
    INODE_REF* ir;
    FILETIME filetime;
    LARGE_INTEGER time;

    memset(&ii, 0, sizeof(INODE_ITEM));

    ii.generation = 1;
    ii.st_blocks = node_size;
    ii.st_nlink = 1;
    ii.st_mode = 040755;

    GetSystemTimeAsFileTime(&filetime);
    time.LowPart = filetime.dwLowDateTime;
    time.HighPart = filetime.dwHighDateTime;

    win_time_to_unix(time, &ii.st_atime);
    ii.st_ctime = ii.st_mtime = ii.st_atime;

    add_item(r, SUBVOL_ROOT_INODE, TYPE_INODE_ITEM, 0, &ii, sizeof(INODE_ITEM));

#ifndef __REACTOS__
    ir = malloc(sizeof(INODE_REF) - 1 + 2);
#else
    ir = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(INODE_REF) - 1 + 2);
#endif

    ir->index = 0;
    ir->n = 2;
    ir->name[0] = '.';
    ir->name[1] = '.';

    add_item(r, SUBVOL_ROOT_INODE, TYPE_INODE_REF, SUBVOL_ROOT_INODE, ir, sizeof(INODE_REF) - 1 + ir->n);

#ifndef __REACTOS__
    free(ir);
#else
    RtlFreeHeap(RtlGetProcessHeap(), 0, ir);
#endif
}

Referenced by write_btrfs().

InitializeListHead()

FORCEINLINE VOID InitializeListHead

(

PLIST_ENTRY

ListHead

)

Definition at line 98 of file btrfslib.c.

                                                          {
    ListHead->Flink = ListHead->Blink = ListHead;
}

Referenced by add_root(), and write_btrfs().

InsertTailList()

FORCEINLINE VOID InsertTailList	(	PLIST_ENTRY	ListHead,
		PLIST_ENTRY	Entry
	)

Definition at line 102 of file btrfslib.c.

                                                                         {
    PLIST_ENTRY Blink;

    Blink = ListHead->Blink;
    Entry->Flink = ListHead;
    Entry->Blink = Blink;
    Blink->Flink = Entry;
    ListHead->Blink = Entry;
}

Referenced by add_chunk(), add_item(), and add_root().

is_mounted_multi_device()

static BOOL is_mounted_multi_device ( HANDLE  h, uint32_t  sector_size  )

static

Definition at line 1166 of file btrfslib.c.

                                                                    {
    NTSTATUS Status;
    superblock* sb;
    ULONG sblen;
    IO_STATUS_BLOCK iosb;
    LARGE_INTEGER off;
    BTRFS_UUID fsuuid, devuuid;
    uint32_t crc32;
    UNICODE_STRING us;
    OBJECT_ATTRIBUTES atts;
    HANDLE h2;
    btrfs_filesystem *bfs = NULL, *bfs2;
    ULONG bfssize;
    BOOL ret = FALSE;

    static WCHAR btrfs[] = L"\\Btrfs";

    sblen = sizeof(*sb);
    if (sblen & (sector_size - 1))
        sblen = (sblen & sector_size) + sector_size;

#ifndef __REACTOS__
    sb = malloc(sblen);
#else
    sb = RtlAllocateHeap(RtlGetProcessHeap(), 0, sblen);
#endif

    off.QuadPart = superblock_addrs[0];

    Status = NtReadFile(h, NULL, NULL, NULL, &iosb, sb, sblen, &off, NULL);
    if (!NT_SUCCESS(Status)) {
#ifndef __REACTOS__
        free(sb);
#else
        RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif
        return FALSE;
    }

    if (sb->magic != BTRFS_MAGIC) {
#ifndef __REACTOS__
        free(sb);
#else
        RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif
        return FALSE;
    }

    crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
    if (crc32 != *((uint32_t*)sb)) {
#ifndef __REACTOS__
        free(sb);
#else
        RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif
        return FALSE;
    }

    fsuuid = sb->uuid;
    devuuid = sb->dev_item.device_uuid;

#ifndef __REACTOS__
    free(sb);
#else
    RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif

    us.Length = us.MaximumLength = (USHORT)(wcslen(btrfs) * sizeof(WCHAR));
    us.Buffer = btrfs;

    InitializeObjectAttributes(&atts, &us, 0, NULL, NULL);

    Status = NtOpenFile(&h2, SYNCHRONIZE | FILE_READ_ATTRIBUTES, &atts, &iosb,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_ALERT);
    if (!NT_SUCCESS(Status)) // not a problem, it usually just means the driver isn't loaded
        return FALSE;

    bfssize = 0;

    do {
        bfssize += 1024;

#ifndef __REACTOS__
        if (bfs) free(bfs);
        bfs = malloc(bfssize);
#else
        if (bfs) RtlFreeHeap(RtlGetProcessHeap(), 0, bfs);
        bfs = RtlAllocateHeap(RtlGetProcessHeap(), 0, bfssize);
#endif

        Status = NtDeviceIoControlFile(h2, NULL, NULL, NULL, &iosb, IOCTL_BTRFS_QUERY_FILESYSTEMS, NULL, 0, bfs, bfssize);
        if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
            NtClose(h2);
            return FALSE;
        }
    } while (Status == STATUS_BUFFER_OVERFLOW);

    if (!NT_SUCCESS(Status))
        goto end;

    if (bfs->num_devices != 0) {
        bfs2 = bfs;
        while (TRUE) {
            if (RtlCompareMemory(&bfs2->uuid, &fsuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
                if (bfs2->num_devices == 1)
                    ret = FALSE;
                else
                    ret = look_for_device(bfs2, &devuuid);

                goto end;
            }

            if (bfs2->next_entry == 0)
                break;
            else
                bfs2 = (btrfs_filesystem*)((uint8_t*)bfs2 + bfs2->next_entry);
        }
    }

end:
    NtClose(h2);

    if (bfs)
#ifndef __REACTOS__
        free(bfs);
#else
        RtlFreeHeap(RtlGetProcessHeap(), 0, bfs);
#endif

    return ret;
}

Referenced by FormatEx2().

is_power_of_two()

static BOOL is_power_of_two ( ULONG  i )

static

Definition at line 1315 of file btrfslib.c.

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

Referenced by FormatEx2().

is_ssd()

static BOOL is_ssd ( HANDLE  h )

static

Definition at line 1017 of file btrfslib.c.

                             {
    ULONG aptelen;
    ATA_PASS_THROUGH_EX* apte;
    IO_STATUS_BLOCK iosb;
    NTSTATUS Status;
    IDENTIFY_DEVICE_DATA* idd;

    aptelen = sizeof(ATA_PASS_THROUGH_EX) + 512;
#ifndef __REACTOS__
    apte = malloc(aptelen);

    RtlZeroMemory(apte, aptelen);
#else
    apte = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, aptelen);
#endif

    apte->Length = sizeof(ATA_PASS_THROUGH_EX);
    apte->AtaFlags = ATA_FLAGS_DATA_IN;
    apte->DataTransferLength = aptelen - sizeof(ATA_PASS_THROUGH_EX);
    apte->TimeOutValue = 3;
    apte->DataBufferOffset = apte->Length;
    apte->CurrentTaskFile[6] = IDE_COMMAND_IDENTIFY;

    Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_ATA_PASS_THROUGH, apte, aptelen, apte, aptelen);

    if (NT_SUCCESS(Status)) {
        idd = (IDENTIFY_DEVICE_DATA*)((uint8_t*)apte + sizeof(ATA_PASS_THROUGH_EX));

        if (idd->NominalMediaRotationRate == 1) {
#ifndef __REACTOS__
            free(apte);
#else
            RtlFreeHeap(RtlGetProcessHeap(), 0, apte);
#endif
            return TRUE;
        }
    }

#ifndef __REACTOS__
    free(apte);
#else
    RtlFreeHeap(RtlGetProcessHeap(), 0, apte);
#endif

    return FALSE;
}

Referenced by write_btrfs().

look_for_device()

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

static

Definition at line 1149 of file btrfslib.c.

                                                                        {
    uint32_t i;
    btrfs_filesystem_device* dev;

    for (i = 0; i < bfs->num_devices; i++) {
        if (i == 0)
            dev = &bfs->device;
        else
            dev = (btrfs_filesystem_device*)((uint8_t*)dev + offsetof(btrfs_filesystem_device, name[0]) + dev->name_length);

        if (RtlCompareMemory(&dev->uuid, devuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID))
            return TRUE;
    }

    return FALSE;
}

Referenced by is_mounted_multi_device().

NtFsControlFile()

NTSYSCALLAPI NTSTATUS NTAPI NtFsControlFile	(	HANDLE	FileHandle,
		HANDLE	Event,
		PIO_APC_ROUTINE	ApcRoutine,
		PVOID	ApcContext,
		PIO_STATUS_BLOCK	IoStatusBlock,
		ULONG	FsControlCode,
		PVOID	InputBuffer,
		ULONG	InputBufferLength,
		PVOID	OutputBuffer,
		ULONG	OutputBufferLength
	)

Referenced by FormatEx2().

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().

SetIncompatFlags()

void __stdcall SetIncompatFlags

(

uint64_t

incompat_flags

)

Definition at line 1525 of file btrfslib.c.

                                                         {
    def_incompat_flags = incompat_flags;
}

SetSizes()

void __stdcall SetSizes	(	ULONG	sector,
		ULONG	node
	)

Definition at line 1517 of file btrfslib.c.

                                                  {
    if (sector != 0)
        def_sector_size = sector;

    if (node != 0)
        def_node_size = node;
}

superblock_collision()

static BOOL superblock_collision ( btrfs_chunk *  c, uint64_t  address  )

static

Definition at line 493 of file btrfslib.c.

                                                                   {
    CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
    uint64_t stripe = (address - c->offset) / c->chunk_item->stripe_length;
    uint16_t i, j;

    for (i = 0; i < c->chunk_item->num_stripes; i++) {
        j = 0;
        while (superblock_addrs[j] != 0) {
            if (superblock_addrs[j] >= cis[i].offset) {
                uint64_t stripe2 = (superblock_addrs[j] - cis[i].offset) / c->chunk_item->stripe_length;

                if (stripe2 == stripe)
                    return TRUE;
            }
            j++;
        }
    }

    return FALSE;
}

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 906 of file btrfslib.c.

                                                                        {
    ULONGLONG l = t.QuadPart - 116444736000000000;

    out->seconds = l / 10000000;
    out->nanoseconds = (l % 10000000) * 100;
}

Referenced by init_fs_tree().

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 1064 of file btrfslib.c.

                                                                                                                                               {
    NTSTATUS Status;
    LIST_ENTRY roots, chunks;
    btrfs_root *root_root, *chunk_root, *extent_root, *dev_root, *fs_root, *reloc_root;
    btrfs_chunk *sys_chunk, *metadata_chunk;
    btrfs_dev dev;
    BTRFS_UUID fsuuid, chunkuuid;
    BOOL ssd;
    uint64_t metadata_flags;
#ifdef __REACTOS__
    ULONG seed;
#endif

#ifndef __REACTOS__
    srand((unsigned int)time(0));
    get_uuid(&fsuuid);
    get_uuid(&chunkuuid);
#else
    seed = NtGetTickCount();
    get_uuid(&fsuuid, &seed);
    get_uuid(&chunkuuid, &seed);
#endif

    InitializeListHead(&roots);
    InitializeListHead(&chunks);

    root_root = add_root(&roots, BTRFS_ROOT_ROOT);
    chunk_root = add_root(&roots, BTRFS_ROOT_CHUNK);
    extent_root = add_root(&roots, BTRFS_ROOT_EXTENT);
    dev_root = add_root(&roots, BTRFS_ROOT_DEVTREE);
    add_root(&roots, BTRFS_ROOT_CHECKSUM);
    fs_root = add_root(&roots, BTRFS_ROOT_FSTREE);
    reloc_root = add_root(&roots, BTRFS_ROOT_DATA_RELOC);

#ifndef __REACTOS__
    init_device(&dev, 1, size, &fsuuid, sector_size);
#else
    init_device(&dev, 1, size, &fsuuid, sector_size, &seed);
#endif

    ssd = is_ssd(h);

    sys_chunk = add_chunk(&chunks, BLOCK_FLAG_SYSTEM | (ssd ? 0 : BLOCK_FLAG_DUPLICATE), chunk_root, &dev, dev_root, &chunkuuid, sector_size);
    if (!sys_chunk)
        return STATUS_INTERNAL_ERROR;

    metadata_flags = BLOCK_FLAG_METADATA;

    if (!ssd && !(incompat_flags & BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS))
        metadata_flags |= BLOCK_FLAG_DUPLICATE;

    if (incompat_flags & BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS)
        metadata_flags |= BLOCK_FLAG_DATA;

    metadata_chunk = add_chunk(&chunks, metadata_flags, chunk_root, &dev, dev_root, &chunkuuid, sector_size);
    if (!metadata_chunk)
        return STATUS_INTERNAL_ERROR;

    add_item(chunk_root, 1, TYPE_DEV_ITEM, dev.dev_item.dev_id, &dev.dev_item, sizeof(DEV_ITEM));

    init_fs_tree(fs_root, node_size);
    init_fs_tree(reloc_root, node_size);

    assign_addresses(&roots, sys_chunk, metadata_chunk, node_size, root_root, extent_root, incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA);

    add_block_group_items(&chunks, extent_root);

    Status = write_roots(h, &roots, node_size, &fsuuid, &chunkuuid);
    if (!NT_SUCCESS(Status))
        return Status;

    Status = clear_first_megabyte(h);
    if (!NT_SUCCESS(Status))
        return Status;

    Status = write_superblocks(h, &dev, chunk_root, root_root, extent_root, sys_chunk, node_size, &fsuuid, sector_size, label, incompat_flags);
    if (!NT_SUCCESS(Status))
        return Status;

    free_roots(&roots);
    free_chunks(&chunks);

    return STATUS_SUCCESS;
}

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 615 of file btrfslib.c.

                                                                                               {
    NTSTATUS Status;
    uint16_t i;
    IO_STATUS_BLOCK iosb;
    LARGE_INTEGER off;
    CHUNK_ITEM_STRIPE* cis;

    cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];

    for (i = 0; i < c->chunk_item->num_stripes; i++) {
        off.QuadPart = cis[i].offset + address - c->offset;

        Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, data, size, &off, NULL);
        if (!NT_SUCCESS(Status))
            return Status;
    }

    return STATUS_SUCCESS;
}

Referenced by write_roots().

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 635 of file btrfslib.c.

                                                                                                                        {
    LIST_ENTRY *le, *le2;
    NTSTATUS Status;
    uint8_t* tree;

#ifndef __REACTOS__
    tree = malloc(node_size);
#else
    tree = RtlAllocateHeap(RtlGetProcessHeap(), 0, node_size);
#endif

    le = roots->Flink;
    while (le != roots) {
        btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry);
        uint8_t* dp;
        leaf_node* ln;
        uint32_t crc32;

        memset(tree, 0, node_size);

        r->header.num_items = 0;
        r->header.fs_uuid = *fsuuid;
        r->header.flags = HEADER_FLAG_MIXED_BACKREF | HEADER_FLAG_WRITTEN;
        r->header.chunk_tree_uuid = *chunkuuid;
        r->header.generation = 1;
        r->header.tree_id = r->id;

        ln = (leaf_node*)(tree + sizeof(tree_header));

        dp = tree + node_size;

        le2 = r->items.Flink;
        while (le2 != &r->items) {
            btrfs_item* item = CONTAINING_RECORD(le2, btrfs_item, list_entry);

            ln->key = item->key;
            ln->size = item->size;

            if (item->size > 0) {
                dp -= item->size;
                memcpy(dp, item->data, item->size);

                ln->offset = dp - tree - sizeof(tree_header);
            } else
                ln->offset = 0;

            ln = &ln[1];

            r->header.num_items++;

            le2 = le2->Flink;
        }

        memcpy(tree, &r->header, sizeof(tree_header));

        crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&((tree_header*)tree)->fs_uuid, node_size - sizeof(((tree_header*)tree)->csum));
        memcpy(tree, &crc32, sizeof(uint32_t));

        Status = write_data(h, r->header.address, r->c, tree, node_size);
        if (!NT_SUCCESS(Status)) {
#ifndef __REACTOS__
            free(tree);
#else
            RtlFreeHeap(RtlGetProcessHeap(), 0, tree);
#endif
            return Status;
        }

        le = le->Flink;
    }

#ifndef __REACTOS__
    free(tree);
#else
    RtlFreeHeap(RtlGetProcessHeap(), 0, tree);
#endif

    return STATUS_SUCCESS;
}

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 761 of file btrfslib.c.

                                                                                                                                                                        {
    NTSTATUS Status;
    IO_STATUS_BLOCK iosb;
    ULONG sblen;
    int i;
    uint32_t crc32;
    superblock* sb;
    KEY* key;
    uint64_t bytes_used;
    LIST_ENTRY* le;

    sblen = sizeof(*sb);
    if (sblen & (sector_size - 1))
        sblen = (sblen & sector_size) + sector_size;

    bytes_used = 0;

    le = extent_root->items.Flink;
    while (le != &extent_root->items) {
        btrfs_item* item = CONTAINING_RECORD(le, btrfs_item, list_entry);

        if (item->key.obj_type == TYPE_EXTENT_ITEM)
            bytes_used += item->key.offset;
        else if (item->key.obj_type == TYPE_METADATA_ITEM)
            bytes_used += node_size;

        le = le->Flink;
    }

#ifndef __REACTOS__
    sb = malloc(sblen);
    memset(sb, 0, sblen);
#else
    sb = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sblen);
#endif

    sb->uuid = *fsuuid;
    sb->flags = 1;
    sb->magic = BTRFS_MAGIC;
    sb->generation = 1;
    sb->root_tree_addr = root_root->header.address;
    sb->chunk_tree_addr = chunk_root->header.address;
    sb->total_bytes = dev->dev_item.num_bytes;
    sb->bytes_used = bytes_used;
    sb->root_dir_objectid = 6;
    sb->num_devices = 1;
    sb->sector_size = sector_size;
    sb->node_size = node_size;
    sb->leaf_size = node_size;
    sb->stripe_size = sector_size;
    sb->n = sizeof(KEY) + sizeof(CHUNK_ITEM) + (sys_chunk->chunk_item->num_stripes * sizeof(CHUNK_ITEM_STRIPE));
    sb->chunk_root_generation = 1;
    sb->incompat_flags = incompat_flags;
    memcpy(&sb->dev_item, &dev->dev_item, sizeof(DEV_ITEM));

    if (label->Length > 0) {
#ifdef __REACTOS__
        ANSI_STRING as;
        unsigned int i;

        for (i = 0; i < label->Length / sizeof(WCHAR); i++) {
#else
        ULONG utf8len;

        for (unsigned int i = 0; i < label->Length / sizeof(WCHAR); i++) {
#endif
            if (label->Buffer[i] == '/' || label->Buffer[i] == '\\') {
#ifndef __REACTOS__
                free(sb);
#else
                RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif
                return STATUS_INVALID_VOLUME_LABEL;
            }
        }

#ifndef __REACTOS__
        utf8len = WideCharToMultiByte(CP_UTF8, 0, label->Buffer, label->Length, NULL, 0, NULL, NULL);

        if (utf8len == 0 || utf8len > MAX_LABEL_SIZE) {
            free(sb);
            return STATUS_INVALID_VOLUME_LABEL;
        }

        if (WideCharToMultiByte(CP_UTF8, 0, label->Buffer, label->Length, sb->label, utf8len, NULL, NULL) == 0) {
            free(sb);
            return STATUS_INVALID_VOLUME_LABEL;
        }
#else
        as.Buffer = sb->label;
        as.Length = 0;
        as.MaximumLength = MAX_LABEL_SIZE;

        if (!NT_SUCCESS(RtlUnicodeStringToAnsiString(&as, label, FALSE)))
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
            return STATUS_INVALID_VOLUME_LABEL;
        }
#endif
    }
    sb->cache_generation = 0xffffffffffffffff;

    key = (KEY*)sb->sys_chunk_array;
    key->obj_id = 0x100;
    key->obj_type = TYPE_CHUNK_ITEM;
    key->offset = sys_chunk->offset;
    memcpy(&key[1], sys_chunk->chunk_item, sizeof(CHUNK_ITEM) + (sys_chunk->chunk_item->num_stripes * sizeof(CHUNK_ITEM_STRIPE)));

    i = 0;
    while (superblock_addrs[i] != 0) {
        LARGE_INTEGER off;

        if (superblock_addrs[i] > dev->dev_item.num_bytes)
            break;

        sb->sb_phys_addr = superblock_addrs[i];

        crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
        memcpy(&sb->checksum, &crc32, sizeof(uint32_t));

        off.QuadPart = superblock_addrs[i];

        Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, sb, sblen, &off, NULL);
        if (!NT_SUCCESS(Status)) {
#ifndef __REACTOS__
            free(sb);
#else
            RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif
            return Status;
        }

        i++;
    }

#ifndef __REACTOS__
    free(sb);
#else
    RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
#endif

    return STATUS_SUCCESS;
}

Referenced by write_btrfs().

Variable Documentation

crctable

const uint32_t crctable[]

static

Definition at line 214 of file btrfslib.c.

Referenced by calc_crc32c().

def_incompat_flags

uint64_t def_incompat_flags = BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA

Definition at line 156 of file btrfslib.c.

Referenced by FormatEx2(), and SetIncompatFlags().

def_node_size

ULONG def_node_size = 0

Definition at line 155 of file btrfslib.c.

Referenced by FormatEx2(), and SetSizes().

def_sector_size

ULONG def_sector_size = 0

Definition at line 155 of file btrfslib.c.

Referenced by FormatEx2(), and SetSizes().

module

HMODULE module

Definition at line 154 of file btrfslib.c.