drivers/block/copy.c

Go to the documentation of this file.

#include <debug.h>
#include <malloc.h>
#include <string.h>
#include <block/device.h>
#include <buffer.h>
#include <workqueue.h>
#include <app/workqueue.h>
#include <app/config_dmapool.h>
#include <block/copy.h>

#define BLOCK_COPY_BUF_SIZE     CONFIG_DMAPOOL_LARGE_OBJ_SIZE
#define BLOCK_COPY_MAX_BUFFERS  (CONFIG_DMAPOOL_NR_LARGE_OBJS / 2)

static void block_copy_read_blocks(void *data);

static void block_copy_complete(void *data)
{
        struct block_copy_request *req = data;

        if (req->completion_callback)
                req->completion_callback(req, req->total_blocks_copied,
                                req->data);
}

static void block_copy_continue(void *data)
{
        struct block_copy_request *req = data;

        if (req->progress_callback)
                req->progress_callback(req, req->total_blocks_copied,
                                req->data);

        workqueue_init_item(&req->work,
                        block_copy_read_blocks, req);
        workqueue_add_item(&block_workqueue, &req->work);
}

static void block_copy_write_done(
                struct block_device *bdev,
                struct block_request *breq)
{
        struct block_copy_request *req = breq->context;
        uint32_t blocks_xfered = breq->bytes_xfered / req->block_size;

        if (breq->status) {
                dbg_error("block copy: Error during write, status: %d\n",
                                breq->status);
                req->status = req->dest_status = breq->status;
                /* Schedule the completion callback to be executed */
                workqueue_init_item(&req->work,
                                block_copy_complete, req);
                workqueue_add_item(&block_workqueue, &req->work);
                return;
        } else {
                dbg_verbose("block copy: Write completed: %zu blocks "
                                "written\n", breq->bytes_xfered);
        }

        slist_move_to_tail(&req->buffer_list, &breq->buf_list);
        req->total_blocks_copied += blocks_xfered;

        if (req->total_blocks_copied < req->length)
                workqueue_init_item(&req->work, block_copy_continue, req);
        else
                workqueue_init_item(&req->work, block_copy_complete, req);

        workqueue_add_item(&block_workqueue, &req->work);
}

static void block_copy_write_blocks(void *data)
{
        struct block_copy_request *req = data;

        block_prepare_req(req->target, req->write_req,
                        req->target_start + req->total_blocks_copied,
                        req->blocks_allocated, BLK_OP_WRITE);
        slist_move_to_tail(&req->write_req->buf_list,
                        &req->read_req->buf_list);
        block_submit_req(req->target, req->write_req);
}

static void block_copy_read_done(
                struct block_device *bdev,
                struct block_request *breq)
{
        struct block_copy_request *req = breq->context;

        if (breq->status) {
                dbg_error("block copy: Error during read, status: %d\n",
                                breq->status);

                req->status = req->source_status = breq->status;

                /* Schedule the completion callback to be executed */
                workqueue_init_item(&req->work,
                                block_copy_complete, req);
        } else {
                dbg_verbose("block copy: Read completed: %zu bytes read\n",
                                breq->bytes_xfered);
                workqueue_init_item(&req->work, block_copy_write_blocks, req);
        }

        workqueue_add_item(&block_workqueue, &req->work);
}

static void block_copy_read_blocks(void *data)
{
        struct block_copy_request *req = data;
        struct buffer *buf;
        struct slist *buffer_list = &req->buffer_list;
        uint32_t blocks_remaining = req->length - req->total_blocks_copied;
        uint32_t excess_blocks;

        if (req->total_blocks_copied > 0) {
                /* Free excess buffers */
                while (req->blocks_allocated - req->blocks_pr_buf
                                >= blocks_remaining) {
                        buf = slist_pop_head(buffer_list,
                                        struct buffer, node);
                        buffer_dma_free(buf, BLOCK_COPY_BUF_SIZE);
                        req->blocks_allocated -= req->blocks_pr_buf;
                }

                /* If our buffers still are to big after removing the
                 * excess, we need to resize one of them to fit our data */
                if (req->blocks_allocated > blocks_remaining) {
                        excess_blocks = req->blocks_allocated
                                - blocks_remaining;
                        buf = slist_peek_tail(buffer_list,
                                        struct buffer, node);
                        buffer_resize(buf, BLOCK_COPY_BUF_SIZE
                                        - req->block_size * excess_blocks);
                        req->blocks_allocated = blocks_remaining;
                }
        }

        block_prepare_req(req->source, req->read_req,
                        req->source_start + req->total_blocks_copied,
                        req->blocks_allocated, BLK_OP_READ);
        slist_move_to_tail(&req->read_req->buf_list, buffer_list);

        block_submit_req(req->source, req->read_req);
}

struct block_copy_request *block_copy_alloc(
                uint32_t nr_blocks,
                uint32_t block_size,
                void *data)
{
        struct block_copy_request *request;
        uint32_t alloc_size;
        struct buffer *buf;
        unsigned int i;

        assert(nr_blocks > 0);

        if (BLOCK_COPY_BUF_SIZE < block_size)
                return NULL;
        if (BLOCK_COPY_BUF_SIZE % block_size)
                return NULL;

        request = malloc(sizeof(struct block_copy_request));
        if (!request)
                return NULL;

        memset(request, 0, sizeof(struct block_copy_request));

        request->block_size = block_size;
        request->blocks_pr_buf = BLOCK_COPY_BUF_SIZE / block_size;

        request->data = data;
        request->length = nr_blocks;
        slist_init(&request->buffer_list);

        for (i = 0; i < BLOCK_COPY_MAX_BUFFERS; i++) {
                uint32_t blocks_remaining;

                /* We only allocate from the large object pool and resize
                 * the last buffer to match the size of our data */
                buf = buffer_dma_alloc(BLOCK_COPY_BUF_SIZE);
                if (!buf)
                        break;

                slist_insert_tail(&request->buffer_list, &buf->node);
                blocks_remaining = request->length - request->blocks_allocated;
                alloc_size = request->blocks_pr_buf;
                request->blocks_allocated += alloc_size;

                if (alloc_size >= blocks_remaining) {
                        if (alloc_size > blocks_remaining) {
                                request->blocks_allocated
                                        -= alloc_size - blocks_remaining;
                                alloc_size = blocks_remaining;
                                buffer_resize(buf, alloc_size * block_size);
                        }
                        break;
                }
        }

        if (request->blocks_allocated == 0) {
                /* Give up if we could not allocate any buffers */
                free(request);
                return NULL;
        }

        return request;
}

void block_copy_free(struct block_copy_request *request)
{
        struct buffer *buf;

        while (!slist_is_empty(&request->buffer_list)) {
                buf = slist_pop_head(&request->buffer_list,
                                struct buffer, node);
                /* All our buffers are allocated from the large object
                 * pool, even those that are smaller */
                buffer_dma_free(buf, BLOCK_COPY_BUF_SIZE);
        }

        if (request->read_req)
                block_free_request(request->source, request->read_req);
        if (request->write_req)
                block_free_request(request->target, request->write_req);

        free(request);
}

int block_copy_set_source(
                struct block_copy_request *req,
                struct block_device *dev,
                block_addr_t lba)
{
        assert(req);
        assert(dev);

        if (req->block_size != dev->block_size)
                return -BLOCK_COPY_BLOCK_SIZE_MISMATCH;

        req->source = dev;
        req->source_start = lba;
        req->read_req = block_alloc_request(dev);

        if (!req->read_req)
                return -BLOCK_COPY_NOMEM;

        req->read_req->req_done = block_copy_read_done;
        req->read_req->context = req;
        return 0;
}

int block_copy_set_dest(
                struct block_copy_request *req,
                struct block_device *dev,
                block_addr_t lba)
{
        assert(req);
        assert(dev);

        if (req->block_size != dev->block_size)
                return -BLOCK_COPY_BLOCK_SIZE_MISMATCH;

        req->target = dev;
        req->target_start = lba;
        req->write_req = block_alloc_request(dev);

        if (!req->write_req)
                return -BLOCK_COPY_NOMEM;

        req->write_req->req_done = block_copy_write_done;
        req->write_req->context = req;
        return 0;
}

void block_copy_set_completion_callback(
                struct block_copy_request *req,
                void (*callback)
                        (struct block_copy_request *, uint32_t, void *))
{
        assert(req);
        req->completion_callback = callback;
}

void block_copy_set_progress_callback(
                struct block_copy_request *req,
                void (*callback)
                        (struct block_copy_request *, uint32_t, void *))
{
        assert(req);
        req->progress_callback = callback;
}

void block_copy_submit(struct block_copy_request *req)
{
        assert(req);
        assert(req->source);
        assert(req->target);
        assert(req->read_req);
        assert(req->write_req);

        req->total_blocks_copied = 0;

        block_copy_read_blocks(req);
}

---