Merge branch 'for-4.13-part1' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave...

[linux-2.6-block.git] / fs / btrfs / check-integrity.c

diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 4ded1c3f92b8b6de1c0eacbba7829a269d18bdff..11d37c94ce058b6c7f09bfb1a546038b85977eb0 100644 (file)
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -94,7 +94,7 @@
 #include <linux/mutex.h>
 #include <linux/genhd.h>
 #include <linux/blkdev.h>
-#include <linux/vmalloc.h>
+#include <linux/mm.h>
 #include <linux/string.h>
 #include "ctree.h"
 #include "disk-io.h"
@@ -1638,12 +1638,7 @@ static int btrfsic_read_block(struct btrfsic_state *state,
                struct bio *bio;
                unsigned int j;
 
-               bio = btrfs_io_bio_alloc(GFP_NOFS, num_pages - i);
-               if (!bio) {
-                       pr_info("btrfsic: bio_alloc() for %u pages failed!\n",
-                              num_pages - i);
-                       return -1;
-               }
+               bio = btrfs_io_bio_alloc(num_pages - i);
                bio->bi_bdev = block_ctx->dev->bdev;
                bio->bi_iter.bi_sector = dev_bytenr >> 9;
                bio_set_op_attrs(bio, REQ_OP_READ, 0);
@@ -1668,14 +1663,8 @@ static int btrfsic_read_block(struct btrfsic_state *state,
                dev_bytenr += (j - i) * PAGE_SIZE;
                i = j;
        }
-       for (i = 0; i < num_pages; i++) {
+       for (i = 0; i < num_pages; i++)
                block_ctx->datav[i] = kmap(block_ctx->pagev[i]);
-               if (!block_ctx->datav[i]) {
-                       pr_info("btrfsic: kmap() failed (dev %s)!\n",
-                              block_ctx->dev->name);
-                       return -1;
-               }
-       }
 
        return block_ctx->len;
 }
@@ -2822,44 +2811,47 @@ static void __btrfsic_submit_bio(struct bio *bio)
        dev_state = btrfsic_dev_state_lookup(bio->bi_bdev);
        if (NULL != dev_state &&
            (bio_op(bio) == REQ_OP_WRITE) && bio_has_data(bio)) {
-               unsigned int i;
+               unsigned int i = 0;
                u64 dev_bytenr;
                u64 cur_bytenr;
-               struct bio_vec *bvec;
+               struct bio_vec bvec;
+               struct bvec_iter iter;
                int bio_is_patched;
                char **mapped_datav;
+               unsigned int segs = bio_segments(bio);
 
                dev_bytenr = 512 * bio->bi_iter.bi_sector;
                bio_is_patched = 0;
                if (dev_state->state->print_mask &
                    BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
                        pr_info("submit_bio(rw=%d,0x%x, bi_vcnt=%u, bi_sector=%llu (bytenr %llu), bi_bdev=%p)\n",
-                              bio_op(bio), bio->bi_opf, bio->bi_vcnt,
+                              bio_op(bio), bio->bi_opf, segs,
                               (unsigned long long)bio->bi_iter.bi_sector,
                               dev_bytenr, bio->bi_bdev);
 
-               mapped_datav = kmalloc_array(bio->bi_vcnt,
+               mapped_datav = kmalloc_array(segs,
                                             sizeof(*mapped_datav), GFP_NOFS);
                if (!mapped_datav)
                        goto leave;
                cur_bytenr = dev_bytenr;
 
-               bio_for_each_segment_all(bvec, bio, i) {
-                       BUG_ON(bvec->bv_len != PAGE_SIZE);
-                       mapped_datav[i] = kmap(bvec->bv_page);
+               bio_for_each_segment(bvec, bio, iter) {
+                       BUG_ON(bvec.bv_len != PAGE_SIZE);
+                       mapped_datav[i] = kmap(bvec.bv_page);
+                       i++;
 
                        if (dev_state->state->print_mask &
                            BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH_VERBOSE)
                                pr_info("#%u: bytenr=%llu, len=%u, offset=%u\n",
-                                      i, cur_bytenr, bvec->bv_len, bvec->bv_offset);
-                       cur_bytenr += bvec->bv_len;
+                                      i, cur_bytenr, bvec.bv_len, bvec.bv_offset);
+                       cur_bytenr += bvec.bv_len;
                }
                btrfsic_process_written_block(dev_state, dev_bytenr,
-                                             mapped_datav, bio->bi_vcnt,
+                                             mapped_datav, segs,
                                              bio, &bio_is_patched,
                                              NULL, bio->bi_opf);
-               bio_for_each_segment_all(bvec, bio, i)
-                       kunmap(bvec->bv_page);
+               bio_for_each_segment(bvec, bio, iter)
+                       kunmap(bvec.bv_page);
                kfree(mapped_datav);
        } else if (NULL != dev_state && (bio->bi_opf & REQ_PREFLUSH)) {
                if (dev_state->state->print_mask &
@@ -2923,13 +2915,10 @@ int btrfsic_mount(struct btrfs_fs_info *fs_info,
                       fs_info->sectorsize, PAGE_SIZE);
                return -1;
        }
-       state = kzalloc(sizeof(*state), GFP_KERNEL | __GFP_NOWARN | __GFP_REPEAT);
+       state = kvzalloc(sizeof(*state), GFP_KERNEL);
        if (!state) {
-               state = vzalloc(sizeof(*state));
-               if (!state) {
-                       pr_info("btrfs check-integrity: vzalloc() failed!\n");
-                       return -1;
-               }
+               pr_info("btrfs check-integrity: allocation failed!\n");
+               return -1;
        }
 
        if (!btrfsic_is_initialized) {