Merge tag 'for-5.3-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux

Pull btrfs updates from David Sterba:
 "Highlights:

   - chunks that have been trimmed and unchanged since last mount are
     tracked and skipped on repeated trims

   - use hw assissed crc32c on more arches, speedups if native
     instructions or optimized implementation is available

   - the RAID56 incompat bit is automatically removed when the last
     block group of that type is removed

  Fixes:

   - fsync fix for reflink on NODATACOW files that could lead to ENOSPC

   - fix data loss after inode eviction, renaming it, and fsync it

   - fix fsync not persisting dentry deletions due to inode evictions

   - update ctime/mtime/iversion after hole punching

   - fix compression type validation (reported by KASAN)

   - send won't be allowed to start when relocation is in progress, this
     can cause spurious errors or produce incorrect send stream

  Core:

   - new tracepoints for space update

   - tree-checker: better check for end of extents for some tree items

   - preparatory work for more checksum algorithms

   - run delayed iput at unlink time and don't push the work to cleaner
     thread where it's not properly throttled

   - wrap block mapping to structures and helpers, base for further
     refactoring

   - split large files, part 1:
       - space info handling
       - block group reservations
       - delayed refs
       - delayed allocation

   - other cleanups and refactoring"

* tag 'for-5.3-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux: (103 commits)
  btrfs: fix memory leak of path on error return path
  btrfs: move the subvolume reservation stuff out of extent-tree.c
  btrfs: migrate the delalloc space stuff to it's own home
  btrfs: migrate btrfs_trans_release_chunk_metadata
  btrfs: migrate the delayed refs rsv code
  btrfs: Evaluate io_tree in find_lock_delalloc_range()
  btrfs: migrate the global_block_rsv helpers to block-rsv.c
  btrfs: migrate the block-rsv code to block-rsv.c
  btrfs: stop using block_rsv_release_bytes everywhere
  btrfs: cleanup the target logic in __btrfs_block_rsv_release
  btrfs: export __btrfs_block_rsv_release
  btrfs: export btrfs_block_rsv_add_bytes
  btrfs: move btrfs_block_rsv definitions into it's own header
  btrfs: Simplify update of space_info in __reserve_metadata_bytes()
  btrfs: unexport can_overcommit
  btrfs: move reserve_metadata_bytes and supporting code to space-info.c
  btrfs: move dump_space_info to space-info.c
  btrfs: export block_rsv_use_bytes
  btrfs: move btrfs_space_info_add_*_bytes to space-info.c
  btrfs: move the space info update macro to space-info.h
  ...

1 files changed, 178 insertions, 3 deletions

diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index a73fc23e2961..9a91d1eb0af4 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -10,6 +10,7 @@
 #include "delayed-ref.h"
 #include "transaction.h"
 #include "qgroup.h"
+#include "space-info.h"
 
 struct kmem_cache *btrfs_delayed_ref_head_cachep;
 struct kmem_cache *btrfs_delayed_tree_ref_cachep;
@@ -24,6 +25,179 @@ struct kmem_cache *btrfs_delayed_extent_op_cachep;
  * of hammering updates on the extent allocation tree.
  */
 
+bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
+        struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
+        bool ret = false;
+        u64 reserved;
+
+        spin_lock(&global_rsv->lock);
+        reserved = global_rsv->reserved;
+        spin_unlock(&global_rsv->lock);
+
+        /*
+         * Since the global reserve is just kind of magic we don't really want
+         * to rely on it to save our bacon, so if our size is more than the
+         * delayed_refs_rsv and the global rsv then it's time to think about
+         * bailing.
+         */
+        spin_lock(&delayed_refs_rsv->lock);
+        reserved += delayed_refs_rsv->reserved;
+        if (delayed_refs_rsv->size >= reserved)
+                ret = true;
+        spin_unlock(&delayed_refs_rsv->lock);
+        return ret;
+}
+
+int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans)
+{
+        u64 num_entries =
+                atomic_read(&trans->transaction->delayed_refs.num_entries);
+        u64 avg_runtime;
+        u64 val;
+
+        smp_mb();
+        avg_runtime = trans->fs_info->avg_delayed_ref_runtime;
+        val = num_entries * avg_runtime;
+        if (val >= NSEC_PER_SEC)
+                return 1;
+        if (val >= NSEC_PER_SEC / 2)
+                return 2;
+
+        return btrfs_check_space_for_delayed_refs(trans->fs_info);
+}
+
+/**
+ * btrfs_delayed_refs_rsv_release - release a ref head's reservation.
+ * @fs_info - the fs_info for our fs.
+ * @nr - the number of items to drop.
+ *
+ * This drops the delayed ref head's count from the delayed refs rsv and frees
+ * any excess reservation we had.
+ */
+void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr)
+{
+        struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;
+        u64 num_bytes = btrfs_calc_trans_metadata_size(fs_info, nr);
+        u64 released = 0;
+
+        released = __btrfs_block_rsv_release(fs_info, block_rsv, num_bytes,
+                                             NULL);
+        if (released)
+                trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",
+                                              0, released, 0);
+}
+
+/*
+ * btrfs_update_delayed_refs_rsv - adjust the size of the delayed refs rsv
+ * @trans - the trans that may have generated delayed refs
+ *
+ * This is to be called anytime we may have adjusted trans->delayed_ref_updates,
+ * it'll calculate the additional size and add it to the delayed_refs_rsv.
+ */
+void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans)
+{
+        struct btrfs_fs_info *fs_info = trans->fs_info;
+        struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
+        u64 num_bytes;
+
+        if (!trans->delayed_ref_updates)
+                return;
+
+        num_bytes = btrfs_calc_trans_metadata_size(fs_info,
+                                                   trans->delayed_ref_updates);
+        spin_lock(&delayed_rsv->lock);
+        delayed_rsv->size += num_bytes;
+        delayed_rsv->full = 0;
+        spin_unlock(&delayed_rsv->lock);
+        trans->delayed_ref_updates = 0;
+}
+
+/**
+ * btrfs_migrate_to_delayed_refs_rsv - transfer bytes to our delayed refs rsv.
+ * @fs_info - the fs info for our fs.
+ * @src - the source block rsv to transfer from.
+ * @num_bytes - the number of bytes to transfer.
+ *
+ * This transfers up to the num_bytes amount from the src rsv to the
+ * delayed_refs_rsv.  Any extra bytes are returned to the space info.
+ */
+void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info,
+                                       struct btrfs_block_rsv *src,
+                                       u64 num_bytes)
+{
+        struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
+        u64 to_free = 0;
+
+        spin_lock(&src->lock);
+        src->reserved -= num_bytes;
+        src->size -= num_bytes;
+        spin_unlock(&src->lock);
+
+        spin_lock(&delayed_refs_rsv->lock);
+        if (delayed_refs_rsv->size > delayed_refs_rsv->reserved) {
+                u64 delta = delayed_refs_rsv->size -
+                        delayed_refs_rsv->reserved;
+                if (num_bytes > delta) {
+                        to_free = num_bytes - delta;
+                        num_bytes = delta;
+                }
+        } else {
+                to_free = num_bytes;
+                num_bytes = 0;
+        }
+
+        if (num_bytes)
+                delayed_refs_rsv->reserved += num_bytes;
+        if (delayed_refs_rsv->reserved >= delayed_refs_rsv->size)
+                delayed_refs_rsv->full = 1;
+        spin_unlock(&delayed_refs_rsv->lock);
+
+        if (num_bytes)
+                trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",
+                                              0, num_bytes, 1);
+        if (to_free)
+                btrfs_space_info_add_old_bytes(fs_info,
+                                delayed_refs_rsv->space_info, to_free);
+}
+
+/**
+ * btrfs_delayed_refs_rsv_refill - refill based on our delayed refs usage.
+ * @fs_info - the fs_info for our fs.
+ * @flush - control how we can flush for this reservation.
+ *
+ * This will refill the delayed block_rsv up to 1 items size worth of space and
+ * will return -ENOSPC if we can't make the reservation.
+ */
+int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,
+                                  enum btrfs_reserve_flush_enum flush)
+{
+        struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;
+        u64 limit = btrfs_calc_trans_metadata_size(fs_info, 1);
+        u64 num_bytes = 0;
+        int ret = -ENOSPC;
+
+        spin_lock(&block_rsv->lock);
+        if (block_rsv->reserved < block_rsv->size) {
+                num_bytes = block_rsv->size - block_rsv->reserved;
+                num_bytes = min(num_bytes, limit);
+        }
+        spin_unlock(&block_rsv->lock);
+
+        if (!num_bytes)
+                return 0;
+
+        ret = btrfs_reserve_metadata_bytes(fs_info->extent_root, block_rsv,
+                                           num_bytes, flush);
+        if (ret)
+                return ret;
+        btrfs_block_rsv_add_bytes(block_rsv, num_bytes, 0);
+        trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",
+                                      0, num_bytes, 1);
+        return 0;
+}
+
 /*
  * compare two delayed tree backrefs with same bytenr and type
  */
@@ -957,13 +1131,14 @@ int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans,
 }
 
 /*
- * this does a simple search for the head node for a given extent.
- * It must be called with the delayed ref spinlock held, and it returns
- * the head node if any where found, or NULL if not.
+ * This does a simple search for the head node for a given extent.  Returns the
+ * head node if found, or NULL if not.
  */
 struct btrfs_delayed_ref_head *
 btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs, u64 bytenr)
 {
+        lockdep_assert_held(&delayed_refs->lock);
+
         return find_ref_head(delayed_refs, bytenr, false);
 }