GitHub-Mirror/linux-bl808
2
0
Fork 0
mirror of https://github.com/Fishwaldo/linux-bl808.git synced 2025-04-01 11:54:10 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

mm/block: convert rw_page users to bio op use

Browse source 
The rw_page users were not converted to use bio/req ops. As a result
bdev_write_page is not passing down REQ_OP_WRITE and the IOs will
be sent down as reads.

Signed-off-by: Mike Christie <mchristi@redhat.com>
Fixes: 4e1b2d52a8 ("block, fs, drivers: remove REQ_OP compat defs and related code")

Modified by me to:

1) Drop op_flags passing into ->rw_page(), as we don't use it.
2) Make op_is_write() and friends safe to use for !CONFIG_BLOCK

Signed-off-by: Jens Axboe <axboe@fb.com>
This commit is contained in:
Mike Christie 2016-08-04 14:23:34 -06:00 • committed by Jens Axboe
parent c1c87c2ba9
commit abf545484d
11 changed files with 60 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
drivers/block/brd.c
View file

@ -300,20 +300,20 @@ static void copy_from_brd(void *dst, struct brd_device *brd,
* Process a single bvec of a bio. * Process a single bvec of a bio.
*/ */
static int brd_do_bvec(struct brd_device *brd, struct page *page, static int brd_do_bvec(struct brd_device *brd, struct page *page,
unsigned int len, unsigned int off, int rw, unsigned int len, unsigned int off, int op,
sector_t sector) sector_t sector)
{ {
void *mem; void *mem;
int err = 0; int err = 0;
if (rw != READ) { if (op_is_write(op)) {
err = copy_to_brd_setup(brd, sector, len); err = copy_to_brd_setup(brd, sector, len);
if (err) if (err)
goto out; goto out;
} }
mem = kmap_atomic(page); mem = kmap_atomic(page);
if (rw == READ) { if (!op_is_write(op)) {
copy_from_brd(mem + off, brd, sector, len); copy_from_brd(mem + off, brd, sector, len);
flush_dcache_page(page); flush_dcache_page(page);
} else { } else {
@ -330,7 +330,6 @@ static blk_qc_t brd_make_request(struct request_queue *q, struct bio *bio)
{ {
struct block_device *bdev = bio->bi_bdev; struct block_device *bdev = bio->bi_bdev;
struct brd_device *brd = bdev->bd_disk->private_data; struct brd_device *brd = bdev->bd_disk->private_data;
int rw;
struct bio_vec bvec; struct bio_vec bvec;
sector_t sector; sector_t sector;
struct bvec_iter iter; struct bvec_iter iter;
@ -347,14 +346,12 @@ static blk_qc_t brd_make_request(struct request_queue *q, struct bio *bio)
goto out; goto out;
} }
rw = bio_data_dir(bio);
bio_for_each_segment(bvec, bio, iter) { bio_for_each_segment(bvec, bio, iter) {
unsigned int len = bvec.bv_len; unsigned int len = bvec.bv_len;
int err; int err;
err = brd_do_bvec(brd, bvec.bv_page, len, err = brd_do_bvec(brd, bvec.bv_page, len,
bvec.bv_offset, rw, sector); bvec.bv_offset, bio_op(bio), sector);
if (err) if (err)
goto io_error; goto io_error;
sector += len >> SECTOR_SHIFT; sector += len >> SECTOR_SHIFT;
@ -369,11 +366,11 @@ io_error:
} }
static int brd_rw_page(struct block_device *bdev, sector_t sector, static int brd_rw_page(struct block_device *bdev, sector_t sector,
struct page *page, int rw) struct page *page, int op)
{ {
struct brd_device *brd = bdev->bd_disk->private_data; struct brd_device *brd = bdev->bd_disk->private_data;
int err = brd_do_bvec(brd, page, PAGE_SIZE, 0, rw, sector); int err = brd_do_bvec(brd, page, PAGE_SIZE, 0, op, sector);
page_endio(page, rw & WRITE, err); page_endio(page, op, err);
return err; return err;
} }

28
drivers/block/zram/zram_drv.c
View file

@ -843,15 +843,15 @@ static void zram_bio_discard(struct zram *zram, u32 index,
} }
static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index, static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
int offset, int rw) int offset, int op)
{ {
unsigned long start_time = jiffies; unsigned long start_time = jiffies;
int ret; int ret;
generic_start_io_acct(rw, bvec->bv_len >> SECTOR_SHIFT, generic_start_io_acct(op, bvec->bv_len >> SECTOR_SHIFT,
&zram->disk->part0); &zram->disk->part0);
if (rw == READ) { if (!op_is_write(op)) {
atomic64_inc(&zram->stats.num_reads); atomic64_inc(&zram->stats.num_reads);
ret = zram_bvec_read(zram, bvec, index, offset); ret = zram_bvec_read(zram, bvec, index, offset);
} else { } else {
@ -859,10 +859,10 @@ static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
ret = zram_bvec_write(zram, bvec, index, offset); ret = zram_bvec_write(zram, bvec, index, offset);
} }
generic_end_io_acct(rw, &zram->disk->part0, start_time); generic_end_io_acct(op, &zram->disk->part0, start_time);
if (unlikely(ret)) { if (unlikely(ret)) {
if (rw == READ) if (!op_is_write(op))
atomic64_inc(&zram->stats.failed_reads); atomic64_inc(&zram->stats.failed_reads);
else else
atomic64_inc(&zram->stats.failed_writes); atomic64_inc(&zram->stats.failed_writes);
@ -873,7 +873,7 @@ static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
static void __zram_make_request(struct zram *zram, struct bio *bio) static void __zram_make_request(struct zram *zram, struct bio *bio)
{ {
int offset, rw; int offset;
u32 index; u32 index;
struct bio_vec bvec; struct bio_vec bvec;
struct bvec_iter iter; struct bvec_iter iter;
@ -888,7 +888,6 @@ static void __zram_make_request(struct zram *zram, struct bio *bio)
return; return;
} }
rw = bio_data_dir(bio);
bio_for_each_segment(bvec, bio, iter) { bio_for_each_segment(bvec, bio, iter) {
int max_transfer_size = PAGE_SIZE - offset; int max_transfer_size = PAGE_SIZE - offset;
@ -903,15 +902,18 @@ static void __zram_make_request(struct zram *zram, struct bio *bio)
bv.bv_len = max_transfer_size; bv.bv_len = max_transfer_size;
bv.bv_offset = bvec.bv_offset; bv.bv_offset = bvec.bv_offset;
if (zram_bvec_rw(zram, &bv, index, offset, rw) < 0) if (zram_bvec_rw(zram, &bv, index, offset,
bio_op(bio)) < 0)
goto out; goto out;
bv.bv_len = bvec.bv_len - max_transfer_size; bv.bv_len = bvec.bv_len - max_transfer_size;
bv.bv_offset += max_transfer_size; bv.bv_offset += max_transfer_size;
if (zram_bvec_rw(zram, &bv, index + 1, 0, rw) < 0) if (zram_bvec_rw(zram, &bv, index + 1, 0,
bio_op(bio)) < 0)
goto out; goto out;
} else } else
if (zram_bvec_rw(zram, &bvec, index, offset, rw) < 0) if (zram_bvec_rw(zram, &bvec, index, offset,
bio_op(bio)) < 0)
goto out; goto out;
update_position(&index, &offset, &bvec); update_position(&index, &offset, &bvec);
@ -968,7 +970,7 @@ static void zram_slot_free_notify(struct block_device *bdev,
} }
static int zram_rw_page(struct block_device *bdev, sector_t sector, static int zram_rw_page(struct block_device *bdev, sector_t sector,
struct page *page, int rw) struct page *page, int op)
{ {
int offset, err = -EIO; int offset, err = -EIO;
u32 index; u32 index;
@ -992,7 +994,7 @@ static int zram_rw_page(struct block_device *bdev, sector_t sector,
bv.bv_len = PAGE_SIZE; bv.bv_len = PAGE_SIZE;
bv.bv_offset = 0; bv.bv_offset = 0;
err = zram_bvec_rw(zram, &bv, index, offset, rw); err = zram_bvec_rw(zram, &bv, index, offset, op);
put_zram: put_zram:
zram_meta_put(zram); zram_meta_put(zram);
out: out:
@ -1005,7 +1007,7 @@ out:
* (e.g., SetPageError, set_page_dirty and extra works). * (e.g., SetPageError, set_page_dirty and extra works).
*/ */
if (err == 0) if (err == 0)
page_endio(page, rw, 0); page_endio(page, op, 0);
return err; return err;
} }

18
drivers/nvdimm/btt.c
View file

@ -1133,11 +1133,11 @@ static int btt_write_pg(struct btt *btt, struct bio_integrity_payload *bip,
static int btt_do_bvec(struct btt *btt, struct bio_integrity_payload *bip, static int btt_do_bvec(struct btt *btt, struct bio_integrity_payload *bip,
struct page *page, unsigned int len, unsigned int off, struct page *page, unsigned int len, unsigned int off,
int rw, sector_t sector) int op, sector_t sector)
{ {
int ret; int ret;
if (rw == READ) { if (!op_is_write(op)) {
ret = btt_read_pg(btt, bip, page, off, sector, len); ret = btt_read_pg(btt, bip, page, off, sector, len);
flush_dcache_page(page); flush_dcache_page(page);
} else { } else {
@ -1155,7 +1155,7 @@ static blk_qc_t btt_make_request(struct request_queue *q, struct bio *bio)
struct bvec_iter iter; struct bvec_iter iter;
unsigned long start; unsigned long start;
struct bio_vec bvec; struct bio_vec bvec;
int err = 0, rw; int err = 0;
bool do_acct; bool do_acct;
/* /*
@ -1170,7 +1170,6 @@ static blk_qc_t btt_make_request(struct request_queue *q, struct bio *bio)
} }
do_acct = nd_iostat_start(bio, &start); do_acct = nd_iostat_start(bio, &start);
rw = bio_data_dir(bio);
bio_for_each_segment(bvec, bio, iter) { bio_for_each_segment(bvec, bio, iter) {
unsigned int len = bvec.bv_len; unsigned int len = bvec.bv_len;
@ -1181,11 +1180,12 @@ static blk_qc_t btt_make_request(struct request_queue *q, struct bio *bio)
BUG_ON(len % btt->sector_size); BUG_ON(len % btt->sector_size);
err = btt_do_bvec(btt, bip, bvec.bv_page, len, bvec.bv_offset, err = btt_do_bvec(btt, bip, bvec.bv_page, len, bvec.bv_offset,
rw, iter.bi_sector); bio_op(bio), iter.bi_sector);
if (err) { if (err) {
dev_info(&btt->nd_btt->dev, dev_info(&btt->nd_btt->dev,
"io error in %s sector %lld, len %d,\n", "io error in %s sector %lld, len %d,\n",
(rw == READ) ? "READ" : "WRITE", (op_is_write(bio_op(bio))) ? "WRITE" :
"READ",
(unsigned long long) iter.bi_sector, len); (unsigned long long) iter.bi_sector, len);
bio->bi_error = err; bio->bi_error = err;
break; break;
@ -1200,12 +1200,12 @@ out:
} }
static int btt_rw_page(struct block_device *bdev, sector_t sector, static int btt_rw_page(struct block_device *bdev, sector_t sector,
struct page *page, int rw) struct page *page, int op)
{ {
struct btt *btt = bdev->bd_disk->private_data; struct btt *btt = bdev->bd_disk->private_data;
btt_do_bvec(btt, NULL, page, PAGE_SIZE, 0, rw, sector); btt_do_bvec(btt, NULL, page, PAGE_SIZE, 0, op, sector);
page_endio(page, rw & WRITE, 0); page_endio(page, op, 0);
return 0; return 0;
} }

12
drivers/nvdimm/pmem.c
View file

@ -67,7 +67,7 @@ static void pmem_clear_poison(struct pmem_device *pmem, phys_addr_t offset,
} }
static int pmem_do_bvec(struct pmem_device *pmem, struct page *page, static int pmem_do_bvec(struct pmem_device *pmem, struct page *page,
unsigned int len, unsigned int off, int rw, unsigned int len, unsigned int off, int op,
sector_t sector) sector_t sector)
{ {
int rc = 0; int rc = 0;
@ -79,7 +79,7 @@ static int pmem_do_bvec(struct pmem_device *pmem, struct page *page,
if (unlikely(is_bad_pmem(&pmem->bb, sector, len))) if (unlikely(is_bad_pmem(&pmem->bb, sector, len)))
bad_pmem = true; bad_pmem = true;
if (rw == READ) { if (!op_is_write(op)) {
if (unlikely(bad_pmem)) if (unlikely(bad_pmem))
rc = -EIO; rc = -EIO;
else { else {
@ -134,7 +134,7 @@ static blk_qc_t pmem_make_request(struct request_queue *q, struct bio *bio)
do_acct = nd_iostat_start(bio, &start); do_acct = nd_iostat_start(bio, &start);
bio_for_each_segment(bvec, bio, iter) { bio_for_each_segment(bvec, bio, iter) {
rc = pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len, rc = pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len,
bvec.bv_offset, bio_data_dir(bio), bvec.bv_offset, bio_op(bio),
iter.bi_sector); iter.bi_sector);
if (rc) { if (rc) {
bio->bi_error = rc; bio->bi_error = rc;
@ -152,12 +152,12 @@ static blk_qc_t pmem_make_request(struct request_queue *q, struct bio *bio)
} }
static int pmem_rw_page(struct block_device *bdev, sector_t sector, static int pmem_rw_page(struct block_device *bdev, sector_t sector,
struct page *page, int rw) struct page *page, int op)
{ {
struct pmem_device *pmem = bdev->bd_queue->queuedata; struct pmem_device *pmem = bdev->bd_queue->queuedata;
int rc; int rc;
rc = pmem_do_bvec(pmem, page, PAGE_SIZE, 0, rw, sector); rc = pmem_do_bvec(pmem, page, PAGE_SIZE, 0, op, sector);
/* /*
* The ->rw_page interface is subtle and tricky. The core * The ->rw_page interface is subtle and tricky. The core
@ -166,7 +166,7 @@ static int pmem_rw_page(struct block_device *bdev, sector_t sector,
* caused by double completion. * caused by double completion.
*/ */
if (rc == 0) if (rc == 0)
page_endio(page, rw & WRITE, 0); page_endio(page, op, 0);
return rc; return rc;
} }

7
fs/block_dev.c
View file

@ -416,7 +416,8 @@ int bdev_read_page(struct block_device *bdev, sector_t sector,
result = blk_queue_enter(bdev->bd_queue, false); result = blk_queue_enter(bdev->bd_queue, false);
if (result) if (result)
return result; return result;
result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, READ); result = ops->rw_page(bdev, sector + get_start_sect(bdev), page,
REQ_OP_READ);
blk_queue_exit(bdev->bd_queue); blk_queue_exit(bdev->bd_queue);
return result; return result;
} }
@ -445,7 +446,6 @@ int bdev_write_page(struct block_device *bdev, sector_t sector,
struct page *page, struct writeback_control *wbc) struct page *page, struct writeback_control *wbc)
{ {
int result; int result;
int rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE;
const struct block_device_operations *ops = bdev->bd_disk->fops; const struct block_device_operations *ops = bdev->bd_disk->fops;
if (!ops->rw_page || bdev_get_integrity(bdev)) if (!ops->rw_page || bdev_get_integrity(bdev))
@ -455,7 +455,8 @@ int bdev_write_page(struct block_device *bdev, sector_t sector,
return result; return result;
set_page_writeback(page); set_page_writeback(page);
result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, rw); result = ops->rw_page(bdev, sector + get_start_sect(bdev), page,
REQ_OP_WRITE);
if (result) if (result)
end_page_writeback(page); end_page_writeback(page);
else else

2
fs/mpage.c
View file

@ -50,7 +50,7 @@ static void mpage_end_io(struct bio *bio)
bio_for_each_segment_all(bv, bio, i) { bio_for_each_segment_all(bv, bio, i) {
struct page *page = bv->bv_page; struct page *page = bv->bv_page;
page_endio(page, bio_data_dir(bio), bio->bi_error); page_endio(page, bio_op(bio), bio->bi_error);
} }
bio_put(bio); bio_put(bio);

22
include/linux/blk_types.h
View file

@ -18,6 +18,17 @@ struct cgroup_subsys_state;
typedef void (bio_end_io_t) (struct bio *); typedef void (bio_end_io_t) (struct bio *);
typedef void (bio_destructor_t) (struct bio *); typedef void (bio_destructor_t) (struct bio *);
enum req_op {
REQ_OP_READ,
REQ_OP_WRITE,
REQ_OP_DISCARD, /* request to discard sectors */
REQ_OP_SECURE_ERASE, /* request to securely erase sectors */
REQ_OP_WRITE_SAME, /* write same block many times */
REQ_OP_FLUSH, /* request for cache flush */
};
#define REQ_OP_BITS 3
#ifdef CONFIG_BLOCK #ifdef CONFIG_BLOCK
/* /*
* main unit of I/O for the block layer and lower layers (ie drivers and * main unit of I/O for the block layer and lower layers (ie drivers and
@ -228,17 +239,6 @@ enum rq_flag_bits {
#define REQ_HASHED (1ULL << __REQ_HASHED) #define REQ_HASHED (1ULL << __REQ_HASHED)
#define REQ_MQ_INFLIGHT (1ULL << __REQ_MQ_INFLIGHT) #define REQ_MQ_INFLIGHT (1ULL << __REQ_MQ_INFLIGHT)
enum req_op {
REQ_OP_READ,
REQ_OP_WRITE,
REQ_OP_DISCARD, /* request to discard sectors */
REQ_OP_SECURE_ERASE, /* request to securely erase sectors */
REQ_OP_WRITE_SAME, /* write same block many times */
REQ_OP_FLUSH, /* request for cache flush */
};
#define REQ_OP_BITS 3
typedef unsigned int blk_qc_t; typedef unsigned int blk_qc_t;
#define BLK_QC_T_NONE -1U #define BLK_QC_T_NONE -1U
#define BLK_QC_T_SHIFT 16 #define BLK_QC_T_SHIFT 16

2
include/linux/blkdev.h
View file

@ -1672,7 +1672,7 @@ struct blk_dax_ctl {
struct block_device_operations { struct block_device_operations {
int (*open) (struct block_device *, fmode_t); int (*open) (struct block_device *, fmode_t);
void (*release) (struct gendisk *, fmode_t); void (*release) (struct gendisk *, fmode_t);
int (*rw_page)(struct block_device *, sector_t, struct page *, int rw); int (*rw_page)(struct block_device *, sector_t, struct page *, int op);
int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
long (*direct_access)(struct block_device *, sector_t, void **, pfn_t *, long (*direct_access)(struct block_device *, sector_t, void **, pfn_t *,

3
include/linux/fs.h
View file

@ -2480,12 +2480,13 @@ extern void init_special_inode(struct inode *, umode_t, dev_t);
extern void make_bad_inode(struct inode *); extern void make_bad_inode(struct inode *);
extern bool is_bad_inode(struct inode *); extern bool is_bad_inode(struct inode *);
#ifdef CONFIG_BLOCK
static inline bool op_is_write(unsigned int op) static inline bool op_is_write(unsigned int op)
{ {
return op == REQ_OP_READ ? false : true; return op == REQ_OP_READ ? false : true;
} }
#ifdef CONFIG_BLOCK
/* /*
* return data direction, READ or WRITE * return data direction, READ or WRITE
*/ */

2
include/linux/pagemap.h
View file

@ -510,7 +510,7 @@ static inline void wait_on_page_writeback(struct page *page)
extern void end_page_writeback(struct page *page); extern void end_page_writeback(struct page *page);
void wait_for_stable_page(struct page *page); void wait_for_stable_page(struct page *page);
void page_endio(struct page *page, int rw, int err); void page_endio(struct page *page, int op, int err);
/* /*
* Add an arbitrary waiter to a page's wait queue * Add an arbitrary waiter to a page's wait queue

6
mm/filemap.c
View file

@ -887,9 +887,9 @@ EXPORT_SYMBOL(end_page_writeback);
* After completing I/O on a page, call this routine to update the page * After completing I/O on a page, call this routine to update the page
* flags appropriately * flags appropriately
*/ */
void page_endio(struct page *page, int rw, int err) void page_endio(struct page *page, int op, int err)
{ {
if (rw == READ) { if (!op_is_write(op)) {
if (!err) { if (!err) {
SetPageUptodate(page); SetPageUptodate(page);
} else { } else {
@ -897,7 +897,7 @@ void page_endio(struct page *page, int rw, int err)
SetPageError(page); SetPageError(page);
} }
unlock_page(page); unlock_page(page);
} else { /* rw == WRITE */ } else {
if (err) { if (err) {
SetPageError(page); SetPageError(page);
if (page->mapping) if (page->mapping)