btrfs: rework lzo_decompress_bio() to make it subpage compatible

For the initial subpage support, although we won't support compressed
write, we still need to support compressed read.

But for lzo_decompress_bio() it has several problems:

- The abuse of PAGE_SIZE for boundary detection
  For subpage case, we should follow sectorsize to detect the padding
  zeros.
  Using PAGE_SIZE will cause subpage compress read to skip certain
  bytes, and causing read error.

- Too many helper variables
  There are half a dozen helper variables, which is only making things
  harder to read

This patch will rework lzo_decompress_bio() to make it work for subpage:

- Use sectorsize to do boundary check, while still use PAGE_SIZE for
  page switching
  This allows us to have the same on-disk format for 4K sectorsize fs,
  while take advantage of larger page size.

- Use two main cursors
  Only @cur_in and @cur_out is utilized as the main cursor.
  The helper variables will only be declared inside the loop, and only 2
  helper variables needed.

- Introduce a helper function to copy compressed segment payload
  Introduce a new helper, copy_compressed_segment(), to copy a
  compressed segment to workspace buffer.
  This function will handle the page switching.

Now the net result is, with all the excessive comments and new helper
function, the refactored code is still smaller, and easier to read.

For other decompression code, they have no special padding rule, thus no
need to bother for initial subpage support, but will be refactored to
the same style later.

Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/lzo.c b/fs/btrfs/lzo.c
index 6cab15e52cec45b161324c03877e05003b754b16..c25dfd1a8a54a0b901e89140252b4df4b5c0e299 100644 (file)
--- a/fs/btrfs/lzo.c
+++ b/fs/btrfs/lzo.c
@@ -14,6 +14,7 @@
 #include <linux/lzo.h>
 #include <linux/refcount.h>
 #include "compression.h"
+#include "ctree.h"
 
 #define LZO_LEN        4
 
@@ -271,130 +272,113 @@ out:
        return ret;
 }
 
+/*
+ * Copy the compressed segment payload into @dest.
+ *
+ * For the payload there will be no padding, just need to do page switching.
+ */
+static void copy_compressed_segment(struct compressed_bio *cb,
+                                   char *dest, u32 len, u32 *cur_in)
+{
+       u32 orig_in = *cur_in;
+
+       while (*cur_in < orig_in + len) {
+               struct page *cur_page;
+               u32 copy_len = min_t(u32, PAGE_SIZE - offset_in_page(*cur_in),
+                                         orig_in + len - *cur_in);
+
+               ASSERT(copy_len);
+               cur_page = cb->compressed_pages[*cur_in / PAGE_SIZE];
+
+               memcpy(dest + *cur_in - orig_in,
+                       page_address(cur_page) + offset_in_page(*cur_in),
+                       copy_len);
+
+               *cur_in += copy_len;
+       }
+}
+
 int lzo_decompress_bio(struct list_head *ws, struct compressed_bio *cb)
 {
        struct workspace *workspace = list_entry(ws, struct workspace, list);
-       int ret = 0, ret2;
-       char *data_in;
-       unsigned long page_in_index = 0;
-       size_t srclen = cb->compressed_len;
-       unsigned long total_pages_in = DIV_ROUND_UP(srclen, PAGE_SIZE);
-       unsigned long buf_start;
-       unsigned long buf_offset = 0;
-       unsigned long bytes;
-       unsigned long working_bytes;
-       size_t in_len;
-       size_t out_len;
-       const size_t max_segment_len = lzo1x_worst_compress(PAGE_SIZE);
-       unsigned long in_offset;
-       unsigned long in_page_bytes_left;
-       unsigned long tot_in;
-       unsigned long tot_out;
-       unsigned long tot_len;
-       char *buf;
-       struct page **pages_in = cb->compressed_pages;
+       const struct btrfs_fs_info *fs_info = btrfs_sb(cb->inode->i_sb);
+       const u32 sectorsize = fs_info->sectorsize;
+       int ret;
+       /* Compressed data length, can be unaligned */
+       u32 len_in;
+       /* Offset inside the compressed data */
+       u32 cur_in = 0;
+       /* Bytes decompressed so far */
+       u32 cur_out = 0;
+
+       len_in = read_compress_length(page_address(cb->compressed_pages[0]));
+       cur_in += LZO_LEN;
 
-       data_in = page_address(pages_in[0]);
-       tot_len = read_compress_length(data_in);
        /*
-        * Compressed data header check.
+        * LZO header length check
         *
-        * The real compressed size can't exceed the maximum extent length, and
-        * all pages should be used (whole unused page with just the segment
-        * header is not possible).  If this happens it means the compressed
-        * extent is corrupted.
+        * The total length should not exceed the maximum extent length,
+        * and all sectors should be used.
+        * If this happens, it means the compressed extent is corrupted.
         */
-       if (tot_len > min_t(size_t, BTRFS_MAX_COMPRESSED, srclen) ||
-           tot_len < srclen - PAGE_SIZE) {
-               ret = -EUCLEAN;
-               goto done;
+       if (len_in > min_t(size_t, BTRFS_MAX_COMPRESSED, cb->compressed_len) ||
+           round_up(len_in, sectorsize) < cb->compressed_len) {
+               btrfs_err(fs_info,
+                       "invalid lzo header, lzo len %u compressed len %u",
+                       len_in, cb->compressed_len);
+               return -EUCLEAN;
        }
 
-       tot_in = LZO_LEN;
-       in_offset = LZO_LEN;
-       in_page_bytes_left = PAGE_SIZE - LZO_LEN;
-
-       tot_out = 0;
-
-       while (tot_in < tot_len) {
-               in_len = read_compress_length(data_in + in_offset);
-               in_page_bytes_left -= LZO_LEN;
-               in_offset += LZO_LEN;
-               tot_in += LZO_LEN;
+       /* Go through each lzo segment */
+       while (cur_in < len_in) {
+               struct page *cur_page;
+               /* Length of the compressed segment */
+               u32 seg_len;
+               u32 sector_bytes_left;
+               size_t out_len = lzo1x_worst_compress(sectorsize);
 
                /*
-                * Segment header check.
-                *
-                * The segment length must not exceed the maximum LZO
-                * compression size, nor the total compressed size.
+                * We should always have enough space for one segment header
+                * inside current sector.
                 */
-               if (in_len > max_segment_len || tot_in + in_len > tot_len) {
-                       ret = -EUCLEAN;
-                       goto done;
-               }
-
-               tot_in += in_len;
-               working_bytes = in_len;
-
-               /* fast path: avoid using the working buffer */
-               if (in_page_bytes_left >= in_len) {
-                       buf = data_in + in_offset;
-                       bytes = in_len;
-                       goto cont;
-               }
-
-               /* copy bytes from the pages into the working buffer */
-               buf = workspace->cbuf;
-               buf_offset = 0;
-               while (working_bytes) {
-                       bytes = min(working_bytes, in_page_bytes_left);
-
-                       memcpy(buf + buf_offset, data_in + in_offset, bytes);
-                       buf_offset += bytes;
-cont:
-                       working_bytes -= bytes;
-                       in_page_bytes_left -= bytes;
-                       in_offset += bytes;
-
-                       /* check if we need to pick another page */
-                       if ((working_bytes == 0 && in_page_bytes_left < LZO_LEN)
-                           || in_page_bytes_left == 0) {
-                               tot_in += in_page_bytes_left;
-
-                               if (working_bytes == 0 && tot_in >= tot_len)
-                                       break;
-
-                               if (page_in_index + 1 >= total_pages_in) {
-                                       ret = -EIO;
-                                       goto done;
-                               }
-
-                               page_in_index++;
-                               data_in = page_address(pages_in[page_in_index]);
-
-                               in_page_bytes_left = PAGE_SIZE;
-                               in_offset = 0;
-                       }
-               }
-
-               out_len = max_segment_len;
-               ret = lzo1x_decompress_safe(buf, in_len, workspace->buf,
-                                           &out_len);
+               ASSERT(cur_in / sectorsize ==
+                      (cur_in + LZO_LEN - 1) / sectorsize);
+               cur_page = cb->compressed_pages[cur_in / PAGE_SIZE];
+               ASSERT(cur_page);
+               seg_len = read_compress_length(page_address(cur_page) +
+                                              offset_in_page(cur_in));
+               cur_in += LZO_LEN;
+
+               /* Copy the compressed segment payload into workspace */
+               copy_compressed_segment(cb, workspace->cbuf, seg_len, &cur_in);
+
+               /* Decompress the data */
+               ret = lzo1x_decompress_safe(workspace->cbuf, seg_len,
+                                           workspace->buf, &out_len);
                if (ret != LZO_E_OK) {
-                       pr_warn("BTRFS: decompress failed\n");
+                       btrfs_err(fs_info, "failed to decompress");
                        ret = -EIO;
-                       break;
+                       goto out;
                }
 
-               buf_start = tot_out;
-               tot_out += out_len;
+               /* Copy the data into inode pages */
+               ret = btrfs_decompress_buf2page(workspace->buf, out_len, cb, cur_out);
+               cur_out += out_len;
 
-               ret2 = btrfs_decompress_buf2page(workspace->buf, out_len,
-                                                cb, buf_start);
-               if (ret2 == 0)
-                       break;
+               /* All data read, exit */
+               if (ret == 0)
+                       goto out;
+               ret = 0;
+
+               /* Check if the sector has enough space for a segment header */
+               sector_bytes_left = sectorsize - (cur_in % sectorsize);
+               if (sector_bytes_left >= LZO_LEN)
+                       continue;
+
+               /* Skip the padding zeros */
+               cur_in += sector_bytes_left;
        }
-done:
+out:
        if (!ret)
                zero_fill_bio(cb->orig_bio);
        return ret;