lib/bio/bio.c

/*
 * Copyright (c) 2009 Travis Geiselbrecht
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include <stdlib.h>
#include <debug.h>
#include <err.h>
#include <string.h>
#include <list.h>
#include <lib/bio.h>
#include <kernel/mutex.h>

#define LOCAL_TRACE 0

struct bdev_struct {
	struct list_node list;
	mutex_t lock;
};

static struct bdev_struct *bdevs;

/* default implementation is to use the read_block hook to 'deblock' the device */
static ssize_t bio_default_read(struct bdev *dev, void *_buf, off_t offset, size_t len)
{
	uint8_t *buf = (uint8_t *)_buf;
	ssize_t bytes_read = 0;
	bnum_t block;
	int err = 0;
	STACKBUF_DMA_ALIGN(temp, dev->block_size); // temporary buffer for partial block transfers

	/* find the starting block */
	block = offset / dev->block_size;

	LTRACEF("buf %p, offset %lld, block %u, len %zd\n", buf, offset, block, len);
	/* handle partial first block */
	if ((offset % dev->block_size) != 0) {
		/* read in the block */
		err = bio_read_block(dev, temp, block, 1);
		if (err < 0)
			goto err;

		/* copy what we need */
		size_t block_offset = offset % dev->block_size;
		size_t tocopy = MIN(dev->block_size - block_offset, len);
		memcpy(buf, temp + block_offset, tocopy);

		/* increment our buffers */
		buf += tocopy;
		len -= tocopy;
		bytes_read += tocopy;
		block++;
	}

	LTRACEF("buf %p, block %u, len %zd\n", buf, block, len);
	/* handle middle blocks */
	if (len >= dev->block_size) {
		/* do the middle reads */
		size_t block_count = len / dev->block_size;
		err = bio_read_block(dev, buf, block, block_count);
		if (err < 0)
			goto err;

		/* increment our buffers */
		size_t bytes = block_count * dev->block_size;
		DEBUG_ASSERT(bytes <= len);

		buf += bytes;
		len -= bytes;
		bytes_read += bytes;
		block += block_count;
	}

	LTRACEF("buf %p, block %u, len %zd\n", buf, block, len);
	/* handle partial last block */
	if (len > 0) {
		/* read the block */
		err = bio_read_block(dev, temp, block, 1);
		if (err < 0)
			goto err;

		/* copy the partial block from our temp buffer */
		memcpy(buf, temp, len);

		bytes_read += len;
	}

err:
	/* return error or bytes read */
	return (err >= 0) ? bytes_read : err;
}

static ssize_t bio_default_write(struct bdev *dev, const void *_buf, off_t offset, size_t len)
{
	const uint8_t *buf = (const uint8_t *)_buf;
	ssize_t bytes_written = 0;
	bnum_t block;
	int err = 0;
	STACKBUF_DMA_ALIGN(temp, dev->block_size); // temporary buffer for partial block transfers

	/* find the starting block */
	block = offset / dev->block_size;

	LTRACEF("buf %p, offset %lld, block %u, len %zd\n", buf, offset, block, len);
	/* handle partial first block */
	if ((offset % dev->block_size) != 0) {
		/* read in the block */
		err = bio_read_block(dev, temp, block, 1);
		if (err < 0)
			goto err;

		/* copy what we need */
		size_t block_offset = offset % dev->block_size;
		size_t tocopy = MIN(dev->block_size - block_offset, len);
		memcpy(temp + block_offset, buf, tocopy);

		/* write it back out */
		err = bio_write_block(dev, temp, block, 1);
		if (err < 0)
			goto err;

		/* increment our buffers */
		buf += tocopy;
		len -= tocopy;
		bytes_written += tocopy;
		block++;
	}

	LTRACEF("buf %p, block %u, len %zd\n", buf, block, len);
	/* handle middle blocks */
	if (len >= dev->block_size) {
		/* do the middle writes */
		size_t block_count = len / dev->block_size;
		err = bio_write_block(dev, buf, block, block_count);
		if (err < 0)
			goto err;

		/* increment our buffers */
		size_t bytes = block_count * dev->block_size;
		DEBUG_ASSERT(bytes <= len);

		buf += bytes;
		len -= bytes;
		bytes_written += bytes;
		block += block_count;
	}

	LTRACEF("buf %p, block %u, len %zd\n", buf, block, len);
	/* handle partial last block */
	if (len > 0) {
		/* read the block */
		err = bio_read_block(dev, temp, block, 1);
		if (err < 0)
			goto err;

		/* copy the partial block from our temp buffer */
		memcpy(temp, buf, len);

		/* write it back out */
		err = bio_write_block(dev, temp, block, 1);
		if (err < 0)
			goto err;

		bytes_written += len;
	}

err:
	/* return error or bytes written */
	return (err >= 0) ? bytes_written : err;
}

static ssize_t bio_default_erase(struct bdev *dev, off_t offset, size_t len)
{
	/* default erase operation is to just write zeros over the device */
#define ERASE_BUF_SIZE 4096
	uint8_t *zero_buf;

	zero_buf = calloc(1, ERASE_BUF_SIZE);

	size_t remaining = len;
	off_t pos = offset;
	while (remaining > 0) {
		ssize_t towrite = MIN(remaining, ERASE_BUF_SIZE);

		ssize_t written = bio_write(dev, zero_buf, pos, towrite);
		if (written < 0)
			return pos;

		pos += written;
		remaining -= written;

		if (written < towrite)
			return pos;
	}

	return len;
}

static ssize_t bio_default_read_block(struct bdev *dev, void *buf, bnum_t block, uint count)
{
	panic("%s no reasonable default operation\n", __PRETTY_FUNCTION__);
}

static ssize_t bio_default_write_block(struct bdev *dev, const void *buf, bnum_t block, uint count)
{
	panic("%s no reasonable default operation\n", __PRETTY_FUNCTION__);
}

static void bdev_inc_ref(bdev_t *dev)
{
	atomic_add(&dev->ref, 1);
}

static void bdev_dec_ref(bdev_t *dev)
{
	int oldval = atomic_add(&dev->ref, -1);
	if (oldval == 1) {
		// last ref, remove it
		DEBUG_ASSERT(!list_in_list(&dev->node));

		TRACEF("last ref, removing (%s)\n", dev->name);

		// call the close hook if it exists
		if (dev->close)
			dev->close(dev);

		free(dev->name);
		free(dev);
	}
}

bdev_t *bio_open(const char *name)
{
	bdev_t *bdev = NULL;

	/* see if it's in our list */
	bdev_t *entry;
	mutex_acquire(&bdevs->lock);
	list_for_every_entry(&bdevs->list, entry, bdev_t, node) {
		DEBUG_ASSERT(entry->ref > 0);
		if (!strcmp(entry->name, name)) {
			bdev = entry;
			bdev_inc_ref(bdev);
			break;
		}
	}
	mutex_release(&bdevs->lock);

	return bdev;
}

void bio_close(bdev_t *dev)
{
	DEBUG_ASSERT(dev);

	bdev_dec_ref(dev);
}

ssize_t bio_read(bdev_t *dev, void *buf, off_t offset, size_t len)
{
	LTRACEF("dev '%s', buf %p, offset %lld, len %zd\n", dev->name, buf, offset, len);

	DEBUG_ASSERT(dev->ref > 0);	

	/* range check */
	if (offset < 0)
		return -1;
	if (offset >= dev->size)
		return 0;
	if (len == 0)
		return 0;
	if (offset + len > dev->size)
		len = dev->size - offset;

	return dev->read(dev, buf, offset, len);
}

ssize_t bio_read_block(bdev_t *dev, void *buf, bnum_t block, uint count)
{
	LTRACEF("dev '%s', buf %p, block %d, count %u\n", dev->name, buf, block, count);
		
	DEBUG_ASSERT(dev->ref > 0);

	/* range check */
	if (block > dev->block_count)
		return 0;
	if (count == 0)
		return 0;
	if (block + count > dev->block_count)
		count = dev->block_count - block;

	return dev->read_block(dev, buf, block, count);
}

ssize_t bio_write(bdev_t *dev, const void *buf, off_t offset, size_t len)
{
	LTRACEF("dev '%s', buf %p, offset %lld, len %zd\n", dev->name, buf, offset, len);
		
	DEBUG_ASSERT(dev->ref > 0);

	/* range check */
	if (offset < 0)
		return -1;
	if (offset >= dev->size)
		return 0;
	if (len == 0)
		return 0;
	if (offset + len > dev->size)
		len = dev->size - offset;

	return dev->write(dev, buf, offset, len);
}

ssize_t bio_write_block(bdev_t *dev, const void *buf, bnum_t block, uint count)
{
	LTRACEF("dev '%s', buf %p, block %d, count %u\n", dev->name, buf, block, count);

	DEBUG_ASSERT(dev->ref > 0);

	/* range check */
	if (block > dev->block_count)
		return 0;
	if (count == 0)
		return 0;
	if (block + count > dev->block_count)
		count = dev->block_count - block;

	return dev->write_block(dev, buf, block, count);
}

ssize_t bio_erase(bdev_t *dev, off_t offset, size_t len)
{
	LTRACEF("dev '%s', offset %lld, len %zd\n", dev->name, offset, len);
		
	DEBUG_ASSERT(dev->ref > 0);

	/* range check */
	if (offset < 0)
		return -1;
	if (offset >= dev->size)
		return 0;
	if (len == 0)
		return 0;
	if (offset + len > dev->size)
		len = dev->size - offset;

	return dev->erase(dev, offset, len);
}

int bio_ioctl(bdev_t *dev, int request, void *argp)
{
	LTRACEF("dev '%s', request %08x, argp %p\n", dev->name, request, argp);

	if (dev->ioctl == NULL) {
		return ERR_NOT_SUPPORTED;
	} else {
		return dev->ioctl(dev, request, argp);
	}
}

void bio_initialize_bdev(bdev_t *dev, const char *name, size_t block_size, bnum_t block_count)
{
	DEBUG_ASSERT(dev);
	DEBUG_ASSERT(name);
	DEBUG_ASSERT(block_size == 512); // XXX can only deal with 512 for now

	list_clear_node(&dev->node);
	dev->name = strdup(name);
	dev->block_size = block_size;
	dev->block_count = block_count;
	dev->size = (off_t)block_count * block_size;
	dev->ref = 0;

	/* set up the default hooks, the sub driver should override the block operations at least */
	dev->read = bio_default_read;
	dev->read_block = bio_default_read_block;
	dev->write = bio_default_write;
	dev->write_block = bio_default_write_block;
	dev->erase = bio_default_erase;
	dev->close = NULL;
}

void bio_register_device(bdev_t *dev)
{
	DEBUG_ASSERT(dev);

	LTRACEF(" '%s'\n", dev->name);

	bdev_inc_ref(dev);

	mutex_acquire(&bdevs->lock);
	list_add_head(&bdevs->list, &dev->node);
	mutex_release(&bdevs->lock);
}

void bio_unregister_device(bdev_t *dev)
{
	DEBUG_ASSERT(dev);

	LTRACEF(" '%s'\n", dev->name);

	// remove it from the list
	mutex_acquire(&bdevs->lock);
	list_delete(&dev->node);
	mutex_release(&bdevs->lock);

	bdev_dec_ref(dev); // remove the ref the list used to have
}

void bio_dump_devices(void)
{
	printf("block devices:\n");
	bdev_t *entry;
	mutex_acquire(&bdevs->lock);
	list_for_every_entry(&bdevs->list, entry, bdev_t, node) {
		printf("\t%s, size %lld, bsize %zd, ref %d\n", entry->name, entry->size, entry->block_size, entry->ref);
	}
	mutex_release(&bdevs->lock);
}

void bio_init(void)
{
	bdevs = malloc(sizeof(*bdevs));

	list_initialize(&bdevs->list);
	mutex_init(&bdevs->lock);
}