direct-io: use bio set/get op accessors

This patch has the dio code use a REQ_OP for the op and rq_flag_bits
for bi_rw flags. To set/get the op it uses the bio_set_op_attrs/bio_op
accssors.

It also begins to convert btrfs's dio_submit_t because of the dio
submit_io callout use. The next patches will completely convert
this code and the reset of the btrfs code paths.

Signed-off-by: Mike Christie <mchristi@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 8b1212e8f7a8b65ddd96a38e7d57d534fdf75aff..348ad81903bd89546bc03f5a76b8197dbd3db285 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -8433,14 +8433,14 @@ out_err:
        return 0;
 }
 
-static void btrfs_submit_direct(int rw, struct bio *dio_bio,
-                               struct inode *inode, loff_t file_offset)
+static void btrfs_submit_direct(struct bio *dio_bio, struct inode *inode,
+                               loff_t file_offset)
 {
        struct btrfs_dio_private *dip = NULL;
        struct bio *io_bio = NULL;
        struct btrfs_io_bio *btrfs_bio;
        int skip_sum;
-       int write = rw & REQ_WRITE;
+       bool write = (bio_op(dio_bio) == REQ_OP_WRITE);
        int ret = 0;
 
        skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
@@ -8491,7 +8491,7 @@ static void btrfs_submit_direct(int rw, struct bio *dio_bio,
                        dio_data->unsubmitted_oe_range_end;
        }
 
-       ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
+       ret = btrfs_submit_direct_hook(dio_bio->bi_rw, dip, skip_sum);
        if (!ret)
                return;
 

diff --git a/fs/direct-io.c b/fs/direct-io.c
index 1bcdd5dde00d1a2b432e1a907a656a71b0760f8d..7c3ce73cb6170ee820aec560ece2fafc8b48b83c 100644 (file)
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -108,7 +108,8 @@ struct dio_submit {
 /* dio_state communicated between submission path and end_io */
 struct dio {
        int flags;                      /* doesn't change */
-       int rw;
+       int op;
+       int op_flags;
        blk_qc_t bio_cookie;
        struct block_device *bio_bdev;
        struct inode *inode;
@@ -163,7 +164,7 @@ static inline int dio_refill_pages(struct dio *dio, struct dio_submit *sdio)
        ret = iov_iter_get_pages(sdio->iter, dio->pages, LONG_MAX, DIO_PAGES,
                                &sdio->from);
 
-       if (ret < 0 && sdio->blocks_available && (dio->rw & WRITE)) {
+       if (ret < 0 && sdio->blocks_available && (dio->op == REQ_OP_WRITE)) {
                struct page *page = ZERO_PAGE(0);
                /*
                 * A memory fault, but the filesystem has some outstanding
@@ -242,7 +243,8 @@ static ssize_t dio_complete(struct dio *dio, ssize_t ret, bool is_async)
                transferred = dio->result;
 
                /* Check for short read case */
-               if ((dio->rw == READ) && ((offset + transferred) > dio->i_size))
+               if ((dio->op == REQ_OP_READ) &&
+                   ((offset + transferred) > dio->i_size))
                        transferred = dio->i_size - offset;
        }
 
@@ -273,7 +275,7 @@ static ssize_t dio_complete(struct dio *dio, ssize_t ret, bool is_async)
                 */
                dio->iocb->ki_pos += transferred;
 
-               if (dio->rw & WRITE)
+               if (dio->op == REQ_OP_WRITE)
                        ret = generic_write_sync(dio->iocb,  transferred);
                dio->iocb->ki_complete(dio->iocb, ret, 0);
        }
@@ -375,7 +377,7 @@ dio_bio_alloc(struct dio *dio, struct dio_submit *sdio,
 
        bio->bi_bdev = bdev;
        bio->bi_iter.bi_sector = first_sector;
-       bio->bi_rw = dio->rw;
+       bio_set_op_attrs(bio, dio->op, dio->op_flags);
        if (dio->is_async)
                bio->bi_end_io = dio_bio_end_aio;
        else
@@ -403,14 +405,13 @@ static inline void dio_bio_submit(struct dio *dio, struct dio_submit *sdio)
        dio->refcount++;
        spin_unlock_irqrestore(&dio->bio_lock, flags);
 
-       if (dio->is_async && dio->rw == READ && dio->should_dirty)
+       if (dio->is_async && dio->op == REQ_OP_READ && dio->should_dirty)
                bio_set_pages_dirty(bio);
 
        dio->bio_bdev = bio->bi_bdev;
 
        if (sdio->submit_io) {
-               sdio->submit_io(dio->rw, bio, dio->inode,
-                              sdio->logical_offset_in_bio);
+               sdio->submit_io(bio, dio->inode, sdio->logical_offset_in_bio);
                dio->bio_cookie = BLK_QC_T_NONE;
        } else
                dio->bio_cookie = submit_bio(bio);
@@ -479,14 +480,14 @@ static int dio_bio_complete(struct dio *dio, struct bio *bio)
        if (bio->bi_error)
                dio->io_error = -EIO;
 
-       if (dio->is_async && dio->rw == READ && dio->should_dirty) {
+       if (dio->is_async && dio->op == REQ_OP_READ && dio->should_dirty) {
                err = bio->bi_error;
                bio_check_pages_dirty(bio);     /* transfers ownership */
        } else {
                bio_for_each_segment_all(bvec, bio, i) {
                        struct page *page = bvec->bv_page;
 
-                       if (dio->rw == READ && !PageCompound(page) &&
+                       if (dio->op == REQ_OP_READ && !PageCompound(page) &&
                                        dio->should_dirty)
                                set_page_dirty_lock(page);
                        put_page(page);
@@ -639,7 +640,7 @@ static int get_more_blocks(struct dio *dio, struct dio_submit *sdio,
                 * which may decide to handle it or also return an unmapped
                 * buffer head.
                 */
-               create = dio->rw & WRITE;
+               create = dio->op == REQ_OP_WRITE;
                if (dio->flags & DIO_SKIP_HOLES) {
                        if (fs_startblk <= ((i_size_read(dio->inode) - 1) >>
                                                        i_blkbits))
@@ -789,7 +790,7 @@ submit_page_section(struct dio *dio, struct dio_submit *sdio, struct page *page,
 {
        int ret = 0;
 
-       if (dio->rw & WRITE) {
+       if (dio->op == REQ_OP_WRITE) {
                /*
                 * Read accounting is performed in submit_bio()
                 */
@@ -989,7 +990,7 @@ do_holes:
                                loff_t i_size_aligned;
 
                                /* AKPM: eargh, -ENOTBLK is a hack */
-                               if (dio->rw & WRITE) {
+                               if (dio->op == REQ_OP_WRITE) {
                                        put_page(page);
                                        return -ENOTBLK;
                                }
@@ -1203,7 +1204,12 @@ do_blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
                dio->is_async = true;
 
        dio->inode = inode;
-       dio->rw = iov_iter_rw(iter) == WRITE ? WRITE_ODIRECT : READ;
+       if (iov_iter_rw(iter) == WRITE) {
+               dio->op = REQ_OP_WRITE;
+               dio->op_flags = WRITE_ODIRECT;
+       } else {
+               dio->op = REQ_OP_READ;
+       }
 
        /*
         * For AIO O_(D)SYNC writes we need to defer completions to a workqueue

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 62ca2f9cad95951235bfda6f64181d7036129665..af6f3c7e4822ae7cc40cfdd1b48e4826e973392d 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2824,7 +2824,7 @@ extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
 
 #ifdef CONFIG_BLOCK
-typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
+typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
                            loff_t file_offset);
 
 enum {