btrfs: extract the compressed folio padding into a helper

Currently after btrfs_compress_folios(), we zero the tail folio at
compress_file_range() after the btrfs_compress_folios() call.

However there are several problems with the incoming block size > page
size support:

- We may need extra padding folios for the compressed data
  Or we will submit a write smaller than the block size.

- The current folio tail zeroing is not covering extra padding folios

Solve this problem by introducing a dedicated helper,
pad_compressed_folios(), which will:

- Do extra basic sanity checks
  Focusing on the @out_folios and @total_out values.

- Zero the tailing folio
  Now we don't need to tail zeroing inside compress_file_range()
  anymore.

- Add extra padding zero folios
  So that for bs > ps cases, the compressed data will always be bs
  aligned.

  This also implies we won't allocate dedicated large folios for
  compressed data.

Finally since we're here, update the stale comments about
btrfs_compress_folios().

Signed-off-by: Qu Wenruo <[email protected]>
---
RFC v2->RFC v3:
- Fix a failure related to inline compressed data (btrfs/246 failure)
  The check on whether the resulted compressed data should not happen
  until we're sure no inlined extent is going to be created.

RFC v1->RFC v2:
- Fix a check causes more strict condition for subpage cases
  Instead comparing the resulted compressed folios number, compare the
  resulted blocks number instead.
  For 64K page sized system with 4K block size, it will result any
  compressed data larger than 64K to be rejected.
  Even if the compression caused a pretty good result, e.g. 128K ->68K.

- Remove an unused local variable

Reason for RFC:

Although this seems to be a preparation patch for bs > ps support, this
one will determine the path we go for compressed folios.

There are 2 methods I can come up with:

- Allocate dedicated large folios following min_order for compressed
  folios
  This is the more common method, used by filemap and will be the method
  for page cache.

  The problem is, we will no longer share the compr_pool across all
  btrfs filesystems, and the dedicated per-fs pool will have a much
  harder time to fill its pool when memory is fragmented or
  under-pressure.

  The benefit is obvious, we will have the insurance that every folio
  will contain at least one block for bs > ps cases.

- Allocate page sized folios but add extra padding folios for compressed
  folios
  The method I take in this patchset.

  The benefit is we can still use the shared compr folios pool, meaning
  a better latency filling the pool.

  The problem is we must manually pad the compressed folios.
  Thankfully the compressed folios are not filemap ones, we don't need
  to bother about the folio flags at all.

  Another problem is, we will have different handling for filemap and
  compressed folios.
  Filemap folios will have the min_order insurance, but not for
  compressed folios.
  I believe the inconsistency is still manageable, at least for now.

Thus I leave this one as RFC, any feedback will be appreciated.

Author: adam900710

fs/btrfs/compression.c

@@ -1024,6 +1024,43 @@ int btrfs_compress_filemap_get_folio(struct address_space *mapping, u64 start,
 	return 0;
 }
 
+/*
+ * Fill the range between (total_out, round_up(total_out, blocksize)) with zero.
+ *
+ * If bs > ps, also allocate extra folios to ensure the compressed folios are aligned
+ * to block size.
+ */
+static int pad_compressed_folios(struct btrfs_fs_info *fs_info, struct folio **folios,
+				 unsigned long orig_len,  unsigned long *out_folios,
+				 unsigned long *total_out)
+{
+	const unsigned long aligned_len = round_up(*total_out, fs_info->sectorsize);
+	const unsigned long aligned_nr_folios = aligned_len >> PAGE_SHIFT;
+
+	ASSERT(aligned_nr_folios <= BTRFS_MAX_COMPRESSED_PAGES);
+	ASSERT(*out_folios == DIV_ROUND_UP_POW2(*total_out, PAGE_SIZE),
+	       "out_folios=%lu total_out=%lu", *out_folios, *total_out);
+
+	/* Zero the tailing part of the compressed folio. */
+	if (!IS_ALIGNED(*total_out, PAGE_SIZE))
+		folio_zero_range(folios[*total_out >> PAGE_SHIFT], offset_in_page(*total_out),
+				PAGE_SIZE - offset_in_page(*total_out));
+
+	/* Padding the compressed folios to blocksize. */
+	for (unsigned long cur = *out_folios; cur < aligned_nr_folios; cur++) {
+		struct folio *folio;
+
+		ASSERT(folios[cur] == NULL);
+		folio = btrfs_alloc_compr_folio();
+		if (!folio)
+			return -ENOMEM;
+		folios[cur] = folio;
+		folio_zero_range(folio, 0, PAGE_SIZE);
+		(*out_folios)++;
+	}
+	return 0;
+}
+
 /*
  * Given an address space and start and length, compress the bytes into @pages
  * that are allocated on demand.
@@ -1033,7 +1070,7 @@ int btrfs_compress_filemap_get_folio(struct address_space *mapping, u64 start,
  * - compression algo are 0-3
  * - the level are bits 4-7
  *
- * @out_pages is an in/out parameter, holds maximum number of pages to allocate
+ * @out_folios is an in/out parameter, holds maximum number of pages to allocate
  * and returns number of actually allocated pages
  *
  * @total_in is used to return the number of bytes actually read.  It
@@ -1060,6 +1097,9 @@ int btrfs_compress_folios(unsigned int type, int level, struct btrfs_inode *inod
 	/* The total read-in bytes should be no larger than the input. */
 	ASSERT(*total_in <= orig_len);
 	put_workspace(fs_info, type, workspace);
+	if (ret < 0)
+		return ret;
+	ret = pad_compressed_folios(fs_info, folios, orig_len, out_folios, total_out);
 	return ret;
 }
 

fs/btrfs/inode.c

@@ -864,7 +864,6 @@ static void compress_file_range(struct btrfs_work *work)
 	unsigned long nr_folios;
 	unsigned long total_compressed = 0;
 	unsigned long total_in = 0;
-	unsigned int poff;
 	int i;
 	int compress_type = fs_info->compress_type;
 	int compress_level = fs_info->compress_level;
@@ -964,14 +963,6 @@ static void compress_file_range(struct btrfs_work *work)
 	if (ret)
 		goto mark_incompressible;
 
-	/*
-	 * Zero the tail end of the last page, as we might be sending it down
-	 * to disk.
-	 */
-	poff = offset_in_page(total_compressed);
-	if (poff)
-		folio_zero_range(folios[nr_folios - 1], poff, PAGE_SIZE - poff);
-
 	/*
 	 * Try to create an inline extent.
 	 *