Merge branch 'for-linus-4.8' of git://git.kernel.org/pub/scm/linux/kernel/git/mason...

[sfrench/cifs-2.6.git] / fs / btrfs / disk-io.c

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index ff2362dca91aa92ef77c719f911283456a04d1ad..87dad552e39ae13ea2533c4a5718a5af635bcbee 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -124,7 +124,6 @@ struct async_submit_bio {
        struct list_head list;
        extent_submit_bio_hook_t *submit_bio_start;
        extent_submit_bio_hook_t *submit_bio_done;
        struct list_head list;
        extent_submit_bio_hook_t *submit_bio_start;
        extent_submit_bio_hook_t *submit_bio_done;

-       int rw;

        int mirror_num;
        unsigned long bio_flags;
        /*
        int mirror_num;
        unsigned long bio_flags;
        /*


@@ -727,7 +726,7 @@ static void end_workqueue_bio(struct bio *bio)
        fs_info = end_io_wq->info;
        end_io_wq->error = bio->bi_error;
 
        fs_info = end_io_wq->info;
        end_io_wq->error = bio->bi_error;
 

-       if (bio->bi_rw & REQ_WRITE) {
+       if (bio_op(bio) == REQ_OP_WRITE) {

                if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA) {
                        wq = fs_info->endio_meta_write_workers;
                        func = btrfs_endio_meta_write_helper;
                if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA) {
                        wq = fs_info->endio_meta_write_workers;
                        func = btrfs_endio_meta_write_helper;


@@ -797,7 +796,7 @@ static void run_one_async_start(struct btrfs_work *work)
        int ret;
 
        async = container_of(work, struct  async_submit_bio, work);
        int ret;
 
        async = container_of(work, struct  async_submit_bio, work);

-       ret = async->submit_bio_start(async->inode, async->rw, async->bio,
+       ret = async->submit_bio_start(async->inode, async->bio,

                                      async->mirror_num, async->bio_flags,
                                      async->bio_offset);
        if (ret)
                                      async->mirror_num, async->bio_flags,
                                      async->bio_offset);
        if (ret)


@@ -830,9 +829,8 @@ static void run_one_async_done(struct btrfs_work *work)
                return;
        }
 
                return;
        }
 

-       async->submit_bio_done(async->inode, async->rw, async->bio,
-                              async->mirror_num, async->bio_flags,
-                              async->bio_offset);
+       async->submit_bio_done(async->inode, async->bio, async->mirror_num,
+                              async->bio_flags, async->bio_offset);

 }
 
 static void run_one_async_free(struct btrfs_work *work)
 }
 
 static void run_one_async_free(struct btrfs_work *work)


@@ -844,7 +842,7 @@ static void run_one_async_free(struct btrfs_work *work)
 }
 
 int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
 }
 
 int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,

-                       int rw, struct bio *bio, int mirror_num,
+                       struct bio *bio, int mirror_num,

                        unsigned long bio_flags,
                        u64 bio_offset,
                        extent_submit_bio_hook_t *submit_bio_start,
                        unsigned long bio_flags,
                        u64 bio_offset,
                        extent_submit_bio_hook_t *submit_bio_start,


@@ -857,7 +855,6 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
                return -ENOMEM;
 
        async->inode = inode;
                return -ENOMEM;
 
        async->inode = inode;

-       async->rw = rw;

        async->bio = bio;
        async->mirror_num = mirror_num;
        async->submit_bio_start = submit_bio_start;
        async->bio = bio;
        async->mirror_num = mirror_num;
        async->submit_bio_start = submit_bio_start;


@@ -873,7 +870,7 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
 
        atomic_inc(&fs_info->nr_async_submits);
 
 
        atomic_inc(&fs_info->nr_async_submits);
 

-       if (rw & REQ_SYNC)
+       if (bio->bi_rw & REQ_SYNC)

                btrfs_set_work_high_priority(&async->work);
 
        btrfs_queue_work(fs_info->workers, &async->work);
                btrfs_set_work_high_priority(&async->work);
 
        btrfs_queue_work(fs_info->workers, &async->work);


@@ -903,9 +900,8 @@ static int btree_csum_one_bio(struct bio *bio)
        return ret;
 }
 
        return ret;
 }
 

-static int __btree_submit_bio_start(struct inode *inode, int rw,
-                                   struct bio *bio, int mirror_num,
-                                   unsigned long bio_flags,
+static int __btree_submit_bio_start(struct inode *inode, struct bio *bio,
+                                   int mirror_num, unsigned long bio_flags,

                                    u64 bio_offset)
 {
        /*
                                    u64 bio_offset)
 {
        /*


@@ -915,7 +911,7 @@ static int __btree_submit_bio_start(struct inode *inode, int rw,
        return btree_csum_one_bio(bio);
 }
 
        return btree_csum_one_bio(bio);
 }
 

-static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
+static int __btree_submit_bio_done(struct inode *inode, struct bio *bio,

                                 int mirror_num, unsigned long bio_flags,
                                 u64 bio_offset)
 {
                                 int mirror_num, unsigned long bio_flags,
                                 u64 bio_offset)
 {


@@ -925,7 +921,7 @@ static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
         * when we're called for a write, we're already in the async
         * submission context.  Just jump into btrfs_map_bio
         */
         * when we're called for a write, we're already in the async
         * submission context.  Just jump into btrfs_map_bio
         */

-       ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
+       ret = btrfs_map_bio(BTRFS_I(inode)->root, bio, mirror_num, 1);

        if (ret) {
                bio->bi_error = ret;
                bio_endio(bio);
        if (ret) {
                bio->bi_error = ret;
                bio_endio(bio);


@@ -944,14 +940,14 @@ static int check_async_write(struct inode *inode, unsigned long bio_flags)
        return 1;
 }
 
        return 1;
 }
 

-static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
+static int btree_submit_bio_hook(struct inode *inode, struct bio *bio,

                                 int mirror_num, unsigned long bio_flags,
                                 u64 bio_offset)
 {
        int async = check_async_write(inode, bio_flags);
        int ret;
 
                                 int mirror_num, unsigned long bio_flags,
                                 u64 bio_offset)
 {
        int async = check_async_write(inode, bio_flags);
        int ret;
 

-       if (!(rw & REQ_WRITE)) {
+       if (bio_op(bio) != REQ_OP_WRITE) {

                /*
                 * called for a read, do the setup so that checksum validation
                 * can happen in the async kernel threads
                /*
                 * called for a read, do the setup so that checksum validation
                 * can happen in the async kernel threads


@@ -960,21 +956,19 @@ static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
                                          bio, BTRFS_WQ_ENDIO_METADATA);
                if (ret)
                        goto out_w_error;
                                          bio, BTRFS_WQ_ENDIO_METADATA);
                if (ret)
                        goto out_w_error;

-               ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
-                                   mirror_num, 0);
+               ret = btrfs_map_bio(BTRFS_I(inode)->root, bio, mirror_num, 0);

        } else if (!async) {
                ret = btree_csum_one_bio(bio);
                if (ret)
                        goto out_w_error;
        } else if (!async) {
                ret = btree_csum_one_bio(bio);
                if (ret)
                        goto out_w_error;

-               ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
-                                   mirror_num, 0);
+               ret = btrfs_map_bio(BTRFS_I(inode)->root, bio, mirror_num, 0);

        } else {
                /*
                 * kthread helpers are used to submit writes so that
                 * checksumming can happen in parallel across all CPUs
                 */
                ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
        } else {
                /*
                 * kthread helpers are used to submit writes so that
                 * checksumming can happen in parallel across all CPUs
                 */
                ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,

-                                         inode, rw, bio, mirror_num, 0,
+                                         inode, bio, mirror_num, 0,

                                          bio_offset,
                                          __btree_submit_bio_start,
                                          __btree_submit_bio_done);
                                          bio_offset,
                                          __btree_submit_bio_start,
                                          __btree_submit_bio_done);


@@ -3425,9 +3419,9 @@ static int write_dev_supers(struct btrfs_device *device,
                 * to go down lazy.
                 */
                if (i == 0)
                 * to go down lazy.
                 */
                if (i == 0)

-                       ret = btrfsic_submit_bh(WRITE_FUA, bh);
+                       ret = btrfsic_submit_bh(REQ_OP_WRITE, WRITE_FUA, bh);

                else
                else

-                       ret = btrfsic_submit_bh(WRITE_SYNC, bh);
+                       ret = btrfsic_submit_bh(REQ_OP_WRITE, WRITE_SYNC, bh);

                if (ret)
                        errors++;
        }
                if (ret)
                        errors++;
        }


@@ -3491,12 +3485,13 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
 
        bio->bi_end_io = btrfs_end_empty_barrier;
        bio->bi_bdev = device->bdev;
 
        bio->bi_end_io = btrfs_end_empty_barrier;
        bio->bi_bdev = device->bdev;

+       bio_set_op_attrs(bio, REQ_OP_WRITE, WRITE_FLUSH);

        init_completion(&device->flush_wait);
        bio->bi_private = &device->flush_wait;
        device->flush_bio = bio;
 
        bio_get(bio);
        init_completion(&device->flush_wait);
        bio->bi_private = &device->flush_wait;
        device->flush_bio = bio;
 
        bio_get(bio);

-       btrfsic_submit_bio(WRITE_FLUSH, bio);
+       btrfsic_submit_bio(bio);

 
        return 0;
 }
 
        return 0;
 }