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

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (62 commits)
  Btrfs: use larger system chunks
  Btrfs: add a delalloc mutex to inodes for delalloc reservations
  Btrfs: space leak tracepoints
  Btrfs: protect orphan block rsv with spin_lock
  Btrfs: add allocator tracepoints
  Btrfs: don't call btrfs_throttle in file write
  Btrfs: release space on error in page_mkwrite
  Btrfs: fix btrfsck error 400 when truncating a compressed
  Btrfs: do not use btrfs_end_transaction_throttle everywhere
  Btrfs: add balance progress reporting
  Btrfs: allow for resuming restriper after it was paused
  Btrfs: allow for canceling restriper
  Btrfs: allow for pausing restriper
  Btrfs: add skip_balance mount option
  Btrfs: recover balance on mount
  Btrfs: save balance parameters to disk
  Btrfs: soft profile changing mode (aka soft convert)
  Btrfs: implement online profile changing
  Btrfs: do not reduce profile in do_chunk_alloc()
  Btrfs: virtual address space subset filter
  ...

Fix up trivial conflict in fs/btrfs/ioctl.c due to the use of the new
mnt_drop_write_file() helper.

1 files changed, 51 insertions, 2 deletions

diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c
index d77b67c4b275..5e178d8f7167 100644
--- a/fs/btrfs/locking.c
+++ b/fs/btrfs/locking.c
@@ -33,6 +33,14 @@ void btrfs_assert_tree_read_locked(struct extent_buffer *eb);
  */
 void btrfs_set_lock_blocking_rw(struct extent_buffer *eb, int rw)
 {
+        if (eb->lock_nested) {
+                read_lock(&eb->lock);
+                if (eb->lock_nested && current->pid == eb->lock_owner) {
+                        read_unlock(&eb->lock);
+                        return;
+                }
+                read_unlock(&eb->lock);
+        }
         if (rw == BTRFS_WRITE_LOCK) {
                 if (atomic_read(&eb->blocking_writers) == 0) {
                         WARN_ON(atomic_read(&eb->spinning_writers) != 1);
@@ -57,6 +65,14 @@ void btrfs_set_lock_blocking_rw(struct extent_buffer *eb, int rw)
  */
 void btrfs_clear_lock_blocking_rw(struct extent_buffer *eb, int rw)
 {
+        if (eb->lock_nested) {
+                read_lock(&eb->lock);
+                if (&eb->lock_nested && current->pid == eb->lock_owner) {
+                        read_unlock(&eb->lock);
+                        return;
+                }
+                read_unlock(&eb->lock);
+        }
         if (rw == BTRFS_WRITE_LOCK_BLOCKING) {
                 BUG_ON(atomic_read(&eb->blocking_writers) != 1);
                 write_lock(&eb->lock);
@@ -81,12 +97,25 @@ void btrfs_clear_lock_blocking_rw(struct extent_buffer *eb, int rw)
 void btrfs_tree_read_lock(struct extent_buffer *eb)
 {
 again:
+        read_lock(&eb->lock);
+        if (atomic_read(&eb->blocking_writers) &&
+            current->pid == eb->lock_owner) {
+                /*
+                 * This extent is already write-locked by our thread. We allow
+                 * an additional read lock to be added because it's for the same
+                 * thread. btrfs_find_all_roots() depends on this as it may be
+                 * called on a partly (write-)locked tree.
+                 */
+                BUG_ON(eb->lock_nested);
+                eb->lock_nested = 1;
+                read_unlock(&eb->lock);
+                return;
+        }
+        read_unlock(&eb->lock);
         wait_event(eb->write_lock_wq, atomic_read(&eb->blocking_writers) == 0);
         read_lock(&eb->lock);
         if (atomic_read(&eb->blocking_writers)) {
                 read_unlock(&eb->lock);
-                wait_event(eb->write_lock_wq,
-                           atomic_read(&eb->blocking_writers) == 0);
                 goto again;
         }
         atomic_inc(&eb->read_locks);
@@ -129,6 +158,7 @@ int btrfs_try_tree_write_lock(struct extent_buffer *eb)
         }
         atomic_inc(&eb->write_locks);
         atomic_inc(&eb->spinning_writers);
+        eb->lock_owner = current->pid;
         return 1;
 }
 
@@ -137,6 +167,15 @@ int btrfs_try_tree_write_lock(struct extent_buffer *eb)
  */
 void btrfs_tree_read_unlock(struct extent_buffer *eb)
 {
+        if (eb->lock_nested) {
+                read_lock(&eb->lock);
+                if (eb->lock_nested && current->pid == eb->lock_owner) {
+                        eb->lock_nested = 0;
+                        read_unlock(&eb->lock);
+                        return;
+                }
+                read_unlock(&eb->lock);
+        }
         btrfs_assert_tree_read_locked(eb);
         WARN_ON(atomic_read(&eb->spinning_readers) == 0);
         atomic_dec(&eb->spinning_readers);
@@ -149,6 +188,15 @@ void btrfs_tree_read_unlock(struct extent_buffer *eb)
  */
 void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb)
 {
+        if (eb->lock_nested) {
+                read_lock(&eb->lock);
+                if (eb->lock_nested && current->pid == eb->lock_owner) {
+                        eb->lock_nested = 0;
+                        read_unlock(&eb->lock);
+                        return;
+                }
+                read_unlock(&eb->lock);
+        }
         btrfs_assert_tree_read_locked(eb);
         WARN_ON(atomic_read(&eb->blocking_readers) == 0);
         if (atomic_dec_and_test(&eb->blocking_readers))
@@ -181,6 +229,7 @@ again:
         WARN_ON(atomic_read(&eb->spinning_writers));
         atomic_inc(&eb->spinning_writers);
         atomic_inc(&eb->write_locks);
+        eb->lock_owner = current->pid;
         return 0;
 }