drivers/block/dummy.c

Go to the documentation of this file.

#include <assert.h>
#include <bitops.h>
#include <debug.h>
#include <malloc.h>
#include <status-codes.h>
#include <string.h>
#include <block/device.h>
#include <block/dummy.h>

static void dummy_do_read(struct block_device *bdev, struct block_request *req)
{
        struct buffer   *buf;
        size_t          bytes_read = 0;

        blk_req_for_each_buffer(req, buf) {
                bytes_read += buf->len;
                memset(buf->addr.ptr, 0, buf->len);
        }

        req->bytes_xfered = bytes_read;
        req->status = 0;

        req->req_done(bdev, req);
        free(req);
}

static void dummy_do_write(struct block_device *bdev, struct block_request *req)
{
        struct buffer   *buf;
        size_t          bytes_written = 0;

        blk_req_for_each_buffer(req, buf)
                bytes_written += buf->len;

        req->bytes_xfered = bytes_written;
        req->status = 0;

        req->req_done(bdev, req);
        free(req);
}

static void dummy_prepare_req(struct block_device *bdev,
                struct block_request *req,
                uint32_t lba, uint32_t nr_blocks,
                enum block_operation operation)
{
        slist_init(&req->buf_list);
        req->status = -STATUS_IN_PROGRESS;
        req->bytes_xfered = 0;
        switch (operation) {
        case BLK_OP_READ:
                req->req_submit = dummy_do_read;
                break;
        case BLK_OP_WRITE:
                req->req_submit = dummy_do_write;
                break;
        default:
                unhandled_case(operation);
        }
}

static struct block_request *dummy_alloc_req(struct block_device *bdev)
{
        struct block_request    *req;

        req = malloc(sizeof(struct block_request));
        if (unlikely(!req))
                return NULL;
        memset(req, 0, sizeof(struct block_request));

        return req;
}

static void dummy_free_req(struct block_device *bdev, struct block_request *req)
{
        free(req);
}

static uint32_t dummy_get_dev_id(struct block_device *bdev)
{
        return 0;
}

struct block_device *dummy_blkdev_init(uint16_t block_size, uint32_t nr_blocks,
                bool writeable)
{
        struct block_device *bdev;

        bdev = malloc(sizeof(struct block_device));
        if (!bdev)
                return NULL;
        memset(bdev, 0, sizeof(struct block_device));

        bdev->block_size = block_size;
        bdev->nr_blocks = nr_blocks;

        if (writeable)
                set_bit(BDEV_WRITEABLE, &bdev->flags);
        set_bit(BDEV_PRESENT, &bdev->flags);

        bdev->prepare_req = dummy_prepare_req;
        bdev->alloc_req = dummy_alloc_req;
        bdev->free_req = dummy_free_req;
        bdev->get_dev_id = dummy_get_dev_id;

        return bdev;
}

---