/**
* Create a copy of a write bio.
*/
struct bio* bio_deep_clone(struct bio *bio, gfp_t gfp_mask)
{
uint size;
struct bio *clone;
ASSERT(bio);
ASSERT(op_is_write(bio_op(bio)));
ASSERT(!bio->bi_next);
if (bio_has_data(bio))
size = bio->bi_iter.bi_size;
else
size = 0;
clone = bio_alloc_with_pages(size, bio->bi_bdev, gfp_mask);
if (!clone)
return NULL;
clone->bi_opf = bio->bi_opf;
clone->bi_iter.bi_sector = bio->bi_iter.bi_sector;
if (size == 0) {
/* This is for discard IOs. */
clone->bi_iter.bi_size = bio->bi_iter.bi_size;
} else {
bio_copy_data(clone, bio);
}
return clone;
}
/*
* I/O completion handler for multipage BIOs.
*
* The mpage code never puts partial pages into a BIO (except for end-of-file).
* If a page does not map to a contiguous run of blocks then it simply falls
* back to block_read_full_page().
*
* Why is this? If a page's completion depends on a number of different BIOs
* which can complete in any order (or at the same time) then determining the
* status of that page is hard. See end_buffer_async_read() for the details.
* There is no point in duplicating all that complexity.
*/
static void mpage_end_io(struct bio *bio)
{
struct bio_vec *bv;
int i;
bio_for_each_segment_all(bv, bio, i) {
struct page *page = bv->bv_page;
page_endio(page, bio_op(bio), bio->bi_error);
}
bio_put(bio);
}
static struct bio *
bl_submit_bio(struct bio *bio)
{
if (bio) {
get_parallel(bio->bi_private);
dprintk("%s submitting %s bio %u@%llu\n", __func__,
bio_op(bio) == READ ? "read" : "write",
bio->bi_iter.bi_size,
(unsigned long long)bio->bi_iter.bi_sector);
submit_bio(bio);
}
return NULL;
}
static blk_qc_t pmem_make_request(struct request_queue *q, struct bio *bio)
{
blk_status_t rc = 0;
bool do_acct;
unsigned long start;
struct bio_vec bvec;
struct bvec_iter iter;
struct pmem_device *pmem = q->queuedata;
struct nd_region *nd_region = to_region(pmem);
if (bio->bi_opf & REQ_PREFLUSH)
nvdimm_flush(nd_region);
do_acct = nd_iostat_start(bio, &start);
bio_for_each_segment(bvec, bio, iter) {
rc = pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len,
bvec.bv_offset, bio_op(bio), iter.bi_sector);
if (rc) {
bio->bi_status = rc;
break;
}
}
/*
* Return zeros only on reads
*/
static int zero_map(struct dm_target *ti, struct bio *bio)
{
switch (bio_op(bio)) {
case REQ_OP_READ:
if (bio->bi_rw & REQ_RAHEAD) {
/* readahead of null bytes only wastes buffer cache */
return -EIO;
}
zero_fill_bio(bio);
break;
case REQ_OP_WRITE:
/* writes get silently dropped */
break;
default:
return -EIO;
}
bio_endio(bio);
/* accepted bio, don't make new request */
return DM_MAPIO_SUBMITTED;
}
static blk_qc_t pblk_make_rq(struct request_queue *q, struct bio *bio)
{
struct pblk *pblk = q->queuedata;
if (bio_op(bio) == REQ_OP_DISCARD) {
pblk_discard(pblk, bio);
if (!(bio->bi_opf & REQ_PREFLUSH)) {
bio_endio(bio);
return BLK_QC_T_NONE;
}
}
switch (pblk_rw_io(q, pblk, bio)) {
case NVM_IO_ERR:
bio_io_error(bio);
break;
case NVM_IO_DONE:
bio_endio(bio);
break;
}
return BLK_QC_T_NONE;
}
