@@ -1185,6 +1185,7 @@ static noinline void finish_rmw(struct btrfs_raid_bio *rbio)
bool has_qstripe;
struct bio_list bio_list;
struct bio *bio;
+ u64 event;
int ret;
bio_list_init(&bio_list);
@@ -1338,6 +1339,13 @@ static noinline void finish_rmw(struct btrfs_raid_bio *rbio)
atomic_set(&rbio->stripes_pending, bio_list_size(&bio_list));
BUG_ON(atomic_read(&rbio->stripes_pending) == 0);
+ /* Update the write intent bitmap before we start submitting bios. */
+ btrfs_write_intent_mark_dirty(bioc->fs_info, rbio->bioc->raid_map[0],
+ rbio->nr_data * BTRFS_STRIPE_LEN, &event);
+ ret = btrfs_write_intent_writeback(bioc->fs_info, event);
+
+ if (ret < 0)
+ goto cleanup;
while ((bio = bio_list_pop(&bio_list))) {
bio->bi_end_io = raid_write_end_io;
@@ -432,6 +432,9 @@ static void delete_one_entry(struct write_intent_ctrl *ctrl, int nr)
memset(write_intent_entry_nr(ctrl, cur_nr_entries - 1), 0,
sizeof(struct write_intent_entry));
wi_set_super_nr_entries(wis, cur_nr_entries - 1);
+
+ /* We freed one entry, wake up who are waiting for the extra space. */
+ wake_up(&ctrl->overflow_wait);
}
/*
@@ -699,6 +702,49 @@ static void write_intent_clear_bits(struct write_intent_ctrl *ctrl, u64 bytenr,
}
}
+void btrfs_write_intent_mark_dirty(struct btrfs_fs_info *fs_info, u64 logical,
+ u32 len, u64 *event_ret)
+{
+ struct write_intent_ctrl *ctrl = fs_info->wi_ctrl;
+ struct write_intent_super *wis;
+ u32 entry_len;
+ int nr_entries;
+
+ if (!btrfs_fs_compat_ro(fs_info, WRITE_INTENT_BITMAP))
+ return;
+
+ ASSERT(ctrl);
+ ASSERT(IS_ALIGNED(len, BTRFS_STRIPE_LEN));
+
+again:
+ spin_lock(&ctrl->lock);
+ entry_len = ctrl->blocksize * WRITE_INTENT_BITS_PER_ENTRY;
+ nr_entries = (round_up(logical + len, entry_len) -
+ round_down(logical, entry_len)) / entry_len;
+ wis = page_address(ctrl->page);
+
+ /*
+ * May not have enough space left. This calculation is definitely
+ * overkilled, but will ensure we have enough space for it.
+ */
+ if (unlikely(wi_super_nr_entries(wis) + nr_entries) >=
+ WRITE_INTENT_INTERNAL_BITMAPS_MAX_ENTRIES) {
+ DEFINE_WAIT(__wait);
+
+ prepare_to_wait_event(&ctrl->overflow_wait, &__wait,
+ TASK_UNINTERRUPTIBLE);
+ spin_unlock(&ctrl->lock);
+ schedule();
+ finish_wait(&ctrl->write_wait, &__wait);
+ goto again;
+ }
+
+ /* Update the bitmap. */
+ write_intent_set_bits(ctrl, logical, len);
+ *event_ret = atomic64_read(&ctrl->event);
+ spin_unlock(&ctrl->lock);
+}
+
int btrfs_write_intent_writeback(struct btrfs_fs_info *fs_info, u64 event)
{
struct write_intent_ctrl *ctrl = fs_info->wi_ctrl;
@@ -258,4 +258,13 @@ void btrfs_write_intent_free(struct btrfs_fs_info *fs_info);
*/
int btrfs_write_intent_writeback(struct btrfs_fs_info *fs_info, u64 event);
+/*
+ * Mark the range dirty in write intent bitmaps.
+ *
+ * May (but unlikely) sleep if there is not enough free entries.
+ * In that case, we will wait for enough free entries to be released.
+ */
+void btrfs_write_intent_mark_dirty(struct btrfs_fs_info *fs_info, u64 logical,
+ u32 len, u64 *event_ret);
+
#endif
This allows us to mark the write-intent bitmaps dirty for later recovery usage. For now, we only mark the bitmaps dirty but without really clearing them, this is going to cause problems (hang the fs if the bitmap is full), but this also allows us to debug the bitmap with the new dump-write-intent tool: csum_type 0 (crc32c) csum 0xad622029 [match] magic _wIbSb_Q [match] fsid 46bcd711-6c9b-400f-aaba-bf99aa3dd321 flags 0x7 ( TARGET_RAID56 | INTERNAL | BYTENR_LOGICAL ) events 10 size 4096 blocksize 65536 nr_entries 1 entry 0, bytenr 385875968, bitmap 0x000000000003fffc This is doing 1MiB write for logical 388104192, which matches the above output bitmap. Signed-off-by: Qu Wenruo <wqu@suse.com> --- fs/btrfs/raid56.c | 8 +++++++ fs/btrfs/write-intent.c | 46 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/write-intent.h | 9 ++++++++ 3 files changed, 63 insertions(+)