Merge tag 'for-4.18-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux
authorLinus Torvalds <torvalds@linux-foundation.org>
Mon, 4 Jun 2018 21:29:13 +0000 (14:29 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Mon, 4 Jun 2018 21:29:13 +0000 (14:29 -0700)
Pull btrfs updates from David Sterba:
 "User visible features:

   - added support for the ioctl FS_IOC_FSGETXATTR, per-inode flags,
     successor of GET/SETFLAGS; now supports only existing flags:
     append, immutable, noatime, nodump, sync

   - 3 new unprivileged ioctls to allow users to enumerate subvolumes

   - dedupe syscall implementation does not restrict the range to 16MiB,
     though it still splits the whole range to 16MiB chunks

   - on user demand, rmdir() is able to delete an empty subvolume,
     export the capability in sysfs

   - fix inode number types in tracepoints, other cleanups

   - send: improved speed when dealing with a large removed directory,
     measurements show decrease from 2000 minutes to 2 minutes on a
     directory with 2 million entries

   - pre-commit check of superblock to detect a mysterious in-memory
     corruption

   - log message updates

  Other changes:

   - orphan inode cleanup improved, does no keep long-standing
     reservations that could lead up to early ENOSPC in some cases

   - slight improvement of handling snapshotted NOCOW files by avoiding
     some unnecessary tree searches

   - avoid OOM when dealing with many unmergeable small extents at flush
     time

   - speedup conversion of free space tree representations from/to
     bitmap/tree

   - code refactoring, deletion, cleanups:
      + delayed refs
      + delayed iput
      + redundant argument removals
      + memory barrier cleanups
      + remove a redundant mutex supposedly excluding several ioctls to
        run in parallel

   - new tracepoints for blockgroup manipulation

   - more sanity checks of compressed headers"

* tag 'for-4.18-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux: (183 commits)
  btrfs: Add unprivileged version of ino_lookup ioctl
  btrfs: Add unprivileged ioctl which returns subvolume's ROOT_REF
  btrfs: Add unprivileged ioctl which returns subvolume information
  Btrfs: clean up error handling in btrfs_truncate()
  btrfs: Factor out write portion of btrfs_get_blocks_direct
  btrfs: Factor out read portion of btrfs_get_blocks_direct
  btrfs: return ENOMEM if path allocation fails in btrfs_cross_ref_exist
  btrfs: raid56: Remove VLA usage
  btrfs: return error value if create_io_em failed in cow_file_range
  btrfs: drop useless member qgroup_reserved of btrfs_pending_snapshot
  btrfs: drop unused parameter qgroup_reserved
  btrfs: balance dirty metadata pages in btrfs_finish_ordered_io
  btrfs: lift some btrfs_cross_ref_exist checks in nocow path
  btrfs: Remove fs_info argument from btrfs_uuid_tree_rem
  btrfs: Remove fs_info argument from btrfs_uuid_tree_add
  Btrfs: remove unused check of skip_locking
  Btrfs: remove always true check in unlock_up
  Btrfs: grab write lock directly if write_lock_level is the max level
  Btrfs: move get root out of btrfs_search_slot to a helper
  Btrfs: use more straightforward extent_buffer_uptodate check
  ...

1  2 
fs/btrfs/extent_io.c

diff --combined fs/btrfs/extent_io.c
index 56d32bb462f941d6890f8a6b80226ee3f1381eb0,af2f0408c6e46688029eafa736301fa54da014c1..51fc015c7d2c69bd198e94c3ffc4b2ef267f7ef2
@@@ -26,7 -26,7 +26,7 @@@
  
  static struct kmem_cache *extent_state_cache;
  static struct kmem_cache *extent_buffer_cache;
 -static struct bio_set *btrfs_bioset;
 +static struct bio_set btrfs_bioset;
  
  static inline bool extent_state_in_tree(const struct extent_state *state)
  {
@@@ -162,18 -162,20 +162,18 @@@ int __init extent_io_init(void
        if (!extent_buffer_cache)
                goto free_state_cache;
  
 -      btrfs_bioset = bioset_create(BIO_POOL_SIZE,
 -                                   offsetof(struct btrfs_io_bio, bio),
 -                                   BIOSET_NEED_BVECS);
 -      if (!btrfs_bioset)
 +      if (bioset_init(&btrfs_bioset, BIO_POOL_SIZE,
 +                      offsetof(struct btrfs_io_bio, bio),
 +                      BIOSET_NEED_BVECS))
                goto free_buffer_cache;
  
 -      if (bioset_integrity_create(btrfs_bioset, BIO_POOL_SIZE))
 +      if (bioset_integrity_create(&btrfs_bioset, BIO_POOL_SIZE))
                goto free_bioset;
  
        return 0;
  
  free_bioset:
 -      bioset_free(btrfs_bioset);
 -      btrfs_bioset = NULL;
 +      bioset_exit(&btrfs_bioset);
  
  free_buffer_cache:
        kmem_cache_destroy(extent_buffer_cache);
@@@ -196,7 -198,8 +196,7 @@@ void __cold extent_io_exit(void
        rcu_barrier();
        kmem_cache_destroy(extent_state_cache);
        kmem_cache_destroy(extent_buffer_cache);
 -      if (btrfs_bioset)
 -              bioset_free(btrfs_bioset);
 +      bioset_exit(&btrfs_bioset);
  }
  
  void extent_io_tree_init(struct extent_io_tree *tree,
@@@ -2676,7 -2679,7 +2676,7 @@@ struct bio *btrfs_bio_alloc(struct bloc
  {
        struct bio *bio;
  
 -      bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, btrfs_bioset);
 +      bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &btrfs_bioset);
        bio_set_dev(bio, bdev);
        bio->bi_iter.bi_sector = first_byte >> 9;
        btrfs_io_bio_init(btrfs_io_bio(bio));
@@@ -2689,7 -2692,7 +2689,7 @@@ struct bio *btrfs_bio_clone(struct bio 
        struct bio *new;
  
        /* Bio allocation backed by a bioset does not fail */
 -      new = bio_clone_fast(bio, GFP_NOFS, btrfs_bioset);
 +      new = bio_clone_fast(bio, GFP_NOFS, &btrfs_bioset);
        btrfs_bio = btrfs_io_bio(new);
        btrfs_io_bio_init(btrfs_bio);
        btrfs_bio->iter = bio->bi_iter;
@@@ -2701,7 -2704,7 +2701,7 @@@ struct bio *btrfs_io_bio_alloc(unsigne
        struct bio *bio;
  
        /* Bio allocation backed by a bioset does not fail */
 -      bio = bio_alloc_bioset(GFP_NOFS, nr_iovecs, btrfs_bioset);
 +      bio = bio_alloc_bioset(GFP_NOFS, nr_iovecs, &btrfs_bioset);
        btrfs_io_bio_init(btrfs_io_bio(bio));
        return bio;
  }
@@@ -2712,7 -2715,7 +2712,7 @@@ struct bio *btrfs_bio_clone_partial(str
        struct btrfs_io_bio *btrfs_bio;
  
        /* this will never fail when it's backed by a bioset */
 -      bio = bio_clone_fast(orig, GFP_NOFS, btrfs_bioset);
 +      bio = bio_clone_fast(orig, GFP_NOFS, &btrfs_bioset);
        ASSERT(bio);
  
        btrfs_bio = btrfs_io_bio(bio);
@@@ -4106,14 -4109,13 +4106,13 @@@ int extent_write_locked_range(struct in
        return ret;
  }
  
- int extent_writepages(struct extent_io_tree *tree,
-                     struct address_space *mapping,
+ int extent_writepages(struct address_space *mapping,
                      struct writeback_control *wbc)
  {
        int ret = 0;
        struct extent_page_data epd = {
                .bio = NULL,
-               .tree = tree,
+               .tree = &BTRFS_I(mapping->host)->io_tree,
                .extent_locked = 0,
                .sync_io = wbc->sync_mode == WB_SYNC_ALL,
        };
        return ret;
  }
  
- int extent_readpages(struct extent_io_tree *tree,
-                    struct address_space *mapping,
-                    struct list_head *pages, unsigned nr_pages)
+ int extent_readpages(struct address_space *mapping, struct list_head *pages,
+                    unsigned nr_pages)
  {
        struct bio *bio = NULL;
        unsigned page_idx;
        struct page *pagepool[16];
        struct page *page;
        struct extent_map *em_cached = NULL;
+       struct extent_io_tree *tree = &BTRFS_I(mapping->host)->io_tree;
        int nr = 0;
        u64 prev_em_start = (u64)-1;
  
@@@ -4199,8 -4201,7 +4198,7 @@@ int extent_invalidatepage(struct extent
   * are locked or under IO and drops the related state bits if it is safe
   * to drop the page.
   */
- static int try_release_extent_state(struct extent_map_tree *map,
-                                   struct extent_io_tree *tree,
+ static int try_release_extent_state(struct extent_io_tree *tree,
                                    struct page *page, gfp_t mask)
  {
        u64 start = page_offset(page);
   * in the range corresponding to the page, both state records and extent
   * map records are removed
   */
- int try_release_extent_mapping(struct extent_map_tree *map,
-                              struct extent_io_tree *tree, struct page *page,
-                              gfp_t mask)
+ int try_release_extent_mapping(struct page *page, gfp_t mask)
  {
        struct extent_map *em;
        u64 start = page_offset(page);
        u64 end = start + PAGE_SIZE - 1;
+       struct extent_io_tree *tree = &BTRFS_I(page->mapping->host)->io_tree;
+       struct extent_map_tree *map = &BTRFS_I(page->mapping->host)->extent_tree;
  
        if (gfpflags_allow_blocking(mask) &&
            page->mapping->host->i_size > SZ_16M) {
                        free_extent_map(em);
                }
        }
-       return try_release_extent_state(map, tree, page, mask);
+       return try_release_extent_state(tree, page, mask);
  }
  
  /*
@@@ -5617,46 -5618,6 +5615,6 @@@ void copy_extent_buffer(struct extent_b
        }
  }
  
- void le_bitmap_set(u8 *map, unsigned int start, int len)
- {
-       u8 *p = map + BIT_BYTE(start);
-       const unsigned int size = start + len;
-       int bits_to_set = BITS_PER_BYTE - (start % BITS_PER_BYTE);
-       u8 mask_to_set = BITMAP_FIRST_BYTE_MASK(start);
-       while (len - bits_to_set >= 0) {
-               *p |= mask_to_set;
-               len -= bits_to_set;
-               bits_to_set = BITS_PER_BYTE;
-               mask_to_set = ~0;
-               p++;
-       }
-       if (len) {
-               mask_to_set &= BITMAP_LAST_BYTE_MASK(size);
-               *p |= mask_to_set;
-       }
- }
- void le_bitmap_clear(u8 *map, unsigned int start, int len)
- {
-       u8 *p = map + BIT_BYTE(start);
-       const unsigned int size = start + len;
-       int bits_to_clear = BITS_PER_BYTE - (start % BITS_PER_BYTE);
-       u8 mask_to_clear = BITMAP_FIRST_BYTE_MASK(start);
-       while (len - bits_to_clear >= 0) {
-               *p &= ~mask_to_clear;
-               len -= bits_to_clear;
-               bits_to_clear = BITS_PER_BYTE;
-               mask_to_clear = ~0;
-               p++;
-       }
-       if (len) {
-               mask_to_clear &= BITMAP_LAST_BYTE_MASK(size);
-               *p &= ~mask_to_clear;
-       }
- }
  /*
   * eb_bitmap_offset() - calculate the page and offset of the byte containing the
   * given bit number