Skip to contentSkip to conversation

btrfs: fix mmap writes for NOCOW files/extents

PATCH Superseded [email protected] 2 participants 17 messages Jul 9, 2025 Btrfs file system

lore
Share & tools
lore
#0 lore raw

cover btrfs: fix mmap writes for NOCOW files/extents

From: Filipe Manana <[email protected]>

A bug fix and a couple cleanups. Details in the individual change logs.

Filipe Manana (3):
btrfs: fix -ENOSPC mmap write failure on NOCOW files/extents
btrfs: use variable for io_tree when clearing range in btrfs_page_mkwrite()
btrfs: use btrfs_inode local variable at btrfs_page_mkwrite()

 fs/btrfs/file.c | 85 +++++++++++++++++++++++++++++++++----------------
 1 file changed, 58 insertions(+), 27 deletions(-)
Signature · 1 line
2.47.2
#1 lore raw

PATCH 1/3 btrfs: fix -ENOSPC mmap write failure on NOCOW files/extents

From: Filipe Manana <[email protected]>

If we attempt a mmap write into a NOCOW file or a prealloc extent when there is no more available data space (or unallocated space to allocate a new data block group) and we can do a NOCOW write (there are no reflinks for the target extent or snapshots), we always fail due to -ENOSPC, unlike for the regular buffered write and direct IO paths where we check that we can do a NOCOW write in case we can't reserve data space.

Simple reproducer:

  $ cat test.sh
  #!/bin/bash

DEV=/dev/sdi
MNT=/mnt/sdi

  umount $DEV &> /dev/null
  mkfs.btrfs -f -b $((512 * 1024 * 1024)) $DEV
  mount $DEV $MNT

touch $MNT/foobar
# Make it a NOCOW file.
chattr +C $MNT/foobar

# Add initial data to file.
xfs_io -c "pwrite -S 0xab 0 1M" $MNT/foobar

# Fill all the remaining data space and unallocated space with data. dd if=/dev/zero of=$MNT/filler bs=4K &> /dev/null

  # Overwrite the file with a mmap write. Should succeed.
  xfs_io -c "mmap -w 0 1M"        \
         -c "mwrite -S 0xcd 0 1M" \
         -c "munmap"              \
         $MNT/foobar

# Unmount, mount again and verify the new data was persisted. umount $MNT
mount $DEV $MNT

od -A d -t x1 $MNT/foobar

umount $MNT

Running this:

  $ ./test.sh
  (...)
  wrote 1048576/1048576 bytes at offset 0
  1 MiB, 256 ops; 0.0008 sec (1.188 GiB/sec and 311435.5231 ops/sec)
  ./test.sh: line 24: 234865 Bus error               xfs_io -c "mmap -w 0 1M" -c "mwrite -S 0xcd 0 1M" -c "munmap" $MNT/foobar
  0000000 ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
  *
  1048576

Fix this by not failing in case we can't allocate data space and we can NOCOW into the target extent - reserving only metadata space in this case.

After this change the test passes:

  $ ./test.sh
  (...)
  wrote 1048576/1048576 bytes at offset 0
  1 MiB, 256 ops; 0.0007 sec (1.262 GiB/sec and 330749.3540 ops/sec)
  0000000 cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd
  *
  1048576

A test case for fstests will be added soon.

---
 fs/btrfs/file.c | 49 +++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 41 insertions(+), 8 deletions(-)
fs/btrfs/file.c +41 -8
index 05b046c6806f..f08c72dbb530 100644
@@ -1841,6 +1841,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	loff_t size;
 	size_t fsize = folio_size(folio);
 	int ret;
+	bool only_release_metadata = false;
 	u64 reserved_space;
 	u64 page_start;
 	u64 page_end;
@@ -1861,10 +1862,28 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * end up waiting indefinitely to get a lock on the page currently
 	 * being processed by btrfs_page_mkwrite() function.
 	 */
-	ret = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
-					   page_start, reserved_space);
-	if (ret < 0)
+	ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved,
+					  page_start, reserved_space, false);
+	if (ret < 0) {
+		size_t write_bytes = reserved_space;
+
+		if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
+					   &write_bytes, false) <= 0)
+			goto out_noreserve;
+
+		if (write_bytes < reserved_space)
+			goto out_noreserve;
+
+		only_release_metadata = true;
+	}
+	ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+					      reserved_space, false);
+	if (ret < 0) {
+		if (!only_release_metadata)
+			btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+						       page_start, reserved_space);
 		goto out_noreserve;
+	}
 
 	ret = file_update_time(vmf->vma->vm_file);
 	if (ret < 0)
@@ -1906,9 +1925,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 		reserved_space = round_up(size - page_start, fs_info->sectorsize);
 		if (reserved_space < fsize) {
 			end = page_start + reserved_space - 1;
-			btrfs_delalloc_release_space(BTRFS_I(inode),
-					data_reserved, end + 1,
-					fsize - reserved_space, true);
+			if (!only_release_metadata)
+				btrfs_delalloc_release_space(BTRFS_I(inode),
+							     data_reserved, end + 1,
+							     fsize - reserved_space,
+							     true);
 		}
 	}
 
@@ -1945,10 +1966,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
 	btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
 
+	if (only_release_metadata)
+		btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
+				     &cached_state);
+
 	btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 	up_read(&BTRFS_I(inode)->i_mmap_lock);
 
 	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	if (only_release_metadata)
+		btrfs_check_nocow_unlock(BTRFS_I(inode));
 	sb_end_pagefault(inode->i_sb);
 	extent_changeset_free(data_reserved);
 	return VM_FAULT_LOCKED;
@@ -1958,10 +1985,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	up_read(&BTRFS_I(inode)->i_mmap_lock);
 out:
 	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
-	btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
-				     reserved_space, true);
+	if (only_release_metadata)
+		btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+	else
+		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
+					     page_start, reserved_space, true);
 	extent_changeset_free(data_reserved);
 out_noreserve:
+	if (only_release_metadata)
+		btrfs_check_nocow_unlock(BTRFS_I(inode));
+
 	sb_end_pagefault(inode->i_sb);
 
 	if (ret < 0)
Signature · 1 line
2.47.2
Reviewed-by on v1 1/3
#2 lore raw

Re: [PATCH 1/3] btrfs: fix -ENOSPC mmap write failure on NOCOW files/extents

Quoted 69 lines · 在 2025/7/9 18:23, [email protected] 写道:

From: Filipe Manana <[email protected]>

If we attempt a mmap write into a NOCOW file or a prealloc extent when there is no more available data space (or unallocated space to allocate a new data block group) and we can do a NOCOW write (there are no reflinks for the target extent or snapshots), we always fail due to -ENOSPC, unlike for the regular buffered write and direct IO paths where we check that we can do a NOCOW write in case we can't reserve data space.

Simple reproducer:

   $ cat test.sh
   #!/bin/bash

DEV=/dev/sdi
MNT=/mnt/sdi

   umount $DEV &> /dev/null
   mkfs.btrfs -f -b $((512 * 1024 * 1024)) $DEV
   mount $DEV $MNT

touch $MNT/foobar
# Make it a NOCOW file.
chattr +C $MNT/foobar

# Add initial data to file.
xfs_io -c "pwrite -S 0xab 0 1M" $MNT/foobar

# Fill all the remaining data space and unallocated space with data. dd if=/dev/zero of=$MNT/filler bs=4K &> /dev/null

   # Overwrite the file with a mmap write. Should succeed.
   xfs_io -c "mmap -w 0 1M"        \
          -c "mwrite -S 0xcd 0 1M" \
          -c "munmap"              \
          $MNT/foobar

# Unmount, mount again and verify the new data was persisted. umount $MNT
mount $DEV $MNT

od -A d -t x1 $MNT/foobar

umount $MNT

Running this:

   $ ./test.sh
   (...)
   wrote 1048576/1048576 bytes at offset 0
   1 MiB, 256 ops; 0.0008 sec (1.188 GiB/sec and 311435.5231 ops/sec)
   ./test.sh: line 24: 234865 Bus error               xfs_io -c "mmap -w 0 1M" -c "mwrite -S 0xcd 0 1M" -c "munmap" $MNT/foobar
   0000000 ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
   *
   1048576

Fix this by not failing in case we can't allocate data space and we can NOCOW into the target extent - reserving only metadata space in this case.

After this change the test passes:

   $ ./test.sh
   (...)
   wrote 1048576/1048576 bytes at offset 0
   1 MiB, 256 ops; 0.0007 sec (1.262 GiB/sec and 330749.3540 ops/sec)
   0000000 cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd
   *
   1048576
Quoted 3 lines

A test case for fstests will be added soon.

With large data folios, I'm afraid we may fail the nocow check more frequently than the regular page sized folios. But that's unavoidable, we have to ensure the whole folio can be written back NOCOW.

Thanks,
Qu

Quoted 99 lines
---
  fs/btrfs/file.c | 49 +++++++++++++++++++++++++++++++++++++++++--------
  1 file changed, 41 insertions(+), 8 deletions(-)
fs/btrfs/file.c +41 -8
index 05b046c6806f..f08c72dbb530 100644
@@ -1841,6 +1841,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  	loff_t size;
  	size_t fsize = folio_size(folio);
  	int ret;
+	bool only_release_metadata = false;
  	u64 reserved_space;
  	u64 page_start;
  	u64 page_end;
@@ -1861,10 +1862,28 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  	 * end up waiting indefinitely to get a lock on the page currently
  	 * being processed by btrfs_page_mkwrite() function.
  	 */
-	ret = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
-					   page_start, reserved_space);
-	if (ret < 0)
+	ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved,
+					  page_start, reserved_space, false);
+	if (ret < 0) {
+		size_t write_bytes = reserved_space;
+
+		if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
+					   &write_bytes, false) <= 0)
+			goto out_noreserve;
+
+		if (write_bytes < reserved_space)
+			goto out_noreserve;
+
+		only_release_metadata = true;
+	}
+	ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+					      reserved_space, false);
+	if (ret < 0) {
+		if (!only_release_metadata)
+			btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+						       page_start, reserved_space);
  		goto out_noreserve;
+	}
 
  	ret = file_update_time(vmf->vma->vm_file);
  	if (ret < 0)
@@ -1906,9 +1925,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  		reserved_space = round_up(size - page_start, fs_info->sectorsize);
  		if (reserved_space < fsize) {
  			end = page_start + reserved_space - 1;
-			btrfs_delalloc_release_space(BTRFS_I(inode),
-					data_reserved, end + 1,
-					fsize - reserved_space, true);
+			if (!only_release_metadata)
+				btrfs_delalloc_release_space(BTRFS_I(inode),
+							     data_reserved, end + 1,
+							     fsize - reserved_space,
+							     true);
  		}
  	}
 
@@ -1945,10 +1966,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
  	btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
 
+	if (only_release_metadata)
+		btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
+				     &cached_state);
+
  	btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
  	up_read(&BTRFS_I(inode)->i_mmap_lock);
 
  	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	if (only_release_metadata)
+		btrfs_check_nocow_unlock(BTRFS_I(inode));
  	sb_end_pagefault(inode->i_sb);
  	extent_changeset_free(data_reserved);
  	return VM_FAULT_LOCKED;
@@ -1958,10 +1985,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  	up_read(&BTRFS_I(inode)->i_mmap_lock);
  out:
  	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
-	btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
-				     reserved_space, true);
+	if (only_release_metadata)
+		btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+	else
+		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
+					     page_start, reserved_space, true);
  	extent_changeset_free(data_reserved);
  out_noreserve:
+	if (only_release_metadata)
+		btrfs_check_nocow_unlock(BTRFS_I(inode));
+
  	sb_end_pagefault(inode->i_sb);
 
  	if (ret < 0)
#3 lore raw

Re: [PATCH 1/3] btrfs: fix -ENOSPC mmap write failure on NOCOW files/extents

Quoted 73 lines · Qu Wenruo
Quoted 69 lines · 在 2025/7/9 18:23, [email protected] 写道:

From: Filipe Manana <[email protected]>

If we attempt a mmap write into a NOCOW file or a prealloc extent when there is no more available data space (or unallocated space to allocate a new data block group) and we can do a NOCOW write (there are no reflinks for the target extent or snapshots), we always fail due to -ENOSPC, unlike for the regular buffered write and direct IO paths where we check that we can do a NOCOW write in case we can't reserve data space.

Simple reproducer:

   $ cat test.sh
   #!/bin/bash

DEV=/dev/sdi
MNT=/mnt/sdi

   umount $DEV &> /dev/null
   mkfs.btrfs -f -b $((512 * 1024 * 1024)) $DEV
   mount $DEV $MNT

touch $MNT/foobar
# Make it a NOCOW file.
chattr +C $MNT/foobar

# Add initial data to file.
xfs_io -c "pwrite -S 0xab 0 1M" $MNT/foobar

# Fill all the remaining data space and unallocated space with data. dd if=/dev/zero of=$MNT/filler bs=4K &> /dev/null

   # Overwrite the file with a mmap write. Should succeed.
   xfs_io -c "mmap -w 0 1M"        \
          -c "mwrite -S 0xcd 0 1M" \
          -c "munmap"              \
          $MNT/foobar

# Unmount, mount again and verify the new data was persisted. umount $MNT
mount $DEV $MNT

od -A d -t x1 $MNT/foobar

umount $MNT

Running this:

   $ ./test.sh
   (...)
   wrote 1048576/1048576 bytes at offset 0
   1 MiB, 256 ops; 0.0008 sec (1.188 GiB/sec and 311435.5231 ops/sec)
   ./test.sh: line 24: 234865 Bus error               xfs_io -c "mmap -w 0 1M" -c "mwrite -S 0xcd 0 1M" -c "munmap" $MNT/foobar
   0000000 ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
   *
   1048576

Fix this by not failing in case we can't allocate data space and we can NOCOW into the target extent - reserving only metadata space in this case.

After this change the test passes:

   $ ./test.sh
   (...)
   wrote 1048576/1048576 bytes at offset 0
   1 MiB, 256 ops; 0.0007 sec (1.262 GiB/sec and 330749.3540 ops/sec)
   0000000 cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd
   *
   1048576
Quoted 8 lines
Quoted 3 lines

A test case for fstests will be added soon.

With large data folios, I'm afraid we may fail the nocow check more frequently than the regular page sized folios.

Why?
For a NOCOW file, assuming there are no reflinks or snapshots, it doesn't matter how big the folio is or how many extents it spans.

Quoted 106 lines

But that's unavoidable, we have to ensure the whole folio can be written back NOCOW.

Thanks,
Qu

Quoted 99 lines
---
  fs/btrfs/file.c | 49 +++++++++++++++++++++++++++++++++++++++++--------
  1 file changed, 41 insertions(+), 8 deletions(-)
fs/btrfs/file.c +41 -8
index 05b046c6806f..f08c72dbb530 100644
@@ -1841,6 +1841,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
      loff_t size;
      size_t fsize = folio_size(folio);
      int ret;
+     bool only_release_metadata = false;
      u64 reserved_space;
      u64 page_start;
      u64 page_end;
@@ -1861,10 +1862,28 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
       * end up waiting indefinitely to get a lock on the page currently
       * being processed by btrfs_page_mkwrite() function.
       */
-     ret = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
-                                        page_start, reserved_space);
-     if (ret < 0)
+     ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved,
+                                       page_start, reserved_space, false);
+     if (ret < 0) {
+             size_t write_bytes = reserved_space;
+
+             if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
+                                        &write_bytes, false) <= 0)
+                     goto out_noreserve;
+
+             if (write_bytes < reserved_space)
+                     goto out_noreserve;
+
+             only_release_metadata = true;
+     }
+     ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+                                           reserved_space, false);
+     if (ret < 0) {
+             if (!only_release_metadata)
+                     btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+                                                    page_start, reserved_space);
              goto out_noreserve;
+     }
 
      ret = file_update_time(vmf->vma->vm_file);
      if (ret < 0)
@@ -1906,9 +1925,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
              reserved_space = round_up(size - page_start, fs_info->sectorsize);
              if (reserved_space < fsize) {
                      end = page_start + reserved_space - 1;
-                     btrfs_delalloc_release_space(BTRFS_I(inode),
-                                     data_reserved, end + 1,
-                                     fsize - reserved_space, true);
+                     if (!only_release_metadata)
+                             btrfs_delalloc_release_space(BTRFS_I(inode),
+                                                          data_reserved, end + 1,
+                                                          fsize - reserved_space,
+                                                          true);
              }
      }
 
@@ -1945,10 +1966,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
      btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
 
+     if (only_release_metadata)
+             btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
+                                  &cached_state);
+
      btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
      up_read(&BTRFS_I(inode)->i_mmap_lock);
 
      btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+     if (only_release_metadata)
+             btrfs_check_nocow_unlock(BTRFS_I(inode));
      sb_end_pagefault(inode->i_sb);
      extent_changeset_free(data_reserved);
      return VM_FAULT_LOCKED;
@@ -1958,10 +1985,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
      up_read(&BTRFS_I(inode)->i_mmap_lock);
  out:
      btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
-     btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
-                                  reserved_space, true);
+     if (only_release_metadata)
+             btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+     else
+             btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
+                                          page_start, reserved_space, true);
      extent_changeset_free(data_reserved);
  out_noreserve:
+     if (only_release_metadata)
+             btrfs_check_nocow_unlock(BTRFS_I(inode));
+
      sb_end_pagefault(inode->i_sb);
 
      if (ret < 0)
#4 lore raw

PATCH 2/3 btrfs: use variable for io_tree when clearing range in btrfs_page_mkwrite()

In reply to [email protected]

From: Filipe Manana <[email protected]>

We have the inode's io_tree already stored in a local variable, so use it instead of grabbing it again in the call to btrfs_clear_extent_bit().

---
 fs/btrfs/file.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/btrfs/file.c +1 -1
index f08c72dbb530..e76e92873de5 100644
@@ -1940,7 +1940,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * clear any delalloc bits within this page range since we have to
 	 * reserve data&meta space before lock_page() (see above comments).
 	 */
-	btrfs_clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
+	btrfs_clear_extent_bit(io_tree, page_start, end,
 			       EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
 			       EXTENT_DEFRAG, &cached_state);
 
Signature · 1 line
2.47.2
Reviewed-by on v1 2/3
#5 lore raw

Re: [PATCH 2/3] btrfs: use variable for io_tree when clearing range in btrfs_page_mkwrite()

Quoted 6 lines · 在 2025/7/9 18:23, [email protected] 写道:

From: Filipe Manana <[email protected]>

We have the inode's io_tree already stored in a local variable, so use it instead of grabbing it again in the call to btrfs_clear_extent_bit().

Thanks,
Qu

Quoted 17 lines
---
  fs/btrfs/file.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
fs/btrfs/file.c +1 -1
index f08c72dbb530..e76e92873de5 100644
@@ -1940,7 +1940,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  	 * clear any delalloc bits within this page range since we have to
  	 * reserve data&meta space before lock_page() (see above comments).
  	 */
-	btrfs_clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
+	btrfs_clear_extent_bit(io_tree, page_start, end,
  			       EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
  			       EXTENT_DEFRAG, &cached_state);
 
#6 lore raw

PATCH 3/3 btrfs: use btrfs_inode local variable at btrfs_page_mkwrite()

In reply to [email protected]

From: Filipe Manana <[email protected]>

Most of the time we want to use the btrfs_inode, so change the local inode variable to be a btrfs_inode instead of a vfs inode, reducing verbosity by eleminating a lot of BTRFS_I() calls.

---
 fs/btrfs/file.c | 58 ++++++++++++++++++++++++-------------------------
 1 file changed, 28 insertions(+), 30 deletions(-)
fs/btrfs/file.c +28 -30
index e76e92873de5..765ffa06688b 100644
@@ -1831,9 +1831,9 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 {
 	struct page *page = vmf->page;
 	struct folio *folio = page_folio(page);
-	struct inode *inode = file_inode(vmf->vma->vm_file);
-	struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);
-	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
+	struct btrfs_inode *inode = BTRFS_I(file_inode(vmf->vma->vm_file));
+	struct btrfs_fs_info *fs_info = inode->root->fs_info;
+	struct extent_io_tree *io_tree = &inode->io_tree;
 	struct btrfs_ordered_extent *ordered;
 	struct extent_state *cached_state = NULL;
 	struct extent_changeset *data_reserved = NULL;
@@ -1849,7 +1849,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
 	reserved_space = fsize;
 
-	sb_start_pagefault(inode->i_sb);
+	sb_start_pagefault(inode->vfs_inode.i_sb);
 	page_start = folio_pos(folio);
 	page_end = page_start + folio_size(folio) - 1;
 	end = page_end;
@@ -1862,13 +1862,12 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * end up waiting indefinitely to get a lock on the page currently
 	 * being processed by btrfs_page_mkwrite() function.
 	 */
-	ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved,
-					  page_start, reserved_space, false);
+	ret = btrfs_check_data_free_space(inode, &data_reserved, page_start,
+					  reserved_space, false);
 	if (ret < 0) {
 		size_t write_bytes = reserved_space;
 
-		if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
-					   &write_bytes, false) <= 0)
+		if (btrfs_check_nocow_lock(inode, page_start, &write_bytes, false) <= 0)
 			goto out_noreserve;
 
 		if (write_bytes < reserved_space)
@@ -1876,11 +1875,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
 		only_release_metadata = true;
 	}
-	ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+	ret = btrfs_delalloc_reserve_metadata(inode, reserved_space,
 					      reserved_space, false);
 	if (ret < 0) {
 		if (!only_release_metadata)
-			btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+			btrfs_free_reserved_data_space(inode, data_reserved,
 						       page_start, reserved_space);
 		goto out_noreserve;
 	}
@@ -1889,11 +1888,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	if (ret < 0)
 		goto out;
 again:
-	down_read(&BTRFS_I(inode)->i_mmap_lock);
+	down_read(&inode->i_mmap_lock);
 	folio_lock(folio);
-	size = i_size_read(inode);
+	size = i_size_read(&inode->vfs_inode);
 
-	if ((folio->mapping != inode->i_mapping) ||
+	if ((folio->mapping != inode->vfs_inode.i_mapping) ||
 	    (page_start >= size)) {
 		/* Page got truncated out from underneath us. */
 		goto out_unlock;
@@ -1911,11 +1910,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * We can't set the delalloc bits if there are pending ordered
 	 * extents.  Drop our locks and wait for them to finish.
 	 */
-	ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start, fsize);
+	ordered = btrfs_lookup_ordered_range(inode, page_start, fsize);
 	if (ordered) {
 		btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 		folio_unlock(folio);
-		up_read(&BTRFS_I(inode)->i_mmap_lock);
+		up_read(&inode->i_mmap_lock);
 		btrfs_start_ordered_extent(ordered);
 		btrfs_put_ordered_extent(ordered);
 		goto again;
@@ -1926,7 +1925,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 		if (reserved_space < fsize) {
 			end = page_start + reserved_space - 1;
 			if (!only_release_metadata)
-				btrfs_delalloc_release_space(BTRFS_I(inode),
+				btrfs_delalloc_release_space(inode,
 							     data_reserved, end + 1,
 							     fsize - reserved_space,
 							     true);
@@ -1944,8 +1943,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 			       EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
 			       EXTENT_DEFRAG, &cached_state);
 
-	ret = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
-					&cached_state);
+	ret = btrfs_set_extent_delalloc(inode, page_start, end, 0, &cached_state);
 	if (ret < 0) {
 		btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 		goto out_unlock;
@@ -1964,38 +1962,38 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start);
 	btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start);
 
-	btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
+	btrfs_set_inode_last_sub_trans(inode);
 
 	if (only_release_metadata)
 		btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
 				     &cached_state);
 
 	btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
-	up_read(&BTRFS_I(inode)->i_mmap_lock);
+	up_read(&inode->i_mmap_lock);
 
-	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	btrfs_delalloc_release_extents(inode, fsize);
 	if (only_release_metadata)
-		btrfs_check_nocow_unlock(BTRFS_I(inode));
-	sb_end_pagefault(inode->i_sb);
+		btrfs_check_nocow_unlock(inode);
+	sb_end_pagefault(inode->vfs_inode.i_sb);
 	extent_changeset_free(data_reserved);
 	return VM_FAULT_LOCKED;
 
 out_unlock:
 	folio_unlock(folio);
-	up_read(&BTRFS_I(inode)->i_mmap_lock);
+	up_read(&inode->i_mmap_lock);
 out:
-	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	btrfs_delalloc_release_extents(inode, fsize);
 	if (only_release_metadata)
-		btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+		btrfs_delalloc_release_metadata(inode, reserved_space, true);
 	else
-		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
-					     page_start, reserved_space, true);
+		btrfs_delalloc_release_space(inode, data_reserved, page_start,
+					     reserved_space, true);
 	extent_changeset_free(data_reserved);
 out_noreserve:
 	if (only_release_metadata)
-		btrfs_check_nocow_unlock(BTRFS_I(inode));
+		btrfs_check_nocow_unlock(inode);
 
-	sb_end_pagefault(inode->i_sb);
+	sb_end_pagefault(inode->vfs_inode.i_sb);
 
 	if (ret < 0)
 		return vmf_error(ret);
Signature · 1 line
2.47.2
Reviewed-by on v1 3/3
#7 lore raw

Re: [PATCH 3/3] btrfs: use btrfs_inode local variable at btrfs_page_mkwrite()

Quoted 7 lines · 在 2025/7/9 18:23, [email protected] 写道:

From: Filipe Manana <[email protected]>

Most of the time we want to use the btrfs_inode, so change the local inode variable to be a btrfs_inode instead of a vfs inode, reducing verbosity by eleminating a lot of BTRFS_I() calls.

fs/btrfs/file.c static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) · line 1870

Quoted 3 lines
fs/btrfs/file.c +1 -2
-		if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
-					   &write_bytes, false) <= 0)
+		if (btrfs_check_nocow_lock(inode, page_start, &write_bytes, false) <= 0)

I guess we are no longer limited by 80 chars line limit anymore?

What would be the new limit? 100 from checkpatch or something slightly lower like 90?

Thanks,
Qu

Quoted 116 lines

goto out_noreserve;

if (write_bytes < reserved_space)

fs/btrfs/file.c +21 -22
@@ -1876,11 +1875,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
  		only_release_metadata = true;
  	}
-	ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+	ret = btrfs_delalloc_reserve_metadata(inode, reserved_space,
  					      reserved_space, false);
  	if (ret < 0) {
  		if (!only_release_metadata)
-			btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+			btrfs_free_reserved_data_space(inode, data_reserved,
  						       page_start, reserved_space);
  		goto out_noreserve;
  	}
@@ -1889,11 +1888,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  	if (ret < 0)
  		goto out;
  again:
-	down_read(&BTRFS_I(inode)->i_mmap_lock);
+	down_read(&inode->i_mmap_lock);
  	folio_lock(folio);
-	size = i_size_read(inode);
+	size = i_size_read(&inode->vfs_inode);
 
-	if ((folio->mapping != inode->i_mapping) ||
+	if ((folio->mapping != inode->vfs_inode.i_mapping) ||
  	    (page_start >= size)) {
  		/* Page got truncated out from underneath us. */
  		goto out_unlock;
@@ -1911,11 +1910,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  	 * We can't set the delalloc bits if there are pending ordered
  	 * extents.  Drop our locks and wait for them to finish.
  	 */
-	ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start, fsize);
+	ordered = btrfs_lookup_ordered_range(inode, page_start, fsize);
  	if (ordered) {
  		btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
  		folio_unlock(folio);
-		up_read(&BTRFS_I(inode)->i_mmap_lock);
+		up_read(&inode->i_mmap_lock);
  		btrfs_start_ordered_extent(ordered);
  		btrfs_put_ordered_extent(ordered);
  		goto again;
@@ -1926,7 +1925,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  		if (reserved_space < fsize) {
  			end = page_start + reserved_space - 1;
  			if (!only_release_metadata)
-				btrfs_delalloc_release_space(BTRFS_I(inode),
+				btrfs_delalloc_release_space(inode,
  							     data_reserved, end + 1,
  							     fsize - reserved_space,
  							     true);
@@ -1944,8 +1943,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  			       EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
  			       EXTENT_DEFRAG, &cached_state);
 
-	ret = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
-					&cached_state);
+	ret = btrfs_set_extent_delalloc(inode, page_start, end, 0, &cached_state);
  	if (ret < 0) {
  		btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
  		goto out_unlock;
@@ -1964,38 +1962,38 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
  	btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start);
  	btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start);
 
-	btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
+	btrfs_set_inode_last_sub_trans(inode);
 
  	if (only_release_metadata)
  		btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
  				     &cached_state);
 
  	btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
-	up_read(&BTRFS_I(inode)->i_mmap_lock);
+	up_read(&inode->i_mmap_lock);
 
-	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	btrfs_delalloc_release_extents(inode, fsize);
  	if (only_release_metadata)
-		btrfs_check_nocow_unlock(BTRFS_I(inode));
-	sb_end_pagefault(inode->i_sb);
+		btrfs_check_nocow_unlock(inode);
+	sb_end_pagefault(inode->vfs_inode.i_sb);
  	extent_changeset_free(data_reserved);
  	return VM_FAULT_LOCKED;
 
  out_unlock:
  	folio_unlock(folio);
-	up_read(&BTRFS_I(inode)->i_mmap_lock);
+	up_read(&inode->i_mmap_lock);
  out:
-	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	btrfs_delalloc_release_extents(inode, fsize);
  	if (only_release_metadata)
-		btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+		btrfs_delalloc_release_metadata(inode, reserved_space, true);
  	else
-		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
-					     page_start, reserved_space, true);
+		btrfs_delalloc_release_space(inode, data_reserved, page_start,
+					     reserved_space, true);
  	extent_changeset_free(data_reserved);
  out_noreserve:
  	if (only_release_metadata)
-		btrfs_check_nocow_unlock(BTRFS_I(inode));
+		btrfs_check_nocow_unlock(inode);
 
-	sb_end_pagefault(inode->i_sb);
+	sb_end_pagefault(inode->vfs_inode.i_sb);
 
  	if (ret < 0)
  		return vmf_error(ret);
#8 lore raw

Re: [PATCH 3/3] btrfs: use btrfs_inode local variable at btrfs_page_mkwrite()

Quoted 12 lines · Qu Wenruo
Quoted 7 lines · 在 2025/7/9 18:23, [email protected] 写道:

From: Filipe Manana <[email protected]>

Most of the time we want to use the btrfs_inode, so change the local inode variable to be a btrfs_inode instead of a vfs inode, reducing verbosity by eleminating a lot of BTRFS_I() calls.

Quoted 7 lines

fs/btrfs/file.c static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) · line 1870

Quoted 3 lines
fs/btrfs/file.c +1 -2
-             if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
-                                        &write_bytes, false) <= 0)
+             if (btrfs_check_nocow_lock(inode, page_start, &write_bytes, false) <= 0)

I guess we are no longer limited by 80 chars line limit anymore?

No we aren't, and it shouldn't be news to anyone anymore, it's been well over a year, maybe two.
I've commented in reviews several times to avoid line splits when the total length doesn't exceed 80 characters by too much.

Quoted 3 lines

What would be the new limit? 100 from checkpatch or something slightly lower like 90?

Within reasonability, in this case it's 88 characters and it makes the code more readable.

Thanks.

Quoted 121 lines

Thanks,
Qu

Quoted 116 lines

goto out_noreserve;

if (write_bytes < reserved_space)

fs/btrfs/file.c +21 -22
@@ -1876,11 +1875,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
              only_release_metadata = true;
      }
-     ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+     ret = btrfs_delalloc_reserve_metadata(inode, reserved_space,
                                            reserved_space, false);
      if (ret < 0) {
              if (!only_release_metadata)
-                     btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+                     btrfs_free_reserved_data_space(inode, data_reserved,
                                                     page_start, reserved_space);
              goto out_noreserve;
      }
@@ -1889,11 +1888,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
      if (ret < 0)
              goto out;
  again:
-     down_read(&BTRFS_I(inode)->i_mmap_lock);
+     down_read(&inode->i_mmap_lock);
      folio_lock(folio);
-     size = i_size_read(inode);
+     size = i_size_read(&inode->vfs_inode);
 
-     if ((folio->mapping != inode->i_mapping) ||
+     if ((folio->mapping != inode->vfs_inode.i_mapping) ||
          (page_start >= size)) {
              /* Page got truncated out from underneath us. */
              goto out_unlock;
@@ -1911,11 +1910,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
       * We can't set the delalloc bits if there are pending ordered
       * extents.  Drop our locks and wait for them to finish.
       */
-     ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start, fsize);
+     ordered = btrfs_lookup_ordered_range(inode, page_start, fsize);
      if (ordered) {
              btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
              folio_unlock(folio);
-             up_read(&BTRFS_I(inode)->i_mmap_lock);
+             up_read(&inode->i_mmap_lock);
              btrfs_start_ordered_extent(ordered);
              btrfs_put_ordered_extent(ordered);
              goto again;
@@ -1926,7 +1925,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
              if (reserved_space < fsize) {
                      end = page_start + reserved_space - 1;
                      if (!only_release_metadata)
-                             btrfs_delalloc_release_space(BTRFS_I(inode),
+                             btrfs_delalloc_release_space(inode,
                                                           data_reserved, end + 1,
                                                           fsize - reserved_space,
                                                           true);
@@ -1944,8 +1943,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
                             EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
                             EXTENT_DEFRAG, &cached_state);
 
-     ret = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
-                                     &cached_state);
+     ret = btrfs_set_extent_delalloc(inode, page_start, end, 0, &cached_state);
      if (ret < 0) {
              btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
              goto out_unlock;
@@ -1964,38 +1962,38 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
      btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start);
      btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start);
 
-     btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
+     btrfs_set_inode_last_sub_trans(inode);
 
      if (only_release_metadata)
              btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
                                   &cached_state);
 
      btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
-     up_read(&BTRFS_I(inode)->i_mmap_lock);
+     up_read(&inode->i_mmap_lock);
 
-     btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+     btrfs_delalloc_release_extents(inode, fsize);
      if (only_release_metadata)
-             btrfs_check_nocow_unlock(BTRFS_I(inode));
-     sb_end_pagefault(inode->i_sb);
+             btrfs_check_nocow_unlock(inode);
+     sb_end_pagefault(inode->vfs_inode.i_sb);
      extent_changeset_free(data_reserved);
      return VM_FAULT_LOCKED;
 
  out_unlock:
      folio_unlock(folio);
-     up_read(&BTRFS_I(inode)->i_mmap_lock);
+     up_read(&inode->i_mmap_lock);
  out:
-     btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+     btrfs_delalloc_release_extents(inode, fsize);
      if (only_release_metadata)
-             btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+             btrfs_delalloc_release_metadata(inode, reserved_space, true);
      else
-             btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
-                                          page_start, reserved_space, true);
+             btrfs_delalloc_release_space(inode, data_reserved, page_start,
+                                          reserved_space, true);
      extent_changeset_free(data_reserved);
  out_noreserve:
      if (only_release_metadata)
-             btrfs_check_nocow_unlock(BTRFS_I(inode));
+             btrfs_check_nocow_unlock(inode);
 
-     sb_end_pagefault(inode->i_sb);
+     sb_end_pagefault(inode->vfs_inode.i_sb);
 
      if (ret < 0)
              return vmf_error(ret);
#9 lore raw

v2 cover btrfs: fix mmap writes for NOCOW files/extents

In reply to [email protected]

From: Filipe Manana <[email protected]>

A bug fix and a couple cleanups. Details in the individual change logs.

V2: Fix a bug in patch 1/3 where if write_bytes < reserved_space we would
exit without unlocking the cow lock, so set only_release_metadata to true before bailing out in that case.
Added Qu's review tags.

Filipe Manana (3):
btrfs: fix -ENOSPC mmap write failure on NOCOW files/extents
btrfs: use variable for io_tree when clearing range in btrfs_page_mkwrite()
btrfs: use btrfs_inode local variable at btrfs_page_mkwrite()

 fs/btrfs/file.c | 91 ++++++++++++++++++++++++++++++++++---------------
 1 file changed, 64 insertions(+), 27 deletions(-)
Signature · 1 line
2.47.2
#10 lore raw

PATCH v2 1/3 btrfs: fix -ENOSPC mmap write failure on NOCOW files/extents

From: Filipe Manana <[email protected]>

If we attempt a mmap write into a NOCOW file or a prealloc extent when there is no more available data space (or unallocated space to allocate a new data block group) and we can do a NOCOW write (there are no reflinks for the target extent or snapshots), we always fail due to -ENOSPC, unlike for the regular buffered write and direct IO paths where we check that we can do a NOCOW write in case we can't reserve data space.

Simple reproducer:

  $ cat test.sh
  #!/bin/bash

DEV=/dev/sdi
MNT=/mnt/sdi

  umount $DEV &> /dev/null
  mkfs.btrfs -f -b $((512 * 1024 * 1024)) $DEV
  mount $DEV $MNT

touch $MNT/foobar
# Make it a NOCOW file.
chattr +C $MNT/foobar

# Add initial data to file.
xfs_io -c "pwrite -S 0xab 0 1M" $MNT/foobar

# Fill all the remaining data space and unallocated space with data. dd if=/dev/zero of=$MNT/filler bs=4K &> /dev/null

  # Overwrite the file with a mmap write. Should succeed.
  xfs_io -c "mmap -w 0 1M"        \
         -c "mwrite -S 0xcd 0 1M" \
         -c "munmap"              \
         $MNT/foobar

# Unmount, mount again and verify the new data was persisted. umount $MNT
mount $DEV $MNT

od -A d -t x1 $MNT/foobar

umount $MNT

Running this:

  $ ./test.sh
  (...)
  wrote 1048576/1048576 bytes at offset 0
  1 MiB, 256 ops; 0.0008 sec (1.188 GiB/sec and 311435.5231 ops/sec)
  ./test.sh: line 24: 234865 Bus error               xfs_io -c "mmap -w 0 1M" -c "mwrite -S 0xcd 0 1M" -c "munmap" $MNT/foobar
  0000000 ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
  *
  1048576

Fix this by not failing in case we can't allocate data space and we can NOCOW into the target extent - reserving only metadata space in this case.

After this change the test passes:

  $ ./test.sh
  (...)
  wrote 1048576/1048576 bytes at offset 0
  1 MiB, 256 ops; 0.0007 sec (1.262 GiB/sec and 330749.3540 ops/sec)
  0000000 cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd
  *
  1048576

A test case for fstests will be added soon.

---
 fs/btrfs/file.c | 55 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 47 insertions(+), 8 deletions(-)
fs/btrfs/file.c +47 -8
index 05b046c6806f..9ea3b4d47f81 100644
@@ -1841,6 +1841,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	loff_t size;
 	size_t fsize = folio_size(folio);
 	int ret;
+	bool only_release_metadata = false;
 	u64 reserved_space;
 	u64 page_start;
 	u64 page_end;
@@ -1861,10 +1862,34 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * end up waiting indefinitely to get a lock on the page currently
 	 * being processed by btrfs_page_mkwrite() function.
 	 */
-	ret = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
-					   page_start, reserved_space);
-	if (ret < 0)
+	ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved,
+					  page_start, reserved_space, false);
+	if (ret < 0) {
+		size_t write_bytes = reserved_space;
+
+		if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
+					   &write_bytes, false) <= 0)
+			goto out_noreserve;
+
+		only_release_metadata = true;
+
+		/*
+		 * Can't write the whole range, there may be shared extents or
+		 * holes in the range, bail out with @only_release_metadata set
+		 * to true so that we unlock the nocow lock before returning the
+		 * error.
+		 */
+		if (write_bytes < reserved_space)
+			goto out_noreserve;
+	}
+	ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+					      reserved_space, false);
+	if (ret < 0) {
+		if (!only_release_metadata)
+			btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+						       page_start, reserved_space);
 		goto out_noreserve;
+	}
 
 	ret = file_update_time(vmf->vma->vm_file);
 	if (ret < 0)
@@ -1906,9 +1931,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 		reserved_space = round_up(size - page_start, fs_info->sectorsize);
 		if (reserved_space < fsize) {
 			end = page_start + reserved_space - 1;
-			btrfs_delalloc_release_space(BTRFS_I(inode),
-					data_reserved, end + 1,
-					fsize - reserved_space, true);
+			if (!only_release_metadata)
+				btrfs_delalloc_release_space(BTRFS_I(inode),
+							     data_reserved, end + 1,
+							     fsize - reserved_space,
+							     true);
 		}
 	}
 
@@ -1945,10 +1972,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
 	btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
 
+	if (only_release_metadata)
+		btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
+				     &cached_state);
+
 	btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 	up_read(&BTRFS_I(inode)->i_mmap_lock);
 
 	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	if (only_release_metadata)
+		btrfs_check_nocow_unlock(BTRFS_I(inode));
 	sb_end_pagefault(inode->i_sb);
 	extent_changeset_free(data_reserved);
 	return VM_FAULT_LOCKED;
@@ -1958,10 +1991,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	up_read(&BTRFS_I(inode)->i_mmap_lock);
 out:
 	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
-	btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
-				     reserved_space, true);
+	if (only_release_metadata)
+		btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+	else
+		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
+					     page_start, reserved_space, true);
 	extent_changeset_free(data_reserved);
 out_noreserve:
+	if (only_release_metadata)
+		btrfs_check_nocow_unlock(BTRFS_I(inode));
+
 	sb_end_pagefault(inode->i_sb);
 
 	if (ret < 0)
Signature · 1 line
2.47.2
#11 lore raw

PATCH v2 2/3 btrfs: use variable for io_tree when clearing range in btrfs_page_mkwrite()

In reply to [email protected]

From: Filipe Manana <[email protected]>

We have the inode's io_tree already stored in a local variable, so use it instead of grabbing it again in the call to btrfs_clear_extent_bit().

---
 fs/btrfs/file.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/btrfs/file.c +1 -1
index 9ea3b4d47f81..80a828f39bbd 100644
@@ -1946,7 +1946,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * clear any delalloc bits within this page range since we have to
 	 * reserve data&meta space before lock_page() (see above comments).
 	 */
-	btrfs_clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
+	btrfs_clear_extent_bit(io_tree, page_start, end,
 			       EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
 			       EXTENT_DEFRAG, &cached_state);
 
Signature · 1 line
2.47.2
#12 lore raw

PATCH v2 3/3 btrfs: use btrfs_inode local variable at btrfs_page_mkwrite()

In reply to [email protected]

From: Filipe Manana <[email protected]>

Most of the time we want to use the btrfs_inode, so change the local inode variable to be a btrfs_inode instead of a vfs inode, reducing verbosity by eleminating a lot of BTRFS_I() calls.

---
 fs/btrfs/file.c | 58 ++++++++++++++++++++++++-------------------------
 1 file changed, 28 insertions(+), 30 deletions(-)
fs/btrfs/file.c +28 -30
index 80a828f39bbd..d1f5da14f6d1 100644
@@ -1831,9 +1831,9 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 {
 	struct page *page = vmf->page;
 	struct folio *folio = page_folio(page);
-	struct inode *inode = file_inode(vmf->vma->vm_file);
-	struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);
-	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
+	struct btrfs_inode *inode = BTRFS_I(file_inode(vmf->vma->vm_file));
+	struct btrfs_fs_info *fs_info = inode->root->fs_info;
+	struct extent_io_tree *io_tree = &inode->io_tree;
 	struct btrfs_ordered_extent *ordered;
 	struct extent_state *cached_state = NULL;
 	struct extent_changeset *data_reserved = NULL;
@@ -1849,7 +1849,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
 	reserved_space = fsize;
 
-	sb_start_pagefault(inode->i_sb);
+	sb_start_pagefault(inode->vfs_inode.i_sb);
 	page_start = folio_pos(folio);
 	page_end = page_start + folio_size(folio) - 1;
 	end = page_end;
@@ -1862,13 +1862,12 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * end up waiting indefinitely to get a lock on the page currently
 	 * being processed by btrfs_page_mkwrite() function.
 	 */
-	ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved,
-					  page_start, reserved_space, false);
+	ret = btrfs_check_data_free_space(inode, &data_reserved, page_start,
+					  reserved_space, false);
 	if (ret < 0) {
 		size_t write_bytes = reserved_space;
 
-		if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
-					   &write_bytes, false) <= 0)
+		if (btrfs_check_nocow_lock(inode, page_start, &write_bytes, false) <= 0)
 			goto out_noreserve;
 
 		only_release_metadata = true;
@@ -1882,11 +1881,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 		if (write_bytes < reserved_space)
 			goto out_noreserve;
 	}
-	ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+	ret = btrfs_delalloc_reserve_metadata(inode, reserved_space,
 					      reserved_space, false);
 	if (ret < 0) {
 		if (!only_release_metadata)
-			btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+			btrfs_free_reserved_data_space(inode, data_reserved,
 						       page_start, reserved_space);
 		goto out_noreserve;
 	}
@@ -1895,11 +1894,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	if (ret < 0)
 		goto out;
 again:
-	down_read(&BTRFS_I(inode)->i_mmap_lock);
+	down_read(&inode->i_mmap_lock);
 	folio_lock(folio);
-	size = i_size_read(inode);
+	size = i_size_read(&inode->vfs_inode);
 
-	if ((folio->mapping != inode->i_mapping) ||
+	if ((folio->mapping != inode->vfs_inode.i_mapping) ||
 	    (page_start >= size)) {
 		/* Page got truncated out from underneath us. */
 		goto out_unlock;
@@ -1917,11 +1916,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * We can't set the delalloc bits if there are pending ordered
 	 * extents.  Drop our locks and wait for them to finish.
 	 */
-	ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start, fsize);
+	ordered = btrfs_lookup_ordered_range(inode, page_start, fsize);
 	if (ordered) {
 		btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 		folio_unlock(folio);
-		up_read(&BTRFS_I(inode)->i_mmap_lock);
+		up_read(&inode->i_mmap_lock);
 		btrfs_start_ordered_extent(ordered);
 		btrfs_put_ordered_extent(ordered);
 		goto again;
@@ -1932,7 +1931,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 		if (reserved_space < fsize) {
 			end = page_start + reserved_space - 1;
 			if (!only_release_metadata)
-				btrfs_delalloc_release_space(BTRFS_I(inode),
+				btrfs_delalloc_release_space(inode,
 							     data_reserved, end + 1,
 							     fsize - reserved_space,
 							     true);
@@ -1950,8 +1949,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 			       EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
 			       EXTENT_DEFRAG, &cached_state);
 
-	ret = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
-					&cached_state);
+	ret = btrfs_set_extent_delalloc(inode, page_start, end, 0, &cached_state);
 	if (ret < 0) {
 		btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 		goto out_unlock;
@@ -1970,38 +1968,38 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start);
 	btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start);
 
-	btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
+	btrfs_set_inode_last_sub_trans(inode);
 
 	if (only_release_metadata)
 		btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
 				     &cached_state);
 
 	btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
-	up_read(&BTRFS_I(inode)->i_mmap_lock);
+	up_read(&inode->i_mmap_lock);
 
-	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	btrfs_delalloc_release_extents(inode, fsize);
 	if (only_release_metadata)
-		btrfs_check_nocow_unlock(BTRFS_I(inode));
-	sb_end_pagefault(inode->i_sb);
+		btrfs_check_nocow_unlock(inode);
+	sb_end_pagefault(inode->vfs_inode.i_sb);
 	extent_changeset_free(data_reserved);
 	return VM_FAULT_LOCKED;
 
 out_unlock:
 	folio_unlock(folio);
-	up_read(&BTRFS_I(inode)->i_mmap_lock);
+	up_read(&inode->i_mmap_lock);
 out:
-	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	btrfs_delalloc_release_extents(inode, fsize);
 	if (only_release_metadata)
-		btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+		btrfs_delalloc_release_metadata(inode, reserved_space, true);
 	else
-		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
-					     page_start, reserved_space, true);
+		btrfs_delalloc_release_space(inode, data_reserved, page_start,
+					     reserved_space, true);
 	extent_changeset_free(data_reserved);
 out_noreserve:
 	if (only_release_metadata)
-		btrfs_check_nocow_unlock(BTRFS_I(inode));
+		btrfs_check_nocow_unlock(inode);
 
-	sb_end_pagefault(inode->i_sb);
+	sb_end_pagefault(inode->vfs_inode.i_sb);
 
 	if (ret < 0)
 		return vmf_error(ret);
Signature · 1 line
2.47.2
#13 lore raw

v3 cover btrfs: fix mmap writes for NOCOW files/extents

In reply to [email protected]

From: Filipe Manana <[email protected]>

A bug fix and a couple cleanups. Details in the individual change logs.

V2: Fix a bug in patch 1/3 where if write_bytes < reserved_space we would
exit without unlocking the cow lock, so set only_release_metadata to true before bailing out in that case.
Added Qu's review tags.

V3: Add missing release of metadata reserved space in case we fall
back to NOCOW mode and we are in a folio that contains i_size somewhere in its middle

Filipe Manana (3):
btrfs: fix -ENOSPC mmap write failure on NOCOW files/extents
btrfs: use variable for io_tree when clearing range in btrfs_page_mkwrite()
btrfs: use btrfs_inode local variable at btrfs_page_mkwrite()

 fs/btrfs/file.c | 93 +++++++++++++++++++++++++++++++++++--------------
 1 file changed, 66 insertions(+), 27 deletions(-)
Signature · 1 line
2.47.2
#14 lore raw

PATCH v3 1/3 btrfs: fix -ENOSPC mmap write failure on NOCOW files/extents

From: Filipe Manana <[email protected]>

If we attempt a mmap write into a NOCOW file or a prealloc extent when there is no more available data space (or unallocated space to allocate a new data block group) and we can do a NOCOW write (there are no reflinks for the target extent or snapshots), we always fail due to -ENOSPC, unlike for the regular buffered write and direct IO paths where we check that we can do a NOCOW write in case we can't reserve data space.

Simple reproducer:

  $ cat test.sh
  #!/bin/bash

DEV=/dev/sdi
MNT=/mnt/sdi

  umount $DEV &> /dev/null
  mkfs.btrfs -f -b $((512 * 1024 * 1024)) $DEV
  mount $DEV $MNT

touch $MNT/foobar
# Make it a NOCOW file.
chattr +C $MNT/foobar

# Add initial data to file.
xfs_io -c "pwrite -S 0xab 0 1M" $MNT/foobar

# Fill all the remaining data space and unallocated space with data. dd if=/dev/zero of=$MNT/filler bs=4K &> /dev/null

  # Overwrite the file with a mmap write. Should succeed.
  xfs_io -c "mmap -w 0 1M"        \
         -c "mwrite -S 0xcd 0 1M" \
         -c "munmap"              \
         $MNT/foobar

# Unmount, mount again and verify the new data was persisted. umount $MNT
mount $DEV $MNT

od -A d -t x1 $MNT/foobar

umount $MNT

Running this:

  $ ./test.sh
  (...)
  wrote 1048576/1048576 bytes at offset 0
  1 MiB, 256 ops; 0.0008 sec (1.188 GiB/sec and 311435.5231 ops/sec)
  ./test.sh: line 24: 234865 Bus error               xfs_io -c "mmap -w 0 1M" -c "mwrite -S 0xcd 0 1M" -c "munmap" $MNT/foobar
  0000000 ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
  *
  1048576

Fix this by not failing in case we can't allocate data space and we can NOCOW into the target extent - reserving only metadata space in this case.

After this change the test passes:

  $ ./test.sh
  (...)
  wrote 1048576/1048576 bytes at offset 0
  1 MiB, 256 ops; 0.0007 sec (1.262 GiB/sec and 330749.3540 ops/sec)
  0000000 cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd cd
  *
  1048576

A test case for fstests will be added soon.

---
 fs/btrfs/file.c | 59 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 51 insertions(+), 8 deletions(-)
fs/btrfs/file.c +51 -8
index 05b046c6806f..cb07274d4126 100644
@@ -1841,6 +1841,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	loff_t size;
 	size_t fsize = folio_size(folio);
 	int ret;
+	bool only_release_metadata = false;
 	u64 reserved_space;
 	u64 page_start;
 	u64 page_end;
@@ -1861,10 +1862,34 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * end up waiting indefinitely to get a lock on the page currently
 	 * being processed by btrfs_page_mkwrite() function.
 	 */
-	ret = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
-					   page_start, reserved_space);
-	if (ret < 0)
+	ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved,
+					  page_start, reserved_space, false);
+	if (ret < 0) {
+		size_t write_bytes = reserved_space;
+
+		if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
+					   &write_bytes, false) <= 0)
+			goto out_noreserve;
+
+		only_release_metadata = true;
+
+		/*
+		 * Can't write the whole range, there may be shared extents or
+		 * holes in the range, bail out with @only_release_metadata set
+		 * to true so that we unlock the nocow lock before returning the
+		 * error.
+		 */
+		if (write_bytes < reserved_space)
+			goto out_noreserve;
+	}
+	ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+					      reserved_space, false);
+	if (ret < 0) {
+		if (!only_release_metadata)
+			btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+						       page_start, reserved_space);
 		goto out_noreserve;
+	}
 
 	ret = file_update_time(vmf->vma->vm_file);
 	if (ret < 0)
@@ -1905,10 +1930,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	if (folio_contains(folio, (size - 1) >> PAGE_SHIFT)) {
 		reserved_space = round_up(size - page_start, fs_info->sectorsize);
 		if (reserved_space < fsize) {
+			const u64 to_free = fsize - reserved_space;
+
 			end = page_start + reserved_space - 1;
-			btrfs_delalloc_release_space(BTRFS_I(inode),
-					data_reserved, end + 1,
-					fsize - reserved_space, true);
+			if (only_release_metadata)
+				btrfs_delalloc_release_metadata(BTRFS_I(inode),
+								to_free, true);
+			else
+				btrfs_delalloc_release_space(BTRFS_I(inode),
+							     data_reserved, end + 1,
+							     to_free, true);
 		}
 	}
 
@@ -1945,10 +1976,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
 	btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
 
+	if (only_release_metadata)
+		btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
+				     &cached_state);
+
 	btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 	up_read(&BTRFS_I(inode)->i_mmap_lock);
 
 	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	if (only_release_metadata)
+		btrfs_check_nocow_unlock(BTRFS_I(inode));
 	sb_end_pagefault(inode->i_sb);
 	extent_changeset_free(data_reserved);
 	return VM_FAULT_LOCKED;
@@ -1958,10 +1995,16 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	up_read(&BTRFS_I(inode)->i_mmap_lock);
 out:
 	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
-	btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
-				     reserved_space, true);
+	if (only_release_metadata)
+		btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+	else
+		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
+					     page_start, reserved_space, true);
 	extent_changeset_free(data_reserved);
 out_noreserve:
+	if (only_release_metadata)
+		btrfs_check_nocow_unlock(BTRFS_I(inode));
+
 	sb_end_pagefault(inode->i_sb);
 
 	if (ret < 0)
Signature · 1 line
2.47.2
#15 lore raw

PATCH v3 2/3 btrfs: use variable for io_tree when clearing range in btrfs_page_mkwrite()

In reply to [email protected]

From: Filipe Manana <[email protected]>

We have the inode's io_tree already stored in a local variable, so use it instead of grabbing it again in the call to btrfs_clear_extent_bit().

---
 fs/btrfs/file.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/btrfs/file.c +1 -1
index cb07274d4126..e11b1733e3ae 100644
@@ -1950,7 +1950,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * clear any delalloc bits within this page range since we have to
 	 * reserve data&meta space before lock_page() (see above comments).
 	 */
-	btrfs_clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
+	btrfs_clear_extent_bit(io_tree, page_start, end,
 			       EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
 			       EXTENT_DEFRAG, &cached_state);
 
Signature · 1 line
2.47.2
#16 lore raw

PATCH v3 3/3 btrfs: use btrfs_inode local variable at btrfs_page_mkwrite()

In reply to [email protected]

From: Filipe Manana <[email protected]>

Most of the time we want to use the btrfs_inode, so change the local inode variable to be a btrfs_inode instead of a vfs inode, reducing verbosity by eleminating a lot of BTRFS_I() calls.

---
 fs/btrfs/file.c | 64 +++++++++++++++++++++++--------------------------
 1 file changed, 30 insertions(+), 34 deletions(-)
fs/btrfs/file.c +30 -34
index e11b1733e3ae..37bf473f2132 100644
@@ -1831,9 +1831,9 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 {
 	struct page *page = vmf->page;
 	struct folio *folio = page_folio(page);
-	struct inode *inode = file_inode(vmf->vma->vm_file);
-	struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);
-	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
+	struct btrfs_inode *inode = BTRFS_I(file_inode(vmf->vma->vm_file));
+	struct btrfs_fs_info *fs_info = inode->root->fs_info;
+	struct extent_io_tree *io_tree = &inode->io_tree;
 	struct btrfs_ordered_extent *ordered;
 	struct extent_state *cached_state = NULL;
 	struct extent_changeset *data_reserved = NULL;
@@ -1849,7 +1849,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
 	reserved_space = fsize;
 
-	sb_start_pagefault(inode->i_sb);
+	sb_start_pagefault(inode->vfs_inode.i_sb);
 	page_start = folio_pos(folio);
 	page_end = page_start + folio_size(folio) - 1;
 	end = page_end;
@@ -1862,13 +1862,12 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * end up waiting indefinitely to get a lock on the page currently
 	 * being processed by btrfs_page_mkwrite() function.
 	 */
-	ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved,
-					  page_start, reserved_space, false);
+	ret = btrfs_check_data_free_space(inode, &data_reserved, page_start,
+					  reserved_space, false);
 	if (ret < 0) {
 		size_t write_bytes = reserved_space;
 
-		if (btrfs_check_nocow_lock(BTRFS_I(inode), page_start,
-					   &write_bytes, false) <= 0)
+		if (btrfs_check_nocow_lock(inode, page_start, &write_bytes, false) <= 0)
 			goto out_noreserve;
 
 		only_release_metadata = true;
@@ -1882,11 +1881,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 		if (write_bytes < reserved_space)
 			goto out_noreserve;
 	}
-	ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), reserved_space,
+	ret = btrfs_delalloc_reserve_metadata(inode, reserved_space,
 					      reserved_space, false);
 	if (ret < 0) {
 		if (!only_release_metadata)
-			btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
+			btrfs_free_reserved_data_space(inode, data_reserved,
 						       page_start, reserved_space);
 		goto out_noreserve;
 	}
@@ -1895,11 +1894,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	if (ret < 0)
 		goto out;
 again:
-	down_read(&BTRFS_I(inode)->i_mmap_lock);
+	down_read(&inode->i_mmap_lock);
 	folio_lock(folio);
-	size = i_size_read(inode);
+	size = i_size_read(&inode->vfs_inode);
 
-	if ((folio->mapping != inode->i_mapping) ||
+	if ((folio->mapping != inode->vfs_inode.i_mapping) ||
 	    (page_start >= size)) {
 		/* Page got truncated out from underneath us. */
 		goto out_unlock;
@@ -1917,11 +1916,11 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	 * We can't set the delalloc bits if there are pending ordered
 	 * extents.  Drop our locks and wait for them to finish.
 	 */
-	ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start, fsize);
+	ordered = btrfs_lookup_ordered_range(inode, page_start, fsize);
 	if (ordered) {
 		btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 		folio_unlock(folio);
-		up_read(&BTRFS_I(inode)->i_mmap_lock);
+		up_read(&inode->i_mmap_lock);
 		btrfs_start_ordered_extent(ordered);
 		btrfs_put_ordered_extent(ordered);
 		goto again;
@@ -1934,12 +1933,10 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 
 			end = page_start + reserved_space - 1;
 			if (only_release_metadata)
-				btrfs_delalloc_release_metadata(BTRFS_I(inode),
-								to_free, true);
+				btrfs_delalloc_release_metadata(inode, to_free, true);
 			else
-				btrfs_delalloc_release_space(BTRFS_I(inode),
-							     data_reserved, end + 1,
-							     to_free, true);
+				btrfs_delalloc_release_space(inode, data_reserved,
+							     end + 1, to_free, true);
 		}
 	}
 
@@ -1954,8 +1951,7 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 			       EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
 			       EXTENT_DEFRAG, &cached_state);
 
-	ret = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
-					&cached_state);
+	ret = btrfs_set_extent_delalloc(inode, page_start, end, 0, &cached_state);
 	if (ret < 0) {
 		btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
 		goto out_unlock;
@@ -1974,38 +1970,38 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start);
 	btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start);
 
-	btrfs_set_inode_last_sub_trans(BTRFS_I(inode));
+	btrfs_set_inode_last_sub_trans(inode);
 
 	if (only_release_metadata)
 		btrfs_set_extent_bit(io_tree, page_start, end, EXTENT_NORESERVE,
 				     &cached_state);
 
 	btrfs_unlock_extent(io_tree, page_start, page_end, &cached_state);
-	up_read(&BTRFS_I(inode)->i_mmap_lock);
+	up_read(&inode->i_mmap_lock);
 
-	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	btrfs_delalloc_release_extents(inode, fsize);
 	if (only_release_metadata)
-		btrfs_check_nocow_unlock(BTRFS_I(inode));
-	sb_end_pagefault(inode->i_sb);
+		btrfs_check_nocow_unlock(inode);
+	sb_end_pagefault(inode->vfs_inode.i_sb);
 	extent_changeset_free(data_reserved);
 	return VM_FAULT_LOCKED;
 
 out_unlock:
 	folio_unlock(folio);
-	up_read(&BTRFS_I(inode)->i_mmap_lock);
+	up_read(&inode->i_mmap_lock);
 out:
-	btrfs_delalloc_release_extents(BTRFS_I(inode), fsize);
+	btrfs_delalloc_release_extents(inode, fsize);
 	if (only_release_metadata)
-		btrfs_delalloc_release_metadata(BTRFS_I(inode), reserved_space, true);
+		btrfs_delalloc_release_metadata(inode, reserved_space, true);
 	else
-		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
-					     page_start, reserved_space, true);
+		btrfs_delalloc_release_space(inode, data_reserved, page_start,
+					     reserved_space, true);
 	extent_changeset_free(data_reserved);
 out_noreserve:
 	if (only_release_metadata)
-		btrfs_check_nocow_unlock(BTRFS_I(inode));
+		btrfs_check_nocow_unlock(inode);
 
-	sb_end_pagefault(inode->i_sb);
+	sb_end_pagefault(inode->vfs_inode.i_sb);
 
 	if (ret < 0)
 		return vmf_error(ret);
Signature · 1 line
2.47.2