boot.c File Reference

#include "btrfs_drv.h"

Include dependency graph for boot.c:

Go to the source code of this file.

Classes
struct	DEVOBJ_EXTENSION2
struct	system_root

Macros
#define	DOE_START_PENDING   0x10

Enumerations
enum	system_root_type { system_root_unknown, system_root_partition, system_root_btrfs }

Functions
NTSTATUS	RtlUnicodeStringPrintf (PUNICODE_STRING DestinationString, const WCHAR *pszFormat,...)
static void	get_system_root (system_root *sr)
static void	change_symlink (uint32_t disk_num, uint32_t partition_num, BTRFS_UUID *uuid)
static void	mountmgr_notification (BTRFS_UUID *uuid)
static void	check_boot_options ()
void	boot_add_device (DEVICE_OBJECT *pdo)
void __stdcall	check_system_root (PDRIVER_OBJECT DriverObject, PVOID Context, ULONG Count)

Variables
ERESOURCE	pdo_list_lock
LIST_ENTRY	pdo_list
ERESOURCE	boot_lock
PDRIVER_OBJECT	drvobj
BTRFS_UUID	boot_uuid
uint64_t	boot_subvol = 0

Macro Definition Documentation

DOE_START_PENDING

#define DOE_START_PENDING   0x10

Definition at line 41 of file boot.c.

Enumeration Type Documentation

system_root_type

enum system_root_type

Enumerator
system_root_unknown
system_root_partition
system_root_btrfs

Definition at line 53 of file boot.c.

             {
    system_root_unknown,
    system_root_partition,
    system_root_btrfs
} system_root_type;

Function Documentation

boot_add_device()

void boot_add_device

(

DEVICE_OBJECT *

pdo

)

Definition at line 442 of file boot.c.

                                         {
    pdo_device_extension* pdode = pdo->DeviceExtension;

    AddDevice(drvobj, pdo);

    // To stop Windows sneakily setting DOE_START_PENDING
    pdode->dont_report = true;

    if (pdo->DeviceObjectExtension) {
        ((DEVOBJ_EXTENSION2*)pdo->DeviceObjectExtension)->ExtensionFlags &= ~DOE_START_PENDING;

        if (pdode && pdode->vde && pdode->vde->device)
            ((DEVOBJ_EXTENSION2*)pdode->vde->device->DeviceObjectExtension)->ExtensionFlags &= ~DOE_START_PENDING;
    }

    mountmgr_notification(&pdode->uuid);
}

Referenced by add_volume_device(), and check_system_root().

change_symlink()

static void change_symlink ( uint32_t  disk_num, uint32_t  partition_num, BTRFS_UUID *  uuid  )

static

Definition at line 247 of file boot.c.

                                                                                        {
    NTSTATUS Status;
    UNICODE_STRING us, us2;
    WCHAR symlink[60], target[(sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) + 36], *w;
#ifdef __REACTOS__
    unsigned int i;
#endif

    us.Buffer = symlink;
    us.Length = 0;
    us.MaximumLength = sizeof(symlink);

    Status = RtlUnicodeStringPrintf(&us, L"\\Device\\Harddisk%u\\Partition%u", disk_num, partition_num);
    if (!NT_SUCCESS(Status)) {
        ERR("RtlUnicodeStringPrintf returned %08lx\n", Status);
        return;
    }

    Status = IoDeleteSymbolicLink(&us);
    if (!NT_SUCCESS(Status))
        ERR("IoDeleteSymbolicLink returned %08lx\n", Status);

    RtlCopyMemory(target, BTRFS_VOLUME_PREFIX, sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR));

    w = &target[(sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) - 1];

#ifndef __REACTOS__
    for (unsigned int i = 0; i < 16; i++) {
#else
    for (i = 0; i < 16; i++) {
#endif
        *w = hex_digit(uuid->uuid[i] >> 4); w++;
        *w = hex_digit(uuid->uuid[i] & 0xf); w++;

        if (i == 3 || i == 5 || i == 7 || i == 9) {
            *w = L'-';
            w++;
        }
    }

    *w = L'}';

    us2.Buffer = target;
    us2.Length = us2.MaximumLength = sizeof(target);

    Status = IoCreateSymbolicLink(&us, &us2);
    if (!NT_SUCCESS(Status))
        ERR("IoCreateSymbolicLink returned %08lx\n", Status);
}

Referenced by check_system_root().

check_boot_options()

static void check_boot_options ( )

static

Definition at line 356 of file boot.c.

                                 {
    NTSTATUS Status;
    WCHAR* s;

    static const WCHAR pathw[] = L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control";
    static const WCHAR namew[] = L"SystemStartOptions";
    static const WCHAR subvol[] = L"SUBVOL=";

    _SEH2_TRY {
        HANDLE control;
        OBJECT_ATTRIBUTES oa;
        UNICODE_STRING path;
        ULONG kvfilen = sizeof(KEY_VALUE_FULL_INFORMATION) - sizeof(WCHAR) + (255 * sizeof(WCHAR));
        KEY_VALUE_FULL_INFORMATION* kvfi;
        UNICODE_STRING name;
        WCHAR* options;

        path.Buffer = (WCHAR*)pathw;
        path.Length = path.MaximumLength = sizeof(pathw) - sizeof(WCHAR);

        InitializeObjectAttributes(&oa, &path, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

        Status = ZwOpenKey(&control, KEY_QUERY_VALUE, &oa);
        if (!NT_SUCCESS(Status)) {
            ERR("ZwOpenKey returned %08lx\n", Status);
            return;
        }

        // FIXME - don't fail if value too long (can we query for the length?)

        kvfi = ExAllocatePoolWithTag(PagedPool, kvfilen, ALLOC_TAG);
        if (!kvfi) {
            ERR("out of memory\n");
            NtClose(control);
            return;
        }

        name.Buffer = (WCHAR*)namew;
        name.Length = name.MaximumLength = sizeof(namew) - sizeof(WCHAR);

        Status = ZwQueryValueKey(control, &name, KeyValueFullInformation, kvfi,
                                 kvfilen, &kvfilen);
        if (!NT_SUCCESS(Status)) {
            ERR("ZwQueryValueKey returned %08lx\n", Status);
            NtClose(control);
            return;
        }

        NtClose(control);

        options = (WCHAR*)((uint8_t*)kvfi + kvfi->DataOffset);
        options[kvfi->DataLength / sizeof(WCHAR)] = 0; // FIXME - make sure buffer long enough to allow this

        s = wcsstr(options, subvol);

        if (!s)
            return;

        s += (sizeof(subvol) / sizeof(WCHAR)) - 1;

        boot_subvol = 0;

        while (true) {
            if (*s >= '0' && *s <= '9') {
                boot_subvol <<= 4;
                boot_subvol |= *s - '0';
            } else if (*s >= 'a' && *s <= 'f') {
                boot_subvol <<= 4;
                boot_subvol |= *s - 'a' + 0xa;
            } else if (*s >= 'A' && *s <= 'F') {
                boot_subvol <<= 4;
                boot_subvol |= *s - 'A' + 0xa;
            } else
                break;

            s++;
        }
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        return;
    } _SEH2_END;

    if (boot_subvol != 0) {
        TRACE("passed subvol %I64x in boot options\n", boot_subvol);
    }
}

Referenced by check_system_root().

check_system_root()

void __stdcall check_system_root	(	PDRIVER_OBJECT	DriverObject,
		PVOID	Context,
		ULONG	Count
	)

Definition at line 470 of file boot.c.

                                                                                          {
    system_root sr;
    LIST_ENTRY* le;
    bool done = false;
    PDEVICE_OBJECT pdo_to_add = NULL;
    volume_child* boot_vc = NULL;

    TRACE("(%p, %p, %lu)\n", DriverObject, Context, Count);

    // wait for any PNP notifications in progress to finish
    ExAcquireResourceExclusiveLite(&boot_lock, TRUE);
    ExReleaseResourceLite(&boot_lock);

    get_system_root(&sr);

    if (sr.type == system_root_partition) {
        TRACE("system boot partition is disk %u, partition %u\n", sr.disk_num, sr.partition_num);

        ExAcquireResourceSharedLite(&pdo_list_lock, true);

        le = pdo_list.Flink;
        while (le != &pdo_list) {
            LIST_ENTRY* le2;
            pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);

            ExAcquireResourceSharedLite(&pdode->child_lock, true);

            le2 = pdode->children.Flink;

            while (le2 != &pdode->children) {
                volume_child* vc = CONTAINING_RECORD(le2, volume_child, list_entry);

                if (vc->disk_num == sr.disk_num && vc->part_num == sr.partition_num) {
                    change_symlink(sr.disk_num, sr.partition_num, &pdode->uuid);
                    done = true;

                    vc->boot_volume = true;
                    boot_uuid = pdode->uuid;

                    if (!pdode->vde)
                        pdo_to_add = pdode->pdo;

                    boot_vc = vc;

                    break;
                }

                le2 = le2->Flink;
            }

            if (done) {
                le2 = pdode->children.Flink;

                while (le2 != &pdode->children) {
                    volume_child* vc = CONTAINING_RECORD(le2, volume_child, list_entry);

                    /* On Windows 7 we need to clear the DO_SYSTEM_BOOT_PARTITION flag of
                    * all of our underlying partition objects - otherwise IopMountVolume
                    * will bugcheck with UNMOUNTABLE_BOOT_VOLUME when it tries and fails
                    * to mount one. */
                    if (vc->devobj) {
                        PDEVICE_OBJECT dev = vc->devobj;

                        ObReferenceObject(dev);

                        while (dev) {
                            PDEVICE_OBJECT dev2 = IoGetLowerDeviceObject(dev);

                            dev->Flags &= ~DO_SYSTEM_BOOT_PARTITION;

                            ObDereferenceObject(dev);

                            dev = dev2;
                        }
                    }

                    le2 = le2->Flink;
                }

                ExReleaseResourceLite(&pdode->child_lock);

                break;
            }

            ExReleaseResourceLite(&pdode->child_lock);

            le = le->Flink;
        }

        ExReleaseResourceLite(&pdo_list_lock);
    } else if (sr.type == system_root_btrfs) {
        boot_uuid = sr.uuid;

        ExAcquireResourceSharedLite(&pdo_list_lock, true);

        le = pdo_list.Flink;
        while (le != &pdo_list) {
            pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);

            if (RtlCompareMemory(&pdode->uuid, &sr.uuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
                if (!pdode->vde)
                    pdo_to_add = pdode->pdo;

                break;
            }

            le = le->Flink;
        }

        ExReleaseResourceLite(&pdo_list_lock);
    }

    if (boot_vc) {
        NTSTATUS Status;
        UNICODE_STRING name;

        /* On Windows 8, mountmgr!MountMgrFindBootVolume returns the first volume in its database
         * with the DO_SYSTEM_BOOT_PARTITION flag set. We've cleared the bit on the underlying devices,
         * but as it caches it we need to disable and re-enable the volume so mountmgr receives a PNP
         * notification to refresh its list. */

        static const WCHAR prefix[] = L"\\??";

        name.Length = name.MaximumLength = boot_vc->pnp_name.Length + sizeof(prefix) - sizeof(WCHAR);

        name.Buffer = ExAllocatePoolWithTag(PagedPool, name.MaximumLength, ALLOC_TAG);
        if (!name.Buffer)
            ERR("out of memory\n");
        else {
            RtlCopyMemory(name.Buffer, prefix, sizeof(prefix) - sizeof(WCHAR));
            RtlCopyMemory(&name.Buffer[(sizeof(prefix) / sizeof(WCHAR)) - 1], boot_vc->pnp_name.Buffer, boot_vc->pnp_name.Length);

            Status = IoSetDeviceInterfaceState(&name, false);
            if (!NT_SUCCESS(Status))
                ERR("IoSetDeviceInterfaceState returned %08lx\n", Status);

            Status = IoSetDeviceInterfaceState(&name, true);
            if (!NT_SUCCESS(Status))
                ERR("IoSetDeviceInterfaceState returned %08lx\n", Status);

            ExFreePool(name.Buffer);
        }
    }

    if (sr.type == system_root_btrfs || boot_vc)
        check_boot_options();

    // If our FS depends on volumes that aren't there when we do our IoRegisterPlugPlayNotification calls
    // in DriverEntry, bus_query_device_relations won't get called until it's too late. We need to do our
    // own call to AddDevice here as a result. We need to clear the DOE_START_PENDING bits, or NtOpenFile
    // will return STATUS_NO_SUCH_DEVICE.
    if (pdo_to_add)
        boot_add_device(pdo_to_add);
}

Referenced by _Function_class_().

get_system_root()

static void get_system_root ( system_root *  sr )

static

Definition at line 66 of file boot.c.

                                             {
    NTSTATUS Status;
    HANDLE h;
    UNICODE_STRING us, target;
    OBJECT_ATTRIBUTES objatt;
    ULONG retlen = 0;
    bool second_time = false;

    static const WCHAR system_root[] = L"\\SystemRoot";
    static const WCHAR boot_device[] = L"\\Device\\BootDevice";
    static const WCHAR arc_prefix[] = L"\\ArcName\\multi(0)disk(0)rdisk(";
    static const WCHAR arc_middle[] = L")partition(";
    static const WCHAR arc_btrfs_prefix[] = L"\\ArcName\\btrfs(";

    us.Buffer = (WCHAR*)system_root;
    us.Length = us.MaximumLength = sizeof(system_root) - sizeof(WCHAR);

    InitializeObjectAttributes(&objatt, &us, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

    while (true) {
        Status = ZwOpenSymbolicLinkObject(&h, GENERIC_READ, &objatt);
        if (!NT_SUCCESS(Status)) {
            ERR("ZwOpenSymbolicLinkObject returned %08lx\n", Status);
            return;
        }

        target.Length = target.MaximumLength = 0;

        Status = ZwQuerySymbolicLinkObject(h, &target, &retlen);
        if (Status != STATUS_BUFFER_TOO_SMALL) {
            ERR("ZwQuerySymbolicLinkObject returned %08lx\n", Status);
            NtClose(h);
            return;
        }

        if (retlen == 0) {
            NtClose(h);
            return;
        }

        target.Buffer = ExAllocatePoolWithTag(NonPagedPool, retlen, ALLOC_TAG);
        if (!target.Buffer) {
            ERR("out of memory\n");
            NtClose(h);
            return;
        }

        target.Length = target.MaximumLength = (USHORT)retlen;

        Status = ZwQuerySymbolicLinkObject(h, &target, NULL);
        if (!NT_SUCCESS(Status)) {
            ERR("ZwQuerySymbolicLinkObject returned %08lx\n", Status);
            NtClose(h);
            ExFreePool(target.Buffer);
            return;
        }

        NtClose(h);

        if (second_time) {
            TRACE("boot device is %.*S\n", (int)(target.Length / sizeof(WCHAR)), target.Buffer);
        } else {
            TRACE("system root is %.*S\n", (int)(target.Length / sizeof(WCHAR)), target.Buffer);
        }

        if (!second_time && target.Length >= sizeof(boot_device) - sizeof(WCHAR) &&
            RtlCompareMemory(target.Buffer, boot_device, sizeof(boot_device) - sizeof(WCHAR)) == sizeof(boot_device) - sizeof(WCHAR)) {
            ExFreePool(target.Buffer);

            us.Buffer = (WCHAR*)boot_device;
            us.Length = us.MaximumLength = sizeof(boot_device) - sizeof(WCHAR);

            second_time = true;
        } else
            break;
    }

    sr->type = system_root_unknown;

    if (target.Length >= sizeof(arc_prefix) - sizeof(WCHAR) &&
        RtlCompareMemory(target.Buffer, arc_prefix, sizeof(arc_prefix) - sizeof(WCHAR)) == sizeof(arc_prefix) - sizeof(WCHAR)) {
        WCHAR* s = &target.Buffer[(sizeof(arc_prefix) / sizeof(WCHAR)) - 1];
        ULONG left = ((target.Length - sizeof(arc_prefix)) / sizeof(WCHAR)) + 1;

        if (left == 0 || s[0] < '0' || s[0] > '9') {
            ExFreePool(target.Buffer);
            return;
        }

        sr->disk_num = 0;

        while (left > 0 && s[0] >= '0' && s[0] <= '9') {
            sr->disk_num *= 10;
            sr->disk_num += s[0] - '0';
            s++;
            left--;
        }

        if (left <= (sizeof(arc_middle) / sizeof(WCHAR)) - 1 ||
            RtlCompareMemory(s, arc_middle, sizeof(arc_middle) - sizeof(WCHAR)) != sizeof(arc_middle) - sizeof(WCHAR)) {
            ExFreePool(target.Buffer);
            return;
        }

        s = &s[(sizeof(arc_middle) / sizeof(WCHAR)) - 1];
        left -= (sizeof(arc_middle) / sizeof(WCHAR)) - 1;

        if (left == 0 || s[0] < '0' || s[0] > '9') {
            ExFreePool(target.Buffer);
            return;
        }

        sr->partition_num = 0;

        while (left > 0 && s[0] >= '0' && s[0] <= '9') {
            sr->partition_num *= 10;
            sr->partition_num += s[0] - '0';
            s++;
            left--;
        }

        sr->type = system_root_partition;
    } else if (target.Length >= sizeof(arc_btrfs_prefix) - sizeof(WCHAR) &&
        RtlCompareMemory(target.Buffer, arc_btrfs_prefix, sizeof(arc_btrfs_prefix) - sizeof(WCHAR)) == sizeof(arc_btrfs_prefix) - sizeof(WCHAR)) {
        WCHAR* s = &target.Buffer[(sizeof(arc_btrfs_prefix) / sizeof(WCHAR)) - 1];
#ifdef __REACTOS__
        unsigned int i;
#endif // __REACTOS__

#ifndef __REACTOS__
        for (unsigned int i = 0; i < 16; i++) {
#else
        for (i = 0; i < 16; i++) {
#endif // __REACTOS__
            if (*s >= '0' && *s <= '9')
                sr->uuid.uuid[i] = (*s - '0') << 4;
            else if (*s >= 'a' && *s <= 'f')
                sr->uuid.uuid[i] = (*s - 'a' + 0xa) << 4;
            else if (*s >= 'A' && *s <= 'F')
                sr->uuid.uuid[i] = (*s - 'A' + 0xa) << 4;
            else {
                ExFreePool(target.Buffer);
                return;
            }

            s++;

            if (*s >= '0' && *s <= '9')
                sr->uuid.uuid[i] |= *s - '0';
            else if (*s >= 'a' && *s <= 'f')
                sr->uuid.uuid[i] |= *s - 'a' + 0xa;
            else if (*s >= 'A' && *s <= 'F')
                sr->uuid.uuid[i] |= *s - 'A' + 0xa;
            else {
                ExFreePool(target.Buffer);
                return;
            }

            s++;

            if (i == 3 || i == 5 || i == 7 || i == 9) {
                if (*s != '-') {
                    ExFreePool(target.Buffer);
                    return;
                }

                s++;
            }
        }

        if (*s != ')') {
            ExFreePool(target.Buffer);
            return;
        }

        sr->type = system_root_btrfs;
    }

    ExFreePool(target.Buffer);
}

Referenced by check_system_root().

mountmgr_notification()

static void mountmgr_notification ( BTRFS_UUID *  uuid )

static

Definition at line 297 of file boot.c.

                                                    {
    UNICODE_STRING mmdevpath;
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT mountmgr;
    ULONG mmtnlen;
    MOUNTMGR_TARGET_NAME* mmtn;
    WCHAR* w;
#ifdef __REACTOS__
    unsigned int i;
#endif

    RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
    Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &FileObject, &mountmgr);
    if (!NT_SUCCESS(Status)) {
        ERR("IoGetDeviceObjectPointer returned %08lx\n", Status);
        return;
    }

    mmtnlen = offsetof(MOUNTMGR_TARGET_NAME, DeviceName[0]) + sizeof(BTRFS_VOLUME_PREFIX) + (36 * sizeof(WCHAR));

    mmtn = ExAllocatePoolWithTag(NonPagedPool, mmtnlen, ALLOC_TAG);
    if (!mmtn) {
        ERR("out of memory\n");
        return;
    }

    mmtn->DeviceNameLength = sizeof(BTRFS_VOLUME_PREFIX) + (36 * sizeof(WCHAR));

    RtlCopyMemory(mmtn->DeviceName, BTRFS_VOLUME_PREFIX, sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR));

    w = &mmtn->DeviceName[(sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) - 1];

#ifndef __REACTOS__
    for (unsigned int i = 0; i < 16; i++) {
#else
    for (i = 0; i < 16; i++) {
#endif
        *w = hex_digit(uuid->uuid[i] >> 4); w++;
        *w = hex_digit(uuid->uuid[i] & 0xf); w++;

        if (i == 3 || i == 5 || i == 7 || i == 9) {
            *w = L'-';
            w++;
        }
    }

    *w = L'}';

    Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION, mmtn, mmtnlen, NULL, 0, false, NULL);
    if (!NT_SUCCESS(Status)) {
        ERR("IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION returned %08lx\n", Status);
        ExFreePool(mmtn);
        return;
    }

    ExFreePool(mmtn);
}

Referenced by boot_add_device().

RtlUnicodeStringPrintf()

NTSTATUS RtlUnicodeStringPrintf	(	PUNICODE_STRING	DestinationString,
		const WCHAR *	pszFormat,
			...
	)

Referenced by change_symlink(), FxLibraryCreateDevice(), and Test_RtlUnicodeStringPrintf().

Variable Documentation

boot_lock

ERESOURCE boot_lock

Definition at line 115 of file btrfs.c.

Referenced by check_system_root().

boot_subvol

uint64_t boot_subvol = 0

Definition at line 34 of file boot.c.

Referenced by check_boot_options(), and mount_vol().

boot_uuid

BTRFS_UUID boot_uuid

Definition at line 33 of file boot.c.

Referenced by _Function_class_(), add_volume_device(), check_system_root(), and mount_vol().

drvobj

PDRIVER_OBJECT drvobj

Definition at line 68 of file btrfs.c.

Referenced by boot_add_device().

pdo_list

LIST_ENTRY pdo_list

Definition at line 109 of file btrfs.c.

Referenced by check_system_root().

pdo_list_lock

ERESOURCE pdo_list_lock

Definition at line 108 of file btrfs.c.

Referenced by check_system_root().