block.c

一个Windows下的Linux专用虚拟机

/*
 * This source code is a part of coLinux source package.
 *
 * Dan Aloni <[e-mail]>, 2003 (c)
 *
 * The code is licensed under the GPL. See the COPYING file at
 * the root directory.
 *
 */ 

#include "ddk.h"

#include <ddk/ntdddisk.h>

#include <colinux/os/alloc.h>
#include <colinux/kernel/transfer.h>
#include <colinux/kernel/fileblock.h>
#include <colinux/kernel/monitor.h>

#include "fileio.h"

static co_rc_t co_os_file_block_read(co_monitor_t *linuxvm, co_block_dev_t *dev, 
			      co_monitor_file_block_dev_t *fdev, co_block_request_t *request)
{
	return co_os_file_block_read_write(linuxvm, (HANDLE)(fdev->sysdep),
					   request->offset, request->address,
					   request->size, PTRUE);
}


static co_rc_t co_os_file_block_write(co_monitor_t *linuxvm, co_block_dev_t *dev, 
			       co_monitor_file_block_dev_t *fdev, co_block_request_t *request)
{
	return co_os_file_block_read_write(linuxvm, (HANDLE)(fdev->sysdep),
					   request->offset, request->address,
					   request->size, PFALSE);
}

static bool_t probe_area(HANDLE handle, LARGE_INTEGER offset, char *test_buffer, unsigned long size)
{
	IO_STATUS_BLOCK isb;
	NTSTATUS status;

	status = ZwReadFile(handle, NULL, NULL,
			    NULL, &isb, test_buffer, size,
			    &offset, NULL);

	if (status != STATUS_SUCCESS)
		return PFALSE;

	return PTRUE;
}

static co_rc_t co_os_file_block_detect_size_binary_search(HANDLE handle, unsigned long long *out_size)
{
	/* 
	 * Binary search the size of the device.
	 *
	 * Yep, it's ugly.
	 *
	 * I haven't found a more reliable way. I thought about switching between
	 * IOCTL_DISK_GET_DRIVE_GEOMETRY, IOCTL_DISK_GET_PARTITION_INFORMATION, 
	 * and even IOCTL_CDROM_GET_DRIVE_GEOMETRY depending on the device's type, 
	 * but I'm not sure if would work in all cases.
	 *
	 * This *would* work in all cases.
	 */

	LARGE_INTEGER scan_bit;
	LARGE_INTEGER build_size;
	unsigned long test_buffer_size_max = 0x4000;
	unsigned long test_buffer_size = 0x100;
	char *test_buffer;

	test_buffer = co_os_malloc(test_buffer_size_max);
	if (!test_buffer)
		return CO_RC(OUT_OF_MEMORY);

	build_size.QuadPart = 0;

	while (test_buffer_size <= test_buffer_size_max) {
		if (probe_area(handle, build_size, test_buffer, test_buffer_size))
			break;

		test_buffer_size <<= 1;
	}

	if (test_buffer_size >= test_buffer_size_max) {
		co_debug_error("size is zero");
		*out_size = 0;
		co_os_free(test_buffer);
		return CO_RC(ERROR);
	}

	scan_bit.QuadPart = 1;

	/* 
	 * Find the smallest invalid power of 2.
	 */
	while (scan_bit.QuadPart != 0) {
		if (!probe_area(handle, scan_bit, test_buffer, test_buffer_size))
			break;
		scan_bit.QuadPart <<= 1;
	}

	if (scan_bit.QuadPart == 0)
		return CO_RC(ERROR);

	while (scan_bit.QuadPart) {
		LARGE_INTEGER with_bit;

		scan_bit.QuadPart >>= 1;
		with_bit.QuadPart = build_size.QuadPart | scan_bit.QuadPart;
		if (probe_area(handle, with_bit, test_buffer, test_buffer_size))
			build_size = with_bit;
	}

	build_size.QuadPart += test_buffer_size;

	*out_size = build_size.QuadPart;

	co_os_free(test_buffer);
	return CO_RC(OK);
}

static co_rc_t co_os_file_block_detect_size_harddisk(HANDLE handle, unsigned long long *out_size)
{
	GET_LENGTH_INFORMATION length;
	IO_STATUS_BLOCK block;
	NTSTATUS status;

	length.Length.QuadPart = 0;

	status = ZwDeviceIoControlFile(handle, NULL, NULL, NULL, &block,
				       IOCTL_DISK_GET_LENGTH_INFO,
				       NULL, 0, &length, sizeof(length));

	if (status == STATUS_SUCCESS) {
		co_debug("IOCTL_DISK_GET_LENGTH_INFO returned success");
		*out_size = length.Length.QuadPart;
		return CO_RC(OK);
	}

	return CO_RC(ERROR);
}

static co_rc_t co_os_file_block_detect_size(HANDLE handle, unsigned long long *out_size)
{
	co_rc_t rc;

	rc = co_os_file_block_detect_size_harddisk(handle, out_size);
	if (CO_OK(rc))
		return rc;

	/*
	 * Fall back to binary search.
	 */ 
	rc = co_os_file_block_detect_size_binary_search(handle, out_size);
	if (CO_OK(rc))
		return rc;

	*out_size = 0;
	return CO_RC(ERROR);
}

co_rc_t co_os_file_block_get_size(co_monitor_file_block_dev_t *fdev, unsigned long long *size)
{
	NTSTATUS status;
	HANDLE FileHandle;
	IO_STATUS_BLOCK IoStatusBlock;
	FILE_STANDARD_INFORMATION fsi;
	co_rc_t rc;
	bool_t opened = PFALSE;

	co_debug("device %s", fdev->pathname);

	if (fdev->sysdep == NULL) {
		rc = co_os_file_open(fdev->pathname, &FileHandle, FILE_READ_DATA);
		if (!CO_OK(rc))
			return rc;

		opened = TRUE;
	}
	else {
		FileHandle = (HANDLE)(fdev->sysdep);
	}

	status = ZwQueryInformationFile(FileHandle,
					&IoStatusBlock,
					&fsi,
					sizeof(fsi),
					FileStandardInformation);

	if (status == STATUS_SUCCESS) {
		*size = fsi.EndOfFile.QuadPart;
		co_debug("reported size: %llu KBs", (*size >> 10));
		rc = CO_RC(OK);
	}
	else {
		rc = co_os_file_block_detect_size(FileHandle, size);
		if (CO_OK(rc)) {
			co_debug("detected size: %llu KBs", (*size >> 10));
		}
	}
	
	if (opened)
		co_os_file_close(FileHandle);

	return rc;
}

co_rc_t co_os_file_block_open(co_monitor_t *linuxvm, co_monitor_file_block_dev_t *fdev)
{
	HANDLE FileHandle;
	co_rc_t rc;

	rc = co_os_file_open(fdev->pathname, &FileHandle, FILE_READ_DATA | FILE_WRITE_DATA);
	if (!CO_OK(rc))
		return rc;

	fdev->sysdep = (struct co_os_file_block_sysdep *)(FileHandle);
	return CO_RC(OK);
}

co_rc_t co_os_file_block_close(co_monitor_file_block_dev_t *fdev)
{
	HANDLE FileHandle;

	FileHandle = (HANDLE)(fdev->sysdep);

	co_os_file_close(FileHandle);

	fdev->sysdep = NULL;

	return CO_RC(OK);
}

co_monitor_file_block_operations_t co_os_file_block_default_operations = {
	.open = co_os_file_block_open,
	.close = co_os_file_block_close,
	.read = co_os_file_block_read,
	.write = co_os_file_block_write,
	.get_size = co_os_file_block_get_size,
};