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

Pull btrfs updates from David Sterba:
 "The core updates improve error handling (mostly related to bios), with
  the usual incremental work on the GFP_NOFS (mis)use removal,
  refactoring or cleanups. Except the two top patches, all have been in
  for-next for an extensive amount of time.

  User visible changes:

   - statx support

   - quota override tunable

   - improved compression thresholds

   - obsoleted mount option alloc_start

  Core updates:

   - bio-related updates:
       - faster bio cloning
       - no allocation failures
       - preallocated flush bios

   - more kvzalloc use, memalloc_nofs protections, GFP_NOFS updates

   - prep work for btree_inode removal

   - dir-item validation

   - qgoup fixes and updates

   - cleanups:
       - removed unused struct members, unused code, refactoring
       - argument refactoring (fs_info/root, caller -> callee sink)
       - SEARCH_TREE ioctl docs"

* 'for-4.13-part1' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux: (115 commits)
  btrfs: Remove false alert when fiemap range is smaller than on-disk extent
  btrfs: Don't clear SGID when inheriting ACLs
  btrfs: fix integer overflow in calc_reclaim_items_nr
  btrfs: scrub: fix target device intialization while setting up scrub context
  btrfs: qgroup: Fix qgroup reserved space underflow by only freeing reserved ranges
  btrfs: qgroup: Introduce extent changeset for qgroup reserve functions
  btrfs: qgroup: Fix qgroup reserved space underflow caused by buffered write and quotas being enabled
  btrfs: qgroup: Return actually freed bytes for qgroup release or free data
  btrfs: qgroup: Cleanup btrfs_qgroup_prepare_account_extents function
  btrfs: qgroup: Add quick exit for non-fs extents
  Btrfs: rework delayed ref total_bytes_pinned accounting
  Btrfs: return old and new total ref mods when adding delayed refs
  Btrfs: always account pinned bytes when dropping a tree block ref
  Btrfs: update total_bytes_pinned when pinning down extents
  Btrfs: make BUG_ON() in add_pinned_bytes() an ASSERT()
  Btrfs: make add_pinned_bytes() take an s64 num_bytes instead of u64
  btrfs: fix validation of XATTR_ITEM dir items
  btrfs: Verify dir_item in iterate_object_props
  btrfs: Check name_len before in btrfs_del_root_ref
  btrfs: Check name_len before reading btrfs_get_name
  ...

1 files changed, 21 insertions, 32 deletions

diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 4ded1c3f92b8..11d37c94ce05 100644
--- 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) {