include/block/device.h

Go to the documentation of this file.

#ifndef BLOCK_DEVICE_H_INCLUDED
#define BLOCK_DEVICE_H_INCLUDED

#include <buffer.h>
#include <slist.h>
#include <types.h>

typedef uint32_t block_addr_t;

typedef uint32_t block_len_t;

struct block_device;

struct block_request {
        struct slist    buf_list;
        void (*req_started)(struct block_device *bdev,
                        struct block_request *req);
        void (*req_done)(struct block_device *bdev, struct block_request *req);
        void (*buf_list_done)(struct block_device *bdev,
                        struct block_request *req, struct slist *buf_list);
        void (*req_submit)(struct block_device *bdev,
                        struct block_request *req);
        int (*req_submit_buf_list)(struct block_device *bdev,
                        struct block_request *req, struct slist *buf_list);
        void (*req_abort)(struct block_device *bdev,
                        struct block_request *req);
        void                    *context;
        int                     status;
        size_t                  bytes_xfered;
        struct block_device     *bdev;
};

enum block_device_flag {
        BDEV_UNIT_ATTENTION,    
        BDEV_PRESENT,           
        BDEV_WRITEABLE,         
};

enum block_operation {
        BLK_OP_READ,            
        BLK_OP_WRITE,           
};

struct block_device {
        uint16_t        block_size;
        uint32_t        nr_blocks;
        unsigned long   flags;
        void (*prepare_req)(struct block_device *bdev,
                        struct block_request *req,
                        block_addr_t lba, uint32_t nr_blocks,
                        enum block_operation operation);
        struct block_request *(*alloc_req)(struct block_device *bdev);
        void (*free_req)(struct block_device *bdev, struct block_request *req);
        uint32_t (*get_dev_id)(struct block_device *bdev);
};

extern struct block_request *block_alloc_request(struct block_device *bdev);
extern void block_free_request(struct block_device *bdev,
                struct block_request *req);

static inline void block_prepare_req(struct block_device *bdev,
                struct block_request *req, block_addr_t lba,
                uint32_t nr_blocks, enum block_operation operation)
{
        assert(bdev == req->bdev);

        bdev->prepare_req(bdev, req, lba, nr_blocks, operation);
}

static inline void block_submit_req(struct block_device *bdev,
                struct block_request *req)
{
        assert(bdev == req->bdev);

        req->req_submit(bdev, req);
}

static inline void block_queue_req(struct block_device *bdev,
                struct block_request *req, block_addr_t lba,
                uint32_t nr_blocks, enum block_operation operation)
{
        block_prepare_req(bdev, req, lba, nr_blocks, operation);
        block_submit_req(bdev, req);
}

static inline void block_abort_req(struct block_device *bdev,
                struct block_request *req)
{
        /* FIXME */
}

static inline uint32_t block_get_dev_id(struct block_device *bdev)
{
        assert(bdev);
        assert(bdev->get_dev_id);

        return bdev->get_dev_id(bdev);
}

static inline int block_submit_buf_list(struct block_device *bdev,
                struct block_request *breq, struct slist *buf_list)
{
        assert(breq->bdev == bdev);
        assert(breq->req_submit_buf_list);

        return breq->req_submit_buf_list(bdev, breq, buf_list);
}

static inline block_len_t blk_req_get_blocks_xfered(struct block_device *bdev,
                struct block_request *breq)
{
        assert(bdev == breq->bdev);

        return breq->bytes_xfered / bdev->block_size;
}

static inline size_t blk_req_get_bytes_xfered(struct block_device *bdev,
                struct block_request *breq)
{
        assert(bdev == breq->bdev);

        return breq->bytes_xfered;
}

#define blk_req_for_each_buffer(req, buf)                       \
        slist_for_each(&req->buf_list, buf, node)

#define blk_req_for_each_buffer_safe(req, buf, next)            \
        slist_for_each_safe(&req->buf_list, buf, next, node)

static inline void blk_req_add_buffer(struct block_request *req,
                struct buffer *buf)
{
        slist_insert_tail(&req->buf_list, &buf->node);
}

static inline void blk_req_add_buffer_list(struct block_request *req,
                struct slist *list)
{
        slist_move_to_tail(&req->buf_list, list);
}

static inline void blk_req_free_all_buffers(struct block_request *req)
{
        struct buffer   *buf;
        struct buffer   *next;

        blk_req_for_each_buffer_safe(req, buf, next)
                buffer_free(buf);
}

#endif /* BLOCK_DEVICE_H_INCLUDED */

---