Skip to contentSkip to conversation

udf: Fix race between file type conversion and writeback

PATCH Superseded Jan Kara 2 participants 3 messages Mar 25 – Mar 26

Subsystems (2)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

Jan Kara

author reviewer
#0 lore raw

PATCH v2 1/1 udf: Fix race between file type conversion and writeback

udf_setsize() can race with udf_writepages() as follows:

udf_setsize() udf_writepages()

				  if (iinfo->i_alloc_type ==
						ICBTAG_FLAG_AD_IN_ICB)

err = udf_expand_file_adinicb(inode);
err = udf_extend_file(inode, newsize);
udf_adinicb_writepages()
memcpy_from_file_folio() - crash
because inode size is too big.

Fix the problem by rechecking file type under folio lock in udf_writepages() which properly serializes with udf_expand_file_adinicb(). Since it is quite difficult to implement this locking with current writeback_iter() logic, let's just opencode the logic necessary to prepare (the only) folio the inode can have for writeback.

---
 fs/udf/inode.c | 53 +++++++++++++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 20 deletions(-)

Changes since v1:
* opencode folio_prepare_writeback() in UDF instead of exporting it

I'll merge this fix through my tree.

fs/udf/inode.c +33 -20
index 7fae8002344a..c85b0239660c 100644
@@ -181,34 +181,47 @@ static void udf_write_failed(struct address_space *mapping, loff_t to)
 	}
 }
 
-static int udf_adinicb_writepages(struct address_space *mapping,
-		      struct writeback_control *wbc)
+static int udf_writepages(struct address_space *mapping,
+			  struct writeback_control *wbc)
 {
 	struct inode *inode = mapping->host;
 	struct udf_inode_info *iinfo = UDF_I(inode);
-	struct folio *folio = NULL;
-	int error = 0;
 
-	while ((folio = writeback_iter(mapping, wbc, folio, &error))) {
-		BUG_ON(!folio_test_locked(folio));
-		BUG_ON(folio->index != 0);
+	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+		struct folio *folio;
+		bool dirty = false;
+
+		folio = filemap_lock_folio(mapping, 0);
+		if (IS_ERR(folio))
+			return 0;
+		/*
+		 * Recheck inode type under folio lock when we are protected
+		 * against udf_expand_file_adinicb(). Bail to standard writeback
+		 * path if file got expanded.
+		 */
+		if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
+			folio_unlock(folio);
+			goto mpage_writeback;
+		}
+		if (!folio_test_dirty(folio))
+			goto unlock_folio;
+		if (folio_test_writeback(folio)) {
+			if (wbc->sync_mode == WB_SYNC_NONE)
+				goto unlock_folio;
+			folio_wait_writeback(folio);
+		}
+		if (!folio_clear_dirty_for_io(folio))
+			goto unlock_folio;
 		memcpy_from_file_folio(iinfo->i_data + iinfo->i_lenEAttr, folio,
 				0, i_size_read(inode));
+		dirty = true;
+unlock_folio:
 		folio_unlock(folio);
+		if (dirty)
+			mark_inode_dirty(inode);
+		return 0;
 	}
-
-	mark_inode_dirty(inode);
-	return 0;
-}
-
-static int udf_writepages(struct address_space *mapping,
-			  struct writeback_control *wbc)
-{
-	struct inode *inode = mapping->host;
-	struct udf_inode_info *iinfo = UDF_I(inode);
-
-	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
-		return udf_adinicb_writepages(mapping, wbc);
+mpage_writeback:
 	return mpage_writepages(mapping, wbc, udf_get_block_wb);
 }
 
Signature · 1 line
2.51.0
#1 lore raw
Quoted 11 lines · Jan Kara

udf_setsize() can race with udf_writepages() as follows:

udf_setsize() udf_writepages()

				  if (iinfo->i_alloc_type ==
						ICBTAG_FLAG_AD_IN_ICB)

err = udf_expand_file_adinicb(inode);
err = udf_extend_file(inode, newsize);
udf_adinicb_writepages()
memcpy_from_file_folio() - crash
because inode size is too big.

Quoted 6 lines

Fix the problem by rechecking file type under folio lock in udf_writepages() which properly serializes with udf_expand_file_adinicb(). Since it is quite difficult to implement this locking with current writeback_iter() logic, let's just opencode the logic necessary to prepare (the only) folio the inode can have for writeback.

Still not a fan of open coding this logic, which is even worse than the previous export. Inline data is a relatively common case in various file systems, and we should be able to handle it in common code. So having a callback in mpage_writepages seems much better, but if you detest that we could just export mpage_write_folio and mpage_bio_submit_write (and make mpage_data public) instead. I think that's significantly worse than just adding the callback, but still much better than open coding more writeback internals, something I want to get away from.

author reviewer
#2 lore raw
Quoted 19 lines · Christoph Hellwig
Quoted 11 lines · Jan Kara

udf_setsize() can race with udf_writepages() as follows:

udf_setsize() udf_writepages()

				  if (iinfo->i_alloc_type ==
						ICBTAG_FLAG_AD_IN_ICB)

err = udf_expand_file_adinicb(inode);
err = udf_extend_file(inode, newsize);
udf_adinicb_writepages()
memcpy_from_file_folio() - crash
because inode size is too big.

Quoted 6 lines

Fix the problem by rechecking file type under folio lock in udf_writepages() which properly serializes with udf_expand_file_adinicb(). Since it is quite difficult to implement this locking with current writeback_iter() logic, let's just opencode the logic necessary to prepare (the only) folio the inode can have for writeback.

Quoted 4 lines

Still not a fan of open coding this logic, which is even worse than the previous export. Inline data is a relatively common case in various file systems, and we should be able to handle it in common code.

I agree inline data is relatively common but as far as I was checking UDF is the only filesystem using mpage_writepages() that is supporting inline data (well, OCFS2 does as well but it doesn't bother with inline data writeback - it handles only write(2) to files with inline data which modify on disk content directly, they expand the file to extents in case of mmap). So a special hook in mpage_writepages() for UDF looks like a bit of an overkill to me.

Quoted 6 lines

So having a callback in mpage_writepages seems much better, but if you detest that we could just export mpage_write_folio and mpage_bio_submit_write (and make mpage_data public) instead. I think that's significantly worse than just adding the callback, but still much better than open coding more writeback internals, something I want to get away from.

I agree the callback is better than making all that mpage infrastructure public. I still think exporting folio_prepare_writeback() would be less burden than the callback but frankly I don't think it matters enough to argue further. I just want to get that race fixed :).

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR