Skip to contentSkip to conversation

btrfs: Fix race in read_extent_buffer_pages()

PATCH In review Tavian Barnes 4 participants 6 messages Mar 16, 2024 – Mar 25, 2024 Btrfs file system

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 btrfs: Fix race in read_extent_buffer_pages()

To prevent concurrent reads for the same extent buffer, read_extent_buffer_pages() performs these checks:

    /* (1) */
    if (test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))
        return 0;

    /* (2) */
    if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))
        goto done;

At this point, it seems safe to start the actual read operation. Once that completes, end_bbio_meta_read() does

    /* (3) */
    set_extent_buffer_uptodate(eb);

    /* (4) */
    clear_bit(EXTENT_BUFFER_READING, &eb->bflags);

Normally, this is enough to ensure only one read happens, and all other callers wait for it to finish before returning. Unfortunately, there is a racey interleaving:

    Thread A | Thread B | Thread C
    ---------+----------+---------
       (1)   |          |
             |    (1)   |
       (2)   |          |
       (3)   |          |
       (4)   |          |
             |    (2)   |
             |          |    (1)

When this happens, thread B kicks of an unnecessary read. Worse, thread C will see UPTODATE set and return immediately, while the read from thread B is still in progress. This race could result in tree-checker errors like this as the extent buffer is concurrently modified:

    BTRFS critical (device dm-0): corrupted node, root=256
    block=8550954455682405139 owner mismatch, have 11858205567642294356
    expect [256, 18446744073709551360]

Fix it by testing UPTODATE again after setting the READING bit, and if it's been set, skip the unnecessary read.

---
 fs/btrfs/extent_io.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)
fs/btrfs/extent_io.c +13 -0
index 7441245b1ceb..61594eaf1f89 100644
@@ -4333,6 +4333,19 @@ int read_extent_buffer_pages(struct extent_buffer *eb, int wait, int mirror_num,
 	if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))
 		goto done;
 
+	/*
+	 * Between the initial test_bit(EXTENT_BUFFER_UPTODATE) and the above
+	 * test_and_set_bit(EXTENT_BUFFER_READING), someone else could have
+	 * started and finished reading the same eb.  In this case, UPTODATE
+	 * will now be set, and we shouldn't read it in again.
+	 */
+	if (unlikely(test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))) {
+		clear_bit(EXTENT_BUFFER_READING, &eb->bflags);
+		smp_mb__after_atomic();
+		wake_up_bit(&eb->bflags, EXTENT_BUFFER_READING);
+		return 0;
+	}
+
 	clear_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);
 	eb->read_mirror = 0;
 	check_buffer_tree_ref(eb);
Signature · 1 line
2.44.0
Reviewed-by on v1 1/1
#1 lore raw
Quoted 43 lines · Tavian Barnes

To prevent concurrent reads for the same extent buffer, read_extent_buffer_pages() performs these checks:

     /* (1) */
     if (test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))
         return 0;

     /* (2) */
     if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))
         goto done;

At this point, it seems safe to start the actual read operation. Once that completes, end_bbio_meta_read() does

     /* (3) */
     set_extent_buffer_uptodate(eb);

     /* (4) */
     clear_bit(EXTENT_BUFFER_READING, &eb->bflags);

Normally, this is enough to ensure only one read happens, and all other callers wait for it to finish before returning. Unfortunately, there is a racey interleaving:

     Thread A | Thread B | Thread C
     ---------+----------+---------
        (1)   |          |
              |    (1)   |
        (2)   |          |
        (3)   |          |
        (4)   |          |
              |    (2)   |
              |          |    (1)

When this happens, thread B kicks of an unnecessary read. Worse, thread C will see UPTODATE set and return immediately, while the read from thread B is still in progress. This race could result in tree-checker errors like this as the extent buffer is concurrently modified:

     BTRFS critical (device dm-0): corrupted node, root=256
     block=8550954455682405139 owner mismatch, have 11858205567642294356
     expect [256, 18446744073709551360]
Quoted 8 lines

Fix it by testing UPTODATE again after setting the READING bit, and if it's been set, skip the unnecessary read.

Thanks,
Qu

Quoted 28 lines
---
  fs/btrfs/extent_io.c | 13 +++++++++++++
  1 file changed, 13 insertions(+)
fs/btrfs/extent_io.c +13 -0
index 7441245b1ceb..61594eaf1f89 100644
@@ -4333,6 +4333,19 @@ int read_extent_buffer_pages(struct extent_buffer *eb, int wait, int mirror_num,
  	if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))
  		goto done;
 
+	/*
+	 * Between the initial test_bit(EXTENT_BUFFER_UPTODATE) and the above
+	 * test_and_set_bit(EXTENT_BUFFER_READING), someone else could have
+	 * started and finished reading the same eb.  In this case, UPTODATE
+	 * will now be set, and we shouldn't read it in again.
+	 */
+	if (unlikely(test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))) {
+		clear_bit(EXTENT_BUFFER_READING, &eb->bflags);
+		smp_mb__after_atomic();
+		wake_up_bit(&eb->bflags, EXTENT_BUFFER_READING);
+		return 0;
+	}
+
  	clear_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);
  	eb->read_mirror = 0;
  	check_buffer_tree_ref(eb);
#3 lore raw
In reply to Tavian Barnes
Quoted 43 lines · Tavian Barnes

To prevent concurrent reads for the same extent buffer, read_extent_buffer_pages() performs these checks:

    /* (1) */
    if (test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))
        return 0;

    /* (2) */
    if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))
        goto done;

At this point, it seems safe to start the actual read operation. Once that completes, end_bbio_meta_read() does

    /* (3) */
    set_extent_buffer_uptodate(eb);

    /* (4) */
    clear_bit(EXTENT_BUFFER_READING, &eb->bflags);

Normally, this is enough to ensure only one read happens, and all other callers wait for it to finish before returning. Unfortunately, there is a racey interleaving:

    Thread A | Thread B | Thread C
    ---------+----------+---------
       (1)   |          |
             |    (1)   |
       (2)   |          |
       (3)   |          |
       (4)   |          |
             |    (2)   |
             |          |    (1)

When this happens, thread B kicks of an unnecessary read. Worse, thread C will see UPTODATE set and return immediately, while the read from thread B is still in progress. This race could result in tree-checker errors like this as the extent buffer is concurrently modified:

    BTRFS critical (device dm-0): corrupted node, root=256
    block=8550954455682405139 owner mismatch, have 11858205567642294356
    expect [256, 18446744073709551360]
Quoted 8 lines

Fix it by testing UPTODATE again after setting the READING bit, and if it's been set, skip the unnecessary read.

Thank you very much for taking the time to debug the issue and for the fix. It is a rare occurrence that a tough bug is followed by a fix from the same person (outside of the developer group) and is certainly appreciated.

#4 lore raw
Quoted 53 lines · David Sterba
Quoted 43 lines · Tavian Barnes

To prevent concurrent reads for the same extent buffer, read_extent_buffer_pages() performs these checks:

    /* (1) */
    if (test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))
        return 0;

    /* (2) */
    if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))
        goto done;

At this point, it seems safe to start the actual read operation. Once that completes, end_bbio_meta_read() does

    /* (3) */
    set_extent_buffer_uptodate(eb);

    /* (4) */
    clear_bit(EXTENT_BUFFER_READING, &eb->bflags);

Normally, this is enough to ensure only one read happens, and all other callers wait for it to finish before returning. Unfortunately, there is a racey interleaving:

    Thread A | Thread B | Thread C
    ---------+----------+---------
       (1)   |          |
             |    (1)   |
       (2)   |          |
       (3)   |          |
       (4)   |          |
             |    (2)   |
             |          |    (1)

When this happens, thread B kicks of an unnecessary read. Worse, thread C will see UPTODATE set and return immediately, while the read from thread B is still in progress. This race could result in tree-checker errors like this as the extent buffer is concurrently modified:

    BTRFS critical (device dm-0): corrupted node, root=256
    block=8550954455682405139 owner mismatch, have 11858205567642294356
    expect [256, 18446744073709551360]
Quoted 8 lines

Fix it by testing UPTODATE again after setting the READING bit, and if it's been set, skip the unnecessary read.

Quoted 4 lines

Thank you very much for taking the time to debug the issue and for the fix. It is a rare occurrence that a tough bug is followed by a fix from the same person (outside of the developer group) and is certainly appreciated.

Thank you!

Sorry to nitpick, but the paragraph you added to the commit message
[1] has a typo:

Quoted 4 lines

There are reports from tree-checker that detects corrupted nodes, without any obvious pattern so possibly an overwrite in memory. After some debugging it turns out there's a race when reading an extent buffer the uptodate status is can be missed.

s/is can/can/

[1]: https://github.com/btrfs/linux/commit/402887e0e9ad76d72496aefebd37bd729748be79

Signature · 1 line
Tavian Barnes
#5 lore raw
Quoted 64 lines · Tavian Barnes
Quoted 53 lines · David Sterba
Quoted 43 lines · Tavian Barnes

To prevent concurrent reads for the same extent buffer, read_extent_buffer_pages() performs these checks:

    /* (1) */
    if (test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))
        return 0;

    /* (2) */
    if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))
        goto done;

At this point, it seems safe to start the actual read operation. Once that completes, end_bbio_meta_read() does

    /* (3) */
    set_extent_buffer_uptodate(eb);

    /* (4) */
    clear_bit(EXTENT_BUFFER_READING, &eb->bflags);

Normally, this is enough to ensure only one read happens, and all other callers wait for it to finish before returning. Unfortunately, there is a racey interleaving:

    Thread A | Thread B | Thread C
    ---------+----------+---------
       (1)   |          |
             |    (1)   |
       (2)   |          |
       (3)   |          |
       (4)   |          |
             |    (2)   |
             |          |    (1)

When this happens, thread B kicks of an unnecessary read. Worse, thread C will see UPTODATE set and return immediately, while the read from thread B is still in progress. This race could result in tree-checker errors like this as the extent buffer is concurrently modified:

    BTRFS critical (device dm-0): corrupted node, root=256
    block=8550954455682405139 owner mismatch, have 11858205567642294356
    expect [256, 18446744073709551360]
Quoted 8 lines

Fix it by testing UPTODATE again after setting the READING bit, and if it's been set, skip the unnecessary read.

Quoted 4 lines

Thank you very much for taking the time to debug the issue and for the fix. It is a rare occurrence that a tough bug is followed by a fix from the same person (outside of the developer group) and is certainly appreciated.

Thank you!

Sorry to nitpick, but the paragraph you added to the commit message
[1] has a typo:

Quoted 6 lines
Quoted 4 lines

There are reports from tree-checker that detects corrupted nodes, without any obvious pattern so possibly an overwrite in memory. After some debugging it turns out there's a race when reading an extent buffer the uptodate status is can be missed.

s/is can/can/

I will fix that, thanks.