haiku.git

/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "checksum_device.h"

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <algorithm>

#include <device_manager.h>

#include <AutoDeleter.h>
#include <util/AutoLock.h>
#include <util/DoublyLinkedList.h>

#include <fs/KPath.h>
#include <lock.h>
#include <vm/vm.h>

#include "dma_resources.h"
#include "io_requests.h"
#include "IOSchedulerSimple.h"

#include "CheckSum.h"


//#define TRACE_CHECK_SUM_DEVICE
#ifdef TRACE_CHECK_SUM_DEVICE
#	define TRACE(x...)	dprintf(x)
#else
#	define TRACE(x) do {} while (false)
#endif


// parameters for the DMA resource
static const uint32 kDMAResourceBufferCount			= 16;
static const uint32 kDMAResourceBounceBufferCount	= 16;

static const size_t kCheckSumLength = sizeof(CheckSum);
static const uint32 kCheckSumsPerBlock = B_PAGE_SIZE / sizeof(CheckSum);

static const char* const kDriverModuleName
	= "drivers/disk/virtual/checksum_device/driver_v1";
static const char* const kControlDeviceModuleName
	= "drivers/disk/virtual/checksum_device/control/device_v1";
static const char* const kRawDeviceModuleName
	= "drivers/disk/virtual/checksum_device/raw/device_v1";

static const char* const kControlDeviceName
	= "disk/virtual/checksum_device/control";
static const char* const kRawDeviceBaseName = "disk/virtual/checksum_device";

static const char* const kFilePathItem = "checksum_device/file_path";


struct RawDevice;
typedef DoublyLinkedList<RawDevice> RawDeviceList;

struct device_manager_info* sDeviceManager;

static RawDeviceList sDeviceList;
static mutex sDeviceListLock = MUTEX_INITIALIZER("checksum device list");


struct CheckSumBlock : public DoublyLinkedListLinkImpl<CheckSumBlock> {
	uint64		blockIndex;
	bool		used;
	bool		dirty;
	CheckSum	checkSums[kCheckSumsPerBlock];

	CheckSumBlock()
		:
		used(false)
	{
	}
};


struct CheckSumCache {
	CheckSumCache()
	{
		mutex_init(&fLock, "check sum cache");
	}

	~CheckSumCache()
	{
		while (CheckSumBlock* block = fBlocks.RemoveHead())
			delete block;

		mutex_destroy(&fLock);
	}

	status_t Init(int fd, uint64 blockCount, uint32 cachedBlockCount)
	{
		fBlockCount = blockCount;
		fFD = fd;

		for (uint32 i = 0; i < cachedBlockCount; i++) {
			CheckSumBlock* block = new(std::nothrow) CheckSumBlock;
			if (block == NULL)
				return B_NO_MEMORY;

			fBlocks.Add(block);
		}

		return B_OK;
	}

	status_t GetCheckSum(uint64 blockIndex, CheckSum& checkSum)
	{
		ASSERT(blockIndex < fBlockCount);

		MutexLocker locker(fLock);

		CheckSumBlock* block;
		status_t error = _GetBlock(
			fBlockCount + blockIndex / kCheckSumsPerBlock, block);
		if (error != B_OK)
			return error;

		checkSum = block->checkSums[blockIndex % kCheckSumsPerBlock];

		return B_OK;
	}

	status_t SetCheckSum(uint64 blockIndex, const CheckSum& checkSum)
	{
		ASSERT(blockIndex < fBlockCount);

		MutexLocker locker(fLock);

		CheckSumBlock* block;
		status_t error = _GetBlock(
			fBlockCount + blockIndex / kCheckSumsPerBlock, block);
		if (error != B_OK)
			return error;

		block->checkSums[blockIndex % kCheckSumsPerBlock] = checkSum;
		block->dirty = true;

#ifdef TRACE_CHECK_SUM_DEVICE
		TRACE("checksum_device: setting check sum of block %" B_PRIu64 " to: ",
			blockIndex);
		for (size_t i = 0; i < kCheckSumLength; i++)
			TRACE("%02x", checkSum.Data()[i]);
		TRACE("\n");
#endif

		return B_OK;
	}

private:
	typedef DoublyLinkedList<CheckSumBlock> BlockList;

private:
	status_t _GetBlock(uint64 blockIndex, CheckSumBlock*& _block)
	{
		// check whether we have already cached the block
		for (BlockList::Iterator it = fBlocks.GetIterator();
			CheckSumBlock* block = it.Next();) {
			if (block->used && blockIndex == block->blockIndex) {
				// we know it -- requeue and return
				it.Remove();
				fBlocks.Add(block);
				_block = block;
				return B_OK;
			}
		}

		// flush the least recently used block and recycle it
		CheckSumBlock* block = fBlocks.Head();
		status_t error = _FlushBlock(block);
		if (error != B_OK)
			return error;

		error = _ReadBlock(block, blockIndex);
		if (error != B_OK)
			return error;

		// requeue
		fBlocks.Remove(block);
		fBlocks.Add(block);

		_block = block;
		return B_OK;
	}

	status_t _FlushBlock(CheckSumBlock* block)
	{
		if (!block->used || !block->dirty)
			return B_OK;

		ssize_t written = pwrite(fFD, block->checkSums, B_PAGE_SIZE,
			block->blockIndex * B_PAGE_SIZE);
		if (written < 0)
			return errno;
		if (written != B_PAGE_SIZE)
			return B_ERROR;

		block->dirty = false;
		return B_OK;
	}

	status_t _ReadBlock(CheckSumBlock* block, uint64 blockIndex)
	{
		// mark unused for the failure cases -- reset later
		block->used = false;

		ssize_t bytesRead = pread(fFD, block->checkSums, B_PAGE_SIZE,
			blockIndex * B_PAGE_SIZE);
		if (bytesRead < 0)
			return errno;
		if (bytesRead != B_PAGE_SIZE)
			return B_ERROR;

		block->blockIndex = blockIndex;
		block->used = true;
		block->dirty = false;

		return B_OK;
	}

private:
	mutex		fLock;
	uint64		fBlockCount;
	int			fFD;
	BlockList	fBlocks;	// LRU first
};


struct Device {
	Device(device_node* node)
		:
		fNode(node)
	{
		mutex_init(&fLock, "checksum device");
	}

	virtual ~Device()
	{
		mutex_destroy(&fLock);
	}

	bool Lock()		{ mutex_lock(&fLock); return true; }
	void Unlock()	{ mutex_unlock(&fLock); }

	device_node* Node() const	{ return fNode; }

	virtual status_t PublishDevice() = 0;

protected:
	mutex			fLock;
	device_node*	fNode;
};


struct ControlDevice : Device {
	ControlDevice(device_node* node)
		:
		Device(node)
	{
	}

	status_t Register(const char* fileName)
	{
		device_attr attrs[] = {
			{B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
				{string: "Checksum Raw Device"}},
			{kFilePathItem, B_STRING_TYPE, {string: fileName}},
			{NULL}
		};

		return sDeviceManager->register_node(
			sDeviceManager->get_parent_node(Node()), kDriverModuleName, attrs,
			NULL, NULL);
	}

	virtual status_t PublishDevice()
	{
		return sDeviceManager->publish_device(Node(), kControlDeviceName,
			kControlDeviceModuleName);
	}
};


struct RawDevice : Device, DoublyLinkedListLinkImpl<RawDevice> {
	RawDevice(device_node* node)
		:
		Device(node),
		fIndex(-1),
		fFD(-1),
		fFileSize(0),
		fDeviceSize(0),
		fDeviceName(NULL),
		fDMAResource(NULL),
		fIOScheduler(NULL),
		fTransferBuffer(NULL),
		fCheckSumCache(NULL)
	{
	}

	virtual ~RawDevice()
	{
		if (fIndex >= 0) {
			MutexLocker locker(sDeviceListLock);
			sDeviceList.Remove(this);
		}

		if (fFD >= 0)
			close(fFD);

		free(fDeviceName);
	}

	int32 Index() const				{ return fIndex; }
	off_t DeviceSize() const		{ return fDeviceSize; }
	const char* DeviceName() const	{ return fDeviceName; }

	status_t Init(const char* fileName)
	{
		// open file/device
		fFD = open(fileName, O_RDWR | O_NOCACHE);
			// TODO: The O_NOCACHE is a work-around for a page writer problem.
			// Since it collects pages for writing back without regard for
			// which caches and file systems they belong to, a deadlock can
			// result when pages from both the underlying file system and the
			// one using the checksum device are collected in one run.
		if (fFD < 0)
			return errno;

		// get the size
		struct stat st;
		if (fstat(fFD, &st) < 0)
			return errno;

		switch (st.st_mode & S_IFMT) {
			case S_IFREG:
				fFileSize = st.st_size;
				break;
			case S_IFCHR:
			case S_IFBLK:
			{
				device_geometry geometry;
				if (ioctl(fFD, B_GET_GEOMETRY, &geometry, sizeof(geometry)) < 0)
					return errno;

				fFileSize = (off_t)geometry.bytes_per_sector
					* geometry.sectors_per_track
					* geometry.cylinder_count * geometry.head_count;
				break;
			}
			default:
				return B_BAD_VALUE;
		}

		fFileSize = fFileSize / B_PAGE_SIZE * B_PAGE_SIZE;
		fDeviceSize = fFileSize / (B_PAGE_SIZE + kCheckSumLength) * B_PAGE_SIZE;

		// find a free slot
		fIndex = 0;
		RawDevice* nextDevice = NULL;
		MutexLocker locker(sDeviceListLock);
		for (RawDeviceList::Iterator it = sDeviceList.GetIterator();
				(nextDevice = it.Next()) != NULL;) {
			if (nextDevice->Index() > fIndex)
				break;
			fIndex = nextDevice->Index() + 1;
		}

		sDeviceList.InsertBefore(nextDevice, this);

		// construct our device path
		KPath path(kRawDeviceBaseName);
		char buffer[32];
		snprintf(buffer, sizeof(buffer), "%" B_PRId32 "/raw", fIndex);

		status_t error = path.Append(buffer);
		if (error != B_OK)
			return error;

		fDeviceName = path.DetachBuffer();

		return B_OK;
	}

	status_t Prepare()
	{
		fCheckSumCache = new(std::nothrow) CheckSumCache;
		if (fCheckSumCache == NULL) {
			Unprepare();
			return B_NO_MEMORY;
		}

		status_t error = fCheckSumCache->Init(fFD, fDeviceSize / B_PAGE_SIZE,
			16);
		if (error != B_OK) {
			Unprepare();
			return error;
		}

		// no DMA restrictions
		const dma_restrictions restrictions = {};

		fDMAResource = new(std::nothrow) DMAResource;
		if (fDMAResource == NULL) {
			Unprepare();
			return B_NO_MEMORY;
		}

		error = fDMAResource->Init(restrictions, B_PAGE_SIZE,
			kDMAResourceBufferCount, kDMAResourceBounceBufferCount);
		if (error != B_OK) {
			Unprepare();
			return error;
		}

		fIOScheduler = new(std::nothrow) IOSchedulerSimple(fDMAResource);
		if (fIOScheduler == NULL) {
			Unprepare();
			return B_NO_MEMORY;
		}

		error = fIOScheduler->Init("checksum device scheduler");
		if (error != B_OK) {
			Unprepare();
			return error;
		}

		fIOScheduler->SetCallback(&_DoIOEntry, this);

		fTransferBuffer = malloc(B_PAGE_SIZE);
		if (fTransferBuffer == NULL) {
			Unprepare();
			return B_NO_MEMORY;
		}

		return B_OK;
	}

	void Unprepare()
	{
		free(fTransferBuffer);
		fTransferBuffer = NULL;

		delete fIOScheduler;
		fIOScheduler = NULL;

		delete fDMAResource;
		fDMAResource = NULL;

		delete fCheckSumCache;
		fCheckSumCache = NULL;
	}

	status_t DoIO(IORequest* request)
	{
		return fIOScheduler->ScheduleRequest(request);
	}

	virtual status_t PublishDevice()
	{
		return sDeviceManager->publish_device(Node(), fDeviceName,
			kRawDeviceModuleName);
	}

	status_t GetBlockCheckSum(uint64 blockIndex, CheckSum& checkSum)
	{
		return fCheckSumCache->GetCheckSum(blockIndex, checkSum);
	}

	status_t SetBlockCheckSum(uint64 blockIndex, const CheckSum& checkSum)
	{
		return fCheckSumCache->SetCheckSum(blockIndex, checkSum);
	}

private:
	static status_t _DoIOEntry(void* data, IOOperation* operation)
	{
		return ((RawDevice*)data)->_DoIO(operation);
	}

	status_t _DoIO(IOOperation* operation)
	{
		off_t offset = operation->Offset();
		generic_size_t length = operation->Length();

		ASSERT(offset % B_PAGE_SIZE == 0);
		ASSERT(length % B_PAGE_SIZE == 0);

		const generic_io_vec* vecs = operation->Vecs();
		generic_size_t vecOffset = 0;
		bool isWrite = operation->IsWrite();

		while (length > 0) {
			status_t error = _TransferBlock(vecs, vecOffset, offset, isWrite);
			if (error != B_OK) {
				fIOScheduler->OperationCompleted(operation, error, 0);
				return error;
			}

			offset += B_PAGE_SIZE;
			length -= B_PAGE_SIZE;
		}

		fIOScheduler->OperationCompleted(operation, B_OK, operation->Length());
		return B_OK;
	}

	status_t _TransferBlock(const generic_io_vec*& vecs,
		generic_size_t& vecOffset, off_t offset, bool isWrite)
	{
		if (isWrite) {
			// write -- copy data to transfer buffer
			status_t error = _CopyData(vecs, vecOffset, true);
			if (error != B_OK)
				return error;
			_CheckCheckSum(offset / B_PAGE_SIZE);
		}

		ssize_t transferred = isWrite
			? pwrite(fFD, fTransferBuffer, B_PAGE_SIZE, offset)
			: pread(fFD, fTransferBuffer, B_PAGE_SIZE, offset);

		if (transferred < 0)
			return errno;
		if (transferred != B_PAGE_SIZE)
			return B_ERROR;

		if (!isWrite) {
			// read -- copy data from transfer buffer
			status_t error =_CopyData(vecs, vecOffset, false);
			if (error != B_OK)
				return error;
		}

		return B_OK;
	}

	status_t _CopyData(const generic_io_vec*& vecs, generic_size_t& vecOffset,
		bool toBuffer)
	{
		uint8* buffer = (uint8*)fTransferBuffer;
		size_t length = B_PAGE_SIZE;
		while (length > 0) {
			size_t toCopy = std::min((generic_size_t)length,
				vecs->length - vecOffset);

			if (toCopy == 0) {
				vecs++;
				vecOffset = 0;
				continue;
			}

			phys_addr_t vecAddress = vecs->base + vecOffset;

			status_t error = toBuffer
				? vm_memcpy_from_physical(buffer, vecAddress, toCopy, false)
				: vm_memcpy_to_physical(vecAddress, buffer, toCopy, false);
			if (error != B_OK)
				return error;

			buffer += toCopy;
			length -= toCopy;
			vecOffset += toCopy;
		}

		return B_OK;
	}

	void _CheckCheckSum(uint64 blockIndex)
	{
		// get the checksum the block should have
		CheckSum expectedCheckSum;
		if (fCheckSumCache->GetCheckSum(blockIndex, expectedCheckSum) != B_OK)
			return;

		// if the checksum is clear, we aren't supposed to check
		if (expectedCheckSum.IsZero()) {
			dprintf("checksum_device: skipping check sum check for block %"
				B_PRIu64 "\n", blockIndex);
			return;
		}

		// compute the transfer buffer check sum
		fSHA256.Init();
		fSHA256.Update(fTransferBuffer, B_PAGE_SIZE);

		if (expectedCheckSum != fSHA256.Digest())
			panic("Check sum mismatch for block %" B_PRIu64 " (exptected at %p"
				", actual at %p)", blockIndex, &expectedCheckSum,
				fSHA256.Digest());
	}

private:
	int32			fIndex;
	int				fFD;
	off_t			fFileSize;
	off_t			fDeviceSize;
	char*			fDeviceName;
	DMAResource*	fDMAResource;
	IOScheduler*	fIOScheduler;
	void*			fTransferBuffer;
	CheckSumCache*	fCheckSumCache;
	SHA256			fSHA256;
};


struct RawDeviceCookie {
	RawDeviceCookie(RawDevice* device, int openMode)
		:
		fDevice(device),
		fOpenMode(openMode)
	{
	}

	RawDevice* Device() const	{ return fDevice; }
	int OpenMode() const		{ return fOpenMode; }

private:
	RawDevice*	fDevice;
	int			fOpenMode;
};


// #pragma mark -


static bool
parse_command_line(char* buffer, char**& _argv, int& _argc)
{
	// Process the argument string. We split at whitespace, heeding quotes and
	// escaped characters. The processed arguments are written to the given
	// buffer, separated by single null chars.
	char* start = buffer;
	char* out = buffer;
	bool pendingArgument = false;
	int argc = 0;
	while (*start != '\0') {
		// ignore whitespace
		if (isspace(*start)) {
			if (pendingArgument) {
				*out = '\0';
				out++;
				argc++;
				pendingArgument = false;
			}
			start++;
			continue;
		}

		pendingArgument = true;

		if (*start == '"' || *start == '\'') {
			// quoted text -- continue until closing quote
			char quote = *start;
			start++;
			while (*start != '\0' && *start != quote) {
				if (*start == '\\' && quote == '"') {
					start++;
					if (*start == '\0')
						break;
				}
				*out = *start;
				start++;
				out++;
			}

			if (*start != '\0')
				start++;
		} else {
			// unquoted text
			if (*start == '\\') {
				// escaped char
				start++;
				if (start == '\0')
					break;
			}

			*out = *start;
			start++;
			out++;
		}
	}

	if (pendingArgument) {
		*out = '\0';
		argc++;
	}

	// allocate argument vector
	char** argv = new(std::nothrow) char*[argc + 1];
	if (argv == NULL)
		return false;

	// fill vector
	start = buffer;
	for (int i = 0; i < argc; i++) {
		argv[i] = start;
		start += strlen(start) + 1;
	}
	argv[argc] = NULL;

	_argv = argv;
	_argc = argc;
	return true;
}


//	#pragma mark - driver


static float
checksum_driver_supports_device(device_node* parent)
{
	const char* bus = NULL;
	if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false)
			== B_OK && !strcmp(bus, "generic"))
		return 0.8;

	return -1;
}


static status_t
checksum_driver_register_device(device_node* parent)
{
	device_attr attrs[] = {
		{B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
			{string: "Checksum Control Device"}},
		{NULL}
	};

	return sDeviceManager->register_node(parent, kDriverModuleName, attrs, NULL,
		NULL);
}


static status_t
checksum_driver_init_driver(device_node* node, void** _driverCookie)
{
	const char* fileName;
	if (sDeviceManager->get_attr_string(node, kFilePathItem, &fileName, false)
			== B_OK) {
		RawDevice* device = new(std::nothrow) RawDevice(node);
		if (device == NULL)
			return B_NO_MEMORY;

		status_t error = device->Init(fileName);
		if (error != B_OK) {
			delete device;
			return error;
		}

		*_driverCookie = (Device*)device;
	} else {
		ControlDevice* device = new(std::nothrow) ControlDevice(node);
		if (device == NULL)
			return B_NO_MEMORY;

		*_driverCookie = (Device*)device;
	}

	return B_OK;
}


static void
checksum_driver_uninit_driver(void* driverCookie)
{
	Device* device = (Device*)driverCookie;
	delete device;
}


static status_t
checksum_driver_register_child_devices(void* driverCookie)
{
	Device* device = (Device*)driverCookie;
	return device->PublishDevice();
}


//	#pragma mark - control device


static status_t
checksum_control_device_init_device(void* driverCookie, void** _deviceCookie)
{
	*_deviceCookie = driverCookie;
	return B_OK;
}


static void
checksum_control_device_uninit_device(void* deviceCookie)
{
}


static status_t
checksum_control_device_open(void* deviceCookie, const char* path, int openMode,
	void** _cookie)
{
	*_cookie = deviceCookie;
	return B_OK;
}


static status_t
checksum_control_device_close(void* cookie)
{
	return B_OK;
}


static status_t
checksum_control_device_free(void* cookie)
{
	return B_OK;
}


static status_t
checksum_control_device_read(void* cookie, off_t position, void* buffer,
	size_t* _length)
{
	*_length = 0;
	return B_OK;
}


static status_t
checksum_control_device_write(void* cookie, off_t position, const void* data,
	size_t* _length)
{
	ControlDevice* device = (ControlDevice*)cookie;

	if (position != 0)
		return B_BAD_VALUE;

	// copy data to stack buffer
	char* buffer = (char*)malloc(*_length + 1);
	if (buffer == NULL)
		return B_NO_MEMORY;
	MemoryDeleter bufferDeleter(buffer);

	if (IS_USER_ADDRESS(data)) {
		if (user_memcpy(buffer, data, *_length) != B_OK)
			return B_BAD_ADDRESS;
	} else
		memcpy(buffer, data, *_length);

	buffer[*_length] = '\0';

	// parse arguments
	char** argv;
	int argc;
	if (!parse_command_line(buffer, argv, argc))
		return B_NO_MEMORY;
	ArrayDeleter<char*> argvDeleter(argv);

	if (argc == 0) {
		dprintf("\"help\" for usage!\n");
		return B_BAD_VALUE;
	}

	// execute command
	if (strcmp(argv[0], "help") == 0) {
		// help
		dprintf("register <path>\n");
		dprintf("  Registers file <path> as a new checksum device.\n");
		dprintf("unregister <device>\n");
		dprintf("  Unregisters <device>.\n");
	} else if (strcmp(argv[0], "register") == 0) {
		// register
		if (argc != 2) {
			dprintf("Usage: register <path>\n");
			return B_BAD_VALUE;
		}

		return device->Register(argv[1]);
	} else if (strcmp(argv[0], "unregister") == 0) {
		// unregister
		if (argc != 2) {
			dprintf("Usage: unregister <device>\n");
			return B_BAD_VALUE;
		}

		const char* deviceName = argv[1];
		if (strncmp(deviceName, "/dev/", 5) == 0)
			deviceName += 5;

		// find the device in the list and unregister it
		MutexLocker locker(sDeviceListLock);
		for (RawDeviceList::Iterator it = sDeviceList.GetIterator();
				RawDevice* device = it.Next();) {
			if (strcmp(device->DeviceName(), deviceName) == 0) {
				// TODO: Race condition: We should mark the device as going to
				// be unregistered, so no one else can try the same after we
				// unlock!
				locker.Unlock();
// TODO: The following doesn't work! unpublish_device(), as per implementation
// (partially commented out) and unregister_node() returns B_BUSY.
				status_t error = sDeviceManager->unpublish_device(
					device->Node(), device->DeviceName());
				if (error != B_OK) {
					dprintf("Failed to unpublish device \"%s\": %s\n",
						deviceName, strerror(error));
					return error;
				}

				error = sDeviceManager->unregister_node(device->Node());
				if (error != B_OK) {
					dprintf("Failed to unregister node \"%s\": %s\n",
						deviceName, strerror(error));
					return error;
				}

				return B_OK;
			}
		}

		dprintf("Device \"%s\" not found!\n", deviceName);
		return B_BAD_VALUE;
	} else {
		dprintf("Invalid command \"%s\"!\n", argv[0]);
		return B_BAD_VALUE;
	}

	return B_OK;
}


static status_t
checksum_control_device_control(void* cookie, uint32 op, void* buffer,
	size_t length)
{
	return B_BAD_VALUE;
}


//	#pragma mark - raw device


static status_t
checksum_raw_device_init_device(void* driverCookie, void** _deviceCookie)
{
	RawDevice* device = static_cast<RawDevice*>((Device*)driverCookie);

	status_t error = device->Prepare();
	if (error != B_OK)
		return error;

	*_deviceCookie = device;
	return B_OK;
}


static void
checksum_raw_device_uninit_device(void* deviceCookie)
{
	RawDevice* device = (RawDevice*)deviceCookie;
	device->Unprepare();
}


static status_t
checksum_raw_device_open(void* deviceCookie, const char* path, int openMode,
	void** _cookie)
{
	RawDevice* device = (RawDevice*)deviceCookie;

	RawDeviceCookie* cookie = new(std::nothrow) RawDeviceCookie(device,
		openMode);
	if (cookie == NULL)
		return B_NO_MEMORY;

	*_cookie = cookie;
	return B_OK;
}


static status_t
checksum_raw_device_close(void* cookie)
{
	return B_OK;
}


static status_t
checksum_raw_device_free(void* _cookie)
{
	RawDeviceCookie* cookie = (RawDeviceCookie*)_cookie;
	delete cookie;
	return B_OK;
}


static status_t
checksum_raw_device_read(void* _cookie, off_t pos, void* buffer,
	size_t* _length)
{
	RawDeviceCookie* cookie = (RawDeviceCookie*)_cookie;
	RawDevice* device = cookie->Device();

	size_t length = *_length;

	if (pos >= device->DeviceSize())
		return B_BAD_VALUE;
	if (pos + length > device->DeviceSize())
		length = device->DeviceSize() - pos;

	IORequest request;
	status_t status = request.Init(pos, (addr_t)buffer, length, false, 0);
	if (status != B_OK)
		return status;

	status = device->DoIO(&request);
	if (status != B_OK)
		return status;

	status = request.Wait(0, 0);
	if (status == B_OK)
		*_length = length;
	return status;
}


static status_t
checksum_raw_device_write(void* _cookie, off_t pos, const void* buffer,
	size_t* _length)
{
	RawDeviceCookie* cookie = (RawDeviceCookie*)_cookie;
	RawDevice* device = cookie->Device();

	size_t length = *_length;

	if (pos >= device->DeviceSize())
		return B_BAD_VALUE;
	if (pos + length > device->DeviceSize())
		length = device->DeviceSize() - pos;

	IORequest request;
	status_t status = request.Init(pos, (addr_t)buffer, length, true, 0);
	if (status != B_OK)
		return status;

	status = device->DoIO(&request);
	if (status != B_OK)
		return status;

	status = request.Wait(0, 0);
	if (status == B_OK)
		*_length = length;

	return status;
}


static status_t
checksum_raw_device_io(void* _cookie, io_request* request)
{
	RawDeviceCookie* cookie = (RawDeviceCookie*)_cookie;
	RawDevice* device = cookie->Device();

	return device->DoIO(request);
}


static status_t
checksum_raw_device_control(void* _cookie, uint32 op, void* buffer,
	size_t length)
{
	RawDeviceCookie* cookie = (RawDeviceCookie*)_cookie;
	RawDevice* device = cookie->Device();

	switch (op) {
		case B_GET_DEVICE_SIZE:
		{
			size_t size = device->DeviceSize();
			return user_memcpy(buffer, &size, sizeof(size_t));
		}

		case B_SET_NONBLOCKING_IO:
		case B_SET_BLOCKING_IO:
			return B_OK;

		case B_GET_READ_STATUS:
		case B_GET_WRITE_STATUS:
		{
			bool value = true;
			return user_memcpy(buffer, &value, sizeof(bool));
		}

		case B_GET_GEOMETRY:
		case B_GET_BIOS_GEOMETRY:
		{
			device_geometry geometry;
			geometry.bytes_per_sector = B_PAGE_SIZE;
			geometry.sectors_per_track = 1;
			geometry.cylinder_count = device->DeviceSize() / B_PAGE_SIZE;
				// TODO: We're limited to 2^32 * B_PAGE_SIZE, if we don't use
				// sectors_per_track and head_count.
			geometry.head_count = 1;
			geometry.device_type = B_DISK;
			geometry.removable = true;
			geometry.read_only = false;
			geometry.write_once = false;

			return user_memcpy(buffer, &geometry, sizeof(device_geometry));
		}

		case B_GET_MEDIA_STATUS:
		{
			status_t status = B_OK;
			return user_memcpy(buffer, &status, sizeof(status_t));
		}

		case B_SET_UNINTERRUPTABLE_IO:
		case B_SET_INTERRUPTABLE_IO:
		case B_FLUSH_DRIVE_CACHE:
			return B_OK;

		case CHECKSUM_DEVICE_IOCTL_GET_CHECK_SUM:
		{
			if (IS_USER_ADDRESS(buffer)) {
				checksum_device_ioctl_check_sum getCheckSum;
				if (user_memcpy(&getCheckSum, buffer, sizeof(getCheckSum))
						!= B_OK) {
					return B_BAD_ADDRESS;
				}

				status_t error = device->GetBlockCheckSum(
					getCheckSum.blockIndex, getCheckSum.checkSum);
				if (error != B_OK)
					return error;

				return user_memcpy(buffer, &getCheckSum, sizeof(getCheckSum));
			}

			checksum_device_ioctl_check_sum* getCheckSum
				= (checksum_device_ioctl_check_sum*)buffer;
			return device->GetBlockCheckSum(getCheckSum->blockIndex,
				getCheckSum->checkSum);
		}

		case CHECKSUM_DEVICE_IOCTL_SET_CHECK_SUM:
		{
			if (IS_USER_ADDRESS(buffer)) {
				checksum_device_ioctl_check_sum setCheckSum;
				if (user_memcpy(&setCheckSum, buffer, sizeof(setCheckSum))
						!= B_OK) {
					return B_BAD_ADDRESS;
				}

				return device->SetBlockCheckSum(setCheckSum.blockIndex,
					setCheckSum.checkSum);
			}

			checksum_device_ioctl_check_sum* setCheckSum
				= (checksum_device_ioctl_check_sum*)buffer;
			return device->SetBlockCheckSum(setCheckSum->blockIndex,
				setCheckSum->checkSum);
		}
	}
	return B_BAD_VALUE;
}


// #pragma mark -


module_dependency module_dependencies[] = {
	{B_DEVICE_MANAGER_MODULE_NAME, (module_info**)&sDeviceManager},
	{}
};


static const struct driver_module_info sChecksumDeviceDriverModule = {
	{
		kDriverModuleName,
		0,
		NULL
	},

	checksum_driver_supports_device,
	checksum_driver_register_device,
	checksum_driver_init_driver,
	checksum_driver_uninit_driver,
	checksum_driver_register_child_devices
};

static const struct device_module_info sChecksumControlDeviceModule = {
	{
		kControlDeviceModuleName,
		0,
		NULL
	},

	checksum_control_device_init_device,
	checksum_control_device_uninit_device,
	NULL,

	checksum_control_device_open,
	checksum_control_device_close,
	checksum_control_device_free,

	checksum_control_device_read,
	checksum_control_device_write,
	NULL,	// io

	checksum_control_device_control,

	NULL,	// select
	NULL	// deselect
};

static const struct device_module_info sChecksumRawDeviceModule = {
	{
		kRawDeviceModuleName,
		0,
		NULL
	},

	checksum_raw_device_init_device,
	checksum_raw_device_uninit_device,
	NULL,

	checksum_raw_device_open,
	checksum_raw_device_close,
	checksum_raw_device_free,

	checksum_raw_device_read,
	checksum_raw_device_write,
	checksum_raw_device_io,

	checksum_raw_device_control,

	NULL,	// select
	NULL	// deselect
};

const module_info* modules[] = {
	(module_info*)&sChecksumDeviceDriverModule,
	(module_info*)&sChecksumControlDeviceModule,
	(module_info*)&sChecksumRawDeviceModule,
	NULL
};