Block Layer API

struct bio {
    struct bio          *bi_next;       /* request queue link */
    struct block_device *bi_bdev;       /* target block device */
    blk_opf_t            bi_opf;        /* REQ_OP_* | req flags */
    unsigned short       bi_flags;      /* BIO_* status flags */
    unsigned short       bi_ioprio;     /* I/O priority */
    blk_status_t         bi_status;     /* completion status */
    struct bio_vec      *bi_io_vec;     /* scatter-gather list */
    struct bvec_iter     bi_iter;       /* current position iterator */
    bio_end_io_t        *bi_end_io;    /* completion callback */
    void                *bi_private;   /* caller private data */
    unsigned short       bi_vcnt;      /* number of bio_vecs */
    unsigned short       bi_max_vecs;  /* allocated bio_vecs */
};

#include <linux/bio.h>

struct bio_vec bvec;
struct bvec_iter iter;

bio_for_each_segment(bvec, bio, iter) {
    /*
     * bvec.bv_page   - the page holding this segment
     * bvec.bv_offset - byte offset within the page
     * bvec.bv_len    - byte length of this segment
     */
    void *kaddr = kmap_local_page(bvec.bv_page);
    do_something(kaddr + bvec.bv_offset, bvec.bv_len);
    kunmap_local(kaddr);
}

struct request {
    struct request_queue    *q;             /* owning queue */
    struct blk_mq_ctx       *mq_ctx;       /* software queue context */
    struct blk_mq_hw_ctx    *mq_hctx;     /* hardware queue context */
    blk_opf_t                cmd_flags;    /* REQ_OP_* | request flags */
    req_flags_t              rq_flags;     /* RQF_* internal flags */
    int                      tag;          /* hardware tag */
    int                      internal_tag; /* scheduler tag */
    unsigned int             timeout;      /* timeout in jiffies */
    unsigned int             __data_len;   /* total data length */
    sector_t                 __sector;     /* sector cursor */
    struct bio              *bio;          /* first bio */
    struct bio              *biotail;      /* last bio */
    struct block_device     *part;         /* target partition */
    u64                      start_time_ns;
    u64                      io_start_time_ns;
    unsigned short           nr_phys_segments;
    enum mq_rq_state         state;        /* MQ_RQ_IDLE/IN_FLIGHT/COMPLETE */
    rq_end_io_fn            *end_io;      /* completion callback */
    void                    *end_io_data;
};

/* Get operation */
enum req_op op = req_op(rq);
bool is_write   = op_is_write(req_op(rq));

/* Get position and size */
sector_t start  = blk_rq_pos(rq);
unsigned bytes  = blk_rq_bytes(rq);
unsigned sectors = blk_rq_sectors(rq);

/* DMA direction */
enum dma_data_direction dir = rq_dma_dir(rq); /* DMA_TO_DEVICE or DMA_FROM_DEVICE */

/* Access driver-private data appended to the request (cmd_size bytes) */
void *pdu = blk_mq_rq_to_pdu(rq);
struct request *rq = blk_mq_rq_from_pdu(pdu);

struct blk_mq_tag_set {
    const struct blk_mq_ops *ops;           /* driver callbacks */
    struct blk_mq_queue_map  map[HCTX_MAX_TYPES]; /* CPU→hctx mapping */
    unsigned int             nr_maps;       /* number of valid maps */
    unsigned int             nr_hw_queues;  /* hardware queue count */
    unsigned int             queue_depth;   /* tags per hw queue */
    unsigned int             reserved_tags; /* reserved for BLK_MQ_REQ_RESERVED */
    unsigned int             cmd_size;      /* extra bytes per request (driver PDU) */
    int                      numa_node;
    unsigned int             timeout;       /* request timeout (jiffies) */
    unsigned int             flags;         /* BLK_MQ_F_* */
    void                    *driver_data;
    struct blk_mq_tags     **tags;          /* per-hw-queue tag arrays */
};

/*
 * In queue_rq callback — mark request as in-flight:
 */
void blk_mq_start_request(struct request *rq);

/*
 * In the completion interrupt or poll callback — end the request:
 */
void blk_mq_end_request(struct request *rq, blk_status_t error);

/*
 * If completion runs on a different CPU and you want to run the
 * complete() callback on the issuing CPU:
 */
bool blk_mq_complete_request_remote(struct request *rq);

/* Typical queue_rq implementation: */
static blk_status_t my_queue_rq(struct blk_mq_hw_ctx *hctx,
                                 const struct blk_mq_queue_data *bd)
{
    struct request *rq = bd->rq;
    struct my_request_pdu *pdu = blk_mq_rq_to_pdu(rq);

    blk_mq_start_request(rq);

    /* Build and submit command to hardware */
    pdu->dma = dma_map_sg(&my_dev->pdev->dev,
                          rq->sg_table.sgl, rq->sg_table.nents,
                          rq_dma_dir(rq));
    my_hw_submit_command(my_dev, rq);
    return BLK_STS_OK;
}

/* In the completion interrupt: */
static void my_irq_complete(struct my_dev *dev, u32 tag)
{
    struct request *rq = blk_mq_tag_to_rq(dev->tags, tag);
    blk_mq_end_request(rq, BLK_STS_OK);
}

# Query available schedulers (current in brackets)
cat /sys/block/sda/queue/scheduler
# none mq-deadline kyber [bfq]

# Switch to mq-deadline
echo mq-deadline > /sys/block/sda/queue/scheduler

blk_queue_flag_set(QUEUE_FLAG_NO_SG_MERGE, disk->queue);
disk->queue->elevator_type = &mq_deadline_ops; /* set preferred scheduler */