2018-04-03 17:16:55 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 18:49:59 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2008 Oracle. All rights reserved.
|
|
|
|
|
*/
|
|
|
|
|
|
2018-04-03 17:16:55 +00:00
|
|
|
#ifndef BTRFS_COMPRESSION_H
|
|
|
|
|
#define BTRFS_COMPRESSION_H
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 18:49:59 +00:00
|
|
|
|
2018-05-17 05:52:22 +00:00
|
|
|
#include <linux/sizes.h>
|
2024-01-27 02:19:56 +00:00
|
|
|
#include <linux/mm.h>
|
|
|
|
|
#include <linux/list.h>
|
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
|
#include <linux/wait.h>
|
2023-02-10 07:48:34 +00:00
|
|
|
#include "bio.h"
|
2018-05-17 05:52:22 +00:00
|
|
|
|
2024-01-27 02:19:56 +00:00
|
|
|
struct address_space;
|
|
|
|
|
struct page;
|
|
|
|
|
struct inode;
|
2020-06-03 05:55:16 +00:00
|
|
|
struct btrfs_inode;
|
2023-05-31 07:53:58 +00:00
|
|
|
struct btrfs_ordered_extent;
|
2024-01-27 02:19:56 +00:00
|
|
|
struct btrfs_bio;
|
2020-06-03 05:55:16 +00:00
|
|
|
|
2017-02-14 18:30:39 +00:00
|
|
|
/*
|
|
|
|
|
* We want to make sure that amount of RAM required to uncompress an extent is
|
|
|
|
|
* reasonable, so we limit the total size in ram of a compressed extent to
|
|
|
|
|
* 128k. This is a crucial number because it also controls how easily we can
|
|
|
|
|
* spread reads across cpus for decompression.
|
|
|
|
|
*
|
|
|
|
|
* We also want to make sure the amount of IO required to do a random read is
|
|
|
|
|
* reasonably small, so we limit the size of a compressed extent to 128k.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Maximum length of compressed data stored on disk */
|
|
|
|
|
#define BTRFS_MAX_COMPRESSED (SZ_128K)
|
2023-02-10 07:48:34 +00:00
|
|
|
#define BTRFS_MAX_COMPRESSED_PAGES (BTRFS_MAX_COMPRESSED / PAGE_SIZE)
|
2022-02-01 14:42:07 +00:00
|
|
|
static_assert((BTRFS_MAX_COMPRESSED % PAGE_SIZE) == 0);
|
|
|
|
|
|
2017-02-14 18:30:39 +00:00
|
|
|
/* Maximum size of data before compression */
|
|
|
|
|
#define BTRFS_MAX_UNCOMPRESSED (SZ_128K)
|
|
|
|
|
|
2017-11-06 02:43:18 +00:00
|
|
|
#define BTRFS_ZLIB_DEFAULT_LEVEL 3
|
|
|
|
|
|
2017-05-26 07:44:59 +00:00
|
|
|
struct compressed_bio {
|
2024-01-29 09:46:11 +00:00
|
|
|
/* Number of compressed folios in the array. */
|
|
|
|
|
unsigned int nr_folios;
|
2019-10-14 12:38:33 +00:00
|
|
|
|
2024-01-29 09:46:11 +00:00
|
|
|
/* The folios with the compressed data on them. */
|
|
|
|
|
struct folio **compressed_folios;
|
2017-05-26 07:44:59 +00:00
|
|
|
|
|
|
|
|
/* starting offset in the inode for our pages */
|
|
|
|
|
u64 start;
|
|
|
|
|
|
2019-10-14 12:38:33 +00:00
|
|
|
/* Number of bytes in the inode we're working on */
|
|
|
|
|
unsigned int len;
|
2017-05-26 07:44:59 +00:00
|
|
|
|
2019-10-14 12:38:33 +00:00
|
|
|
/* Number of bytes on disk */
|
|
|
|
|
unsigned int compressed_len;
|
2017-05-26 07:44:59 +00:00
|
|
|
|
2019-10-14 12:38:33 +00:00
|
|
|
/* The compression algorithm for this bio */
|
|
|
|
|
u8 compress_type;
|
2017-05-26 07:44:59 +00:00
|
|
|
|
2019-08-13 23:00:02 +00:00
|
|
|
/* Whether this is a write for writeback. */
|
|
|
|
|
bool writeback;
|
|
|
|
|
|
2022-05-26 07:36:38 +00:00
|
|
|
union {
|
|
|
|
|
/* For reads, this is the bio we are copying the data into */
|
2023-03-07 16:39:41 +00:00
|
|
|
struct btrfs_bio *orig_bbio;
|
2022-05-26 07:36:38 +00:00
|
|
|
struct work_struct write_end_work;
|
|
|
|
|
};
|
2023-02-10 07:48:34 +00:00
|
|
|
|
|
|
|
|
/* Must be last. */
|
|
|
|
|
struct btrfs_bio bbio;
|
2017-05-26 07:44:59 +00:00
|
|
|
};
|
|
|
|
|
|
2019-02-04 20:19:57 +00:00
|
|
|
static inline unsigned int btrfs_compress_type(unsigned int type_level)
|
|
|
|
|
{
|
|
|
|
|
return (type_level & 0xF);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned int btrfs_compress_level(unsigned int type_level)
|
|
|
|
|
{
|
|
|
|
|
return ((type_level & 0xF0) >> 4);
|
|
|
|
|
}
|
|
|
|
|
|
btrfs: make module init/exit match their sequence
[BACKGROUND]
In theory init_btrfs_fs() and exit_btrfs_fs() should match their
sequence, thus normally they should look like this:
init_btrfs_fs() | exit_btrfs_fs()
----------------------+------------------------
init_A(); |
init_B(); |
init_C(); |
| exit_C();
| exit_B();
| exit_A();
So is for the error path of init_btrfs_fs().
But it's not the case, some exit functions don't match their init
functions sequence in init_btrfs_fs().
Furthermore in init_btrfs_fs(), we need to have a new error label for
each new init function we added. This is not really expandable,
especially recently we may add several new functions to init_btrfs_fs().
[ENHANCEMENT]
The patch will introduce the following things to enhance the situation:
- struct init_sequence
Just a wrapper of init and exit function pointers.
The init function must use int type as return value, thus some init
functions need to be updated to return 0.
The exit function can be NULL, as there are some init sequence just
outputting a message.
- struct mod_init_seq[] array
This is a const array, recording all the initialization we need to do
in init_btrfs_fs(), and the order follows the old init_btrfs_fs().
- bool mod_init_result[] array
This is a bool array, recording if we have initialized one entry in
mod_init_seq[].
The reason to split mod_init_seq[] and mod_init_result[] is to avoid
section mismatch in reference.
All init function are in .init.text, but if mod_init_seq[] records
the @initialized member it can no longer be const, thus will be put
into .data section, and cause modpost warning.
For init_btrfs_fs() we just call all init functions in their order in
mod_init_seq[] array, and after each call, setting corresponding
mod_init_result[] to true.
For exit_btrfs_fs() and error handling path of init_btrfs_fs(), we just
iterate mod_init_seq[] in reverse order, and skip all uninitialized
entry.
With this patch, init_btrfs_fs()/exit_btrfs_fs() will be much easier to
expand and will always follow the strict order.
Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2022-10-12 09:22:35 +00:00
|
|
|
int __init btrfs_init_compress(void);
|
2018-02-19 16:24:18 +00:00
|
|
|
void __cold btrfs_exit_compress(void);
|
2010-12-17 06:21:50 +00:00
|
|
|
|
2024-01-29 09:46:11 +00:00
|
|
|
int btrfs_compress_folios(unsigned int type_level, struct address_space *mapping,
|
|
|
|
|
u64 start, struct folio **folios, unsigned long *out_folios,
|
|
|
|
|
unsigned long *total_in, unsigned long *total_out);
|
2022-11-07 16:30:21 +00:00
|
|
|
int btrfs_decompress(int type, const u8 *data_in, struct page *dest_page,
|
2010-12-17 06:21:50 +00:00
|
|
|
unsigned long start_byte, size_t srclen, size_t destlen);
|
btrfs: rework btrfs_decompress_buf2page()
There are several bugs inside the function btrfs_decompress_buf2page()
- @start_byte doesn't take bvec.bv_offset into consideration
Thus it can't handle case where the target range is not page aligned.
- Too many helper variables
There are tons of helper variables, @buf_offset, @current_buf_start,
@start_byte, @prev_start_byte, @working_bytes, @bytes.
This hurts anyone who wants to read the function.
- No obvious main cursor for the iteartion
A new problem caused by previous problem.
- Comments for parameter list makes no sense
Like @buf_start is the offset to @buf, or offset inside the full
decompressed extent? (Spoiler alert, the later case)
And @total_out acts more like @buf_start + @size_of_buf.
The worst is @disk_start.
The real meaning of it is the file offset of the full decompressed
extent.
This patch will rework the whole function by:
- Add a proper comment with ASCII art to explain the parameter list
- Rework parameter list
The old @buf_start is renamed to @decompressed, to show how many bytes
are already decompressed inside the full decompressed extent.
The old @total_out is replaced by @buf_len, which is the decompressed
data size.
For old @disk_start and @bio, just pass @compressed_bio in.
- Use single main cursor
The main cursor will be @cur_file_offset, to show what's the current
file offset.
Other helper variables will be declared inside the main loop, and only
minimal amount of helper variables:
* offset_inside_decompressed_buf: The only real helper
* copy_start_file_offset: File offset we start memcpy
* bvec_file_offset: File offset of current bvec
Even with all these extensive comments, the final function is still
smaller than the original function, which is definitely a win.
Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2021-07-05 02:00:58 +00:00
|
|
|
int btrfs_decompress_buf2page(const char *buf, u32 buf_len,
|
|
|
|
|
struct compressed_bio *cb, u32 decompressed);
|
2010-12-17 06:21:50 +00:00
|
|
|
|
2023-05-31 07:53:58 +00:00
|
|
|
void btrfs_submit_compressed_write(struct btrfs_ordered_extent *ordered,
|
2024-01-29 09:46:11 +00:00
|
|
|
struct folio **compressed_folios,
|
|
|
|
|
unsigned int nr_folios, blk_opf_t write_flags,
|
|
|
|
|
bool writeback);
|
2023-05-03 15:24:27 +00:00
|
|
|
void btrfs_submit_compressed_read(struct btrfs_bio *bbio);
|
2016-03-10 09:26:59 +00:00
|
|
|
|
2019-02-04 20:20:05 +00:00
|
|
|
unsigned int btrfs_compress_str2level(unsigned int type, const char *str);
|
2017-09-15 15:36:57 +00:00
|
|
|
|
2024-01-29 09:46:07 +00:00
|
|
|
struct folio *btrfs_alloc_compr_folio(void);
|
|
|
|
|
void btrfs_free_compr_folio(struct folio *folio);
|
2023-11-15 16:59:39 +00:00
|
|
|
|
2016-03-10 09:26:59 +00:00
|
|
|
enum btrfs_compression_type {
|
|
|
|
|
BTRFS_COMPRESS_NONE = 0,
|
|
|
|
|
BTRFS_COMPRESS_ZLIB = 1,
|
|
|
|
|
BTRFS_COMPRESS_LZO = 2,
|
btrfs: Add zstd support
Add zstd compression and decompression support to BtrFS. zstd at its
fastest level compresses almost as well as zlib, while offering much
faster compression and decompression, approaching lzo speeds.
I benchmarked btrfs with zstd compression against no compression, lzo
compression, and zlib compression. I benchmarked two scenarios. Copying
a set of files to btrfs, and then reading the files. Copying a tarball
to btrfs, extracting it to btrfs, and then reading the extracted files.
After every operation, I call `sync` and include the sync time.
Between every pair of operations I unmount and remount the filesystem
to avoid caching. The benchmark files can be found in the upstream
zstd source repository under
`contrib/linux-kernel/{btrfs-benchmark.sh,btrfs-extract-benchmark.sh}`
[1] [2].
I ran the benchmarks on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.
The VM is running on a MacBook Pro with a 3.1 GHz Intel Core i7 processor,
16 GB of RAM, and a SSD.
The first compression benchmark is copying 10 copies of the unzipped
Silesia corpus [3] into a BtrFS filesystem mounted with
`-o compress-force=Method`. The decompression benchmark times how long
it takes to `tar` all 10 copies into `/dev/null`. The compression ratio is
measured by comparing the output of `df` and `du`. See the benchmark file
[1] for details. I benchmarked multiple zstd compression levels, although
the patch uses zstd level 1.
| Method | Ratio | Compression MB/s | Decompression speed |
|---------|-------|------------------|---------------------|
| None | 0.99 | 504 | 686 |
| lzo | 1.66 | 398 | 442 |
| zlib | 2.58 | 65 | 241 |
| zstd 1 | 2.57 | 260 | 383 |
| zstd 3 | 2.71 | 174 | 408 |
| zstd 6 | 2.87 | 70 | 398 |
| zstd 9 | 2.92 | 43 | 406 |
| zstd 12 | 2.93 | 21 | 408 |
| zstd 15 | 3.01 | 11 | 354 |
The next benchmark first copies `linux-4.11.6.tar` [4] to btrfs. Then it
measures the compression ratio, extracts the tar, and deletes the tar.
Then it measures the compression ratio again, and `tar`s the extracted
files into `/dev/null`. See the benchmark file [2] for details.
| Method | Tar Ratio | Extract Ratio | Copy (s) | Extract (s)| Read (s) |
|--------|-----------|---------------|----------|------------|----------|
| None | 0.97 | 0.78 | 0.981 | 5.501 | 8.807 |
| lzo | 2.06 | 1.38 | 1.631 | 8.458 | 8.585 |
| zlib | 3.40 | 1.86 | 7.750 | 21.544 | 11.744 |
| zstd 1 | 3.57 | 1.85 | 2.579 | 11.479 | 9.389 |
[1] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-benchmark.sh
[2] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-extract-benchmark.sh
[3] http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
[4] https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.11.6.tar.xz
zstd source repository: https://github.com/facebook/zstd
Signed-off-by: Nick Terrell <terrelln@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2017-08-10 02:39:02 +00:00
|
|
|
BTRFS_COMPRESS_ZSTD = 3,
|
2019-10-10 07:59:57 +00:00
|
|
|
BTRFS_NR_COMPRESS_TYPES = 4,
|
2016-03-10 09:26:59 +00:00
|
|
|
};
|
|
|
|
|
|
2019-02-04 20:20:03 +00:00
|
|
|
struct workspace_manager {
|
|
|
|
|
struct list_head idle_ws;
|
|
|
|
|
spinlock_t ws_lock;
|
|
|
|
|
/* Number of free workspaces */
|
|
|
|
|
int free_ws;
|
|
|
|
|
/* Total number of allocated workspaces */
|
|
|
|
|
atomic_t total_ws;
|
|
|
|
|
/* Waiters for a free workspace */
|
|
|
|
|
wait_queue_head_t ws_wait;
|
|
|
|
|
};
|
|
|
|
|
|
2019-10-04 00:50:28 +00:00
|
|
|
struct list_head *btrfs_get_workspace(int type, unsigned int level);
|
2019-10-04 00:50:28 +00:00
|
|
|
void btrfs_put_workspace(int type, struct list_head *ws);
|
2019-02-04 20:20:03 +00:00
|
|
|
|
2010-12-17 06:21:50 +00:00
|
|
|
struct btrfs_compress_op {
|
2019-10-01 22:53:31 +00:00
|
|
|
struct workspace_manager *workspace_manager;
|
2019-08-09 14:25:34 +00:00
|
|
|
/* Maximum level supported by the compression algorithm */
|
|
|
|
|
unsigned int max_level;
|
|
|
|
|
unsigned int default_level;
|
2010-12-17 06:21:50 +00:00
|
|
|
};
|
|
|
|
|
|
2019-02-04 20:19:59 +00:00
|
|
|
/* The heuristic workspaces are managed via the 0th workspace manager */
|
2019-10-10 07:59:57 +00:00
|
|
|
#define BTRFS_NR_WORKSPACE_MANAGERS BTRFS_NR_COMPRESS_TYPES
|
2019-02-04 20:19:59 +00:00
|
|
|
|
|
|
|
|
extern const struct btrfs_compress_op btrfs_heuristic_compress;
|
2015-01-02 17:23:10 +00:00
|
|
|
extern const struct btrfs_compress_op btrfs_zlib_compress;
|
|
|
|
|
extern const struct btrfs_compress_op btrfs_lzo_compress;
|
btrfs: Add zstd support
Add zstd compression and decompression support to BtrFS. zstd at its
fastest level compresses almost as well as zlib, while offering much
faster compression and decompression, approaching lzo speeds.
I benchmarked btrfs with zstd compression against no compression, lzo
compression, and zlib compression. I benchmarked two scenarios. Copying
a set of files to btrfs, and then reading the files. Copying a tarball
to btrfs, extracting it to btrfs, and then reading the extracted files.
After every operation, I call `sync` and include the sync time.
Between every pair of operations I unmount and remount the filesystem
to avoid caching. The benchmark files can be found in the upstream
zstd source repository under
`contrib/linux-kernel/{btrfs-benchmark.sh,btrfs-extract-benchmark.sh}`
[1] [2].
I ran the benchmarks on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.
The VM is running on a MacBook Pro with a 3.1 GHz Intel Core i7 processor,
16 GB of RAM, and a SSD.
The first compression benchmark is copying 10 copies of the unzipped
Silesia corpus [3] into a BtrFS filesystem mounted with
`-o compress-force=Method`. The decompression benchmark times how long
it takes to `tar` all 10 copies into `/dev/null`. The compression ratio is
measured by comparing the output of `df` and `du`. See the benchmark file
[1] for details. I benchmarked multiple zstd compression levels, although
the patch uses zstd level 1.
| Method | Ratio | Compression MB/s | Decompression speed |
|---------|-------|------------------|---------------------|
| None | 0.99 | 504 | 686 |
| lzo | 1.66 | 398 | 442 |
| zlib | 2.58 | 65 | 241 |
| zstd 1 | 2.57 | 260 | 383 |
| zstd 3 | 2.71 | 174 | 408 |
| zstd 6 | 2.87 | 70 | 398 |
| zstd 9 | 2.92 | 43 | 406 |
| zstd 12 | 2.93 | 21 | 408 |
| zstd 15 | 3.01 | 11 | 354 |
The next benchmark first copies `linux-4.11.6.tar` [4] to btrfs. Then it
measures the compression ratio, extracts the tar, and deletes the tar.
Then it measures the compression ratio again, and `tar`s the extracted
files into `/dev/null`. See the benchmark file [2] for details.
| Method | Tar Ratio | Extract Ratio | Copy (s) | Extract (s)| Read (s) |
|--------|-----------|---------------|----------|------------|----------|
| None | 0.97 | 0.78 | 0.981 | 5.501 | 8.807 |
| lzo | 2.06 | 1.38 | 1.631 | 8.458 | 8.585 |
| zlib | 3.40 | 1.86 | 7.750 | 21.544 | 11.744 |
| zstd 1 | 3.57 | 1.85 | 2.579 | 11.479 | 9.389 |
[1] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-benchmark.sh
[2] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-extract-benchmark.sh
[3] http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
[4] https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.11.6.tar.xz
zstd source repository: https://github.com/facebook/zstd
Signed-off-by: Nick Terrell <terrelln@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2017-08-10 02:39:02 +00:00
|
|
|
extern const struct btrfs_compress_op btrfs_zstd_compress;
|
2010-12-17 06:21:50 +00:00
|
|
|
|
2017-10-31 16:24:26 +00:00
|
|
|
const char* btrfs_compress_type2str(enum btrfs_compression_type type);
|
2019-06-06 10:07:15 +00:00
|
|
|
bool btrfs_compress_is_valid_type(const char *str, size_t len);
|
2017-10-31 16:24:26 +00:00
|
|
|
|
2017-07-17 13:52:58 +00:00
|
|
|
int btrfs_compress_heuristic(struct inode *inode, u64 start, u64 end);
|
|
|
|
|
|
2024-01-29 09:46:11 +00:00
|
|
|
int btrfs_compress_filemap_get_folio(struct address_space *mapping, u64 start,
|
|
|
|
|
struct folio **in_folio_ret);
|
2024-01-29 09:46:06 +00:00
|
|
|
|
2024-01-29 09:46:11 +00:00
|
|
|
int zlib_compress_folios(struct list_head *ws, struct address_space *mapping,
|
|
|
|
|
u64 start, struct folio **folios, unsigned long *out_folios,
|
2020-08-17 08:58:38 +00:00
|
|
|
unsigned long *total_in, unsigned long *total_out);
|
|
|
|
|
int zlib_decompress_bio(struct list_head *ws, struct compressed_bio *cb);
|
2022-11-07 16:30:21 +00:00
|
|
|
int zlib_decompress(struct list_head *ws, const u8 *data_in,
|
btrfs: zlib: fix and simplify the inline extent decompression
[BUG]
If we have a filesystem with 4k sectorsize, and an inlined compressed
extent created like this:
item 4 key (257 INODE_ITEM 0) itemoff 15863 itemsize 160
generation 8 transid 8 size 4096 nbytes 4096
block group 0 mode 100600 links 1 uid 0 gid 0 rdev 0
sequence 1 flags 0x0(none)
item 5 key (257 INODE_REF 256) itemoff 15839 itemsize 24
index 2 namelen 14 name: source_inlined
item 6 key (257 EXTENT_DATA 0) itemoff 15770 itemsize 69
generation 8 type 0 (inline)
inline extent data size 48 ram_bytes 4096 compression 1 (zlib)
Which has an inline compressed extent at file offset 0, and its
decompressed size is 4K, allowing us to reflink that 4K range to another
location (which will not be compressed).
If we do such reflink on a subpage system, it would fail like this:
# xfs_io -f -c "reflink $mnt/source_inlined 0 60k 4k" $mnt/dest
XFS_IOC_CLONE_RANGE: Input/output error
[CAUSE]
In zlib_decompress(), we didn't treat @start_byte as just a page offset,
but also use it as an indicator on whether we should switch our output
buffer.
In reality, for subpage cases, although @start_byte can be non-zero,
we should never switch input/output buffer, since the whole input/output
buffer should never exceed one sector.
Note: The above assumption is only not true if we're going to support
multi-page sectorsize.
Thus the current code using @start_byte as a condition to switch
input/output buffer or finish the decompression is completely incorrect.
[FIX]
The fix involves several modifications:
- Rename @start_byte to @dest_pgoff to properly express its meaning
- Add an extra ASSERT() inside btrfs_decompress() to make sure the
input/output size never exceeds one sector.
- Use Z_FINISH flag to make sure the decompression happens in one go
- Remove the loop needed to switch input/output buffers
- Use correct destination offset inside the destination page
- Consider early end as an error
After the fix, even on 64K page sized aarch64, above reflink now
works as expected:
# xfs_io -f -c "reflink $mnt/source_inlined 0 60k 4k" $mnt/dest
linked 4096/4096 bytes at offset 61440
And resulted a correct file layout:
item 9 key (258 INODE_ITEM 0) itemoff 15542 itemsize 160
generation 10 transid 10 size 65536 nbytes 4096
block group 0 mode 100600 links 1 uid 0 gid 0 rdev 0
sequence 1 flags 0x0(none)
item 10 key (258 INODE_REF 256) itemoff 15528 itemsize 14
index 3 namelen 4 name: dest
item 11 key (258 XATTR_ITEM 3817753667) itemoff 15445 itemsize 83
location key (0 UNKNOWN.0 0) type XATTR
transid 10 data_len 37 name_len 16
name: security.selinux
data unconfined_u:object_r:unlabeled_t:s0
item 12 key (258 EXTENT_DATA 61440) itemoff 15392 itemsize 53
generation 10 type 1 (regular)
extent data disk byte 13631488 nr 4096
extent data offset 0 nr 4096 ram 4096
extent compression 0 (none)
Signed-off-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2024-01-08 09:08:44 +00:00
|
|
|
struct page *dest_page, unsigned long dest_pgoff, size_t srclen,
|
2020-08-17 08:58:38 +00:00
|
|
|
size_t destlen);
|
|
|
|
|
struct list_head *zlib_alloc_workspace(unsigned int level);
|
|
|
|
|
void zlib_free_workspace(struct list_head *ws);
|
|
|
|
|
struct list_head *zlib_get_workspace(unsigned int level);
|
|
|
|
|
|
2024-01-29 09:46:11 +00:00
|
|
|
int lzo_compress_folios(struct list_head *ws, struct address_space *mapping,
|
|
|
|
|
u64 start, struct folio **folios, unsigned long *out_folios,
|
2020-08-17 08:58:38 +00:00
|
|
|
unsigned long *total_in, unsigned long *total_out);
|
|
|
|
|
int lzo_decompress_bio(struct list_head *ws, struct compressed_bio *cb);
|
2022-11-07 16:30:21 +00:00
|
|
|
int lzo_decompress(struct list_head *ws, const u8 *data_in,
|
btrfs: lzo: fix and simplify the inline extent decompression
[BUG]
If we have a filesystem with 4k sectorsize, and an inlined compressed
extent created like this:
item 4 key (257 INODE_ITEM 0) itemoff 15863 itemsize 160
generation 8 transid 8 size 4096 nbytes 4096
block group 0 mode 100600 links 1 uid 0 gid 0 rdev 0
sequence 1 flags 0x0(none)
item 5 key (257 INODE_REF 256) itemoff 15839 itemsize 24
index 2 namelen 14 name: source_inlined
item 6 key (257 EXTENT_DATA 0) itemoff 15770 itemsize 69
generation 8 type 0 (inline)
inline extent data size 48 ram_bytes 4096 compression 2 (lzo)
Then trying to reflink that extent in an aarch64 system with 64K page
size, the reflink would just fail:
# xfs_io -f -c "reflink $mnt/source_inlined 0 60k 4k" $mnt/dest
XFS_IOC_CLONE_RANGE: Input/output error
[CAUSE]
In zlib_decompress(), we didn't treat @start_byte as just a page offset,
but also use it as an indicator on whether we should error out, without
any proper explanation (this is from the very beginning of btrfs).
In reality, for subpage cases, although @start_byte can be non-zero,
we should never switch input/output buffer nor error out, since the whole
input/output buffer should never exceed one sector.
Note: The above assumption is only not true if we're going to support
multi-page sectorsize.
Thus the current code using @start_byte as a condition to switch
input/output buffer or finish the decompression is completely incorrect.
[FIX]
The fix involves several modifications:
- Rename @start_byte to @dest_pgoff to properly express its meaning
- Use @sectorsize other than PAGE_SIZE to properly initialize the
output buffer size
- Use correct destination offset inside the destination page
- Use memcpy_to_page() to copy the contents to the destination page
- Use memzero_page() to zero out the tailing part
- Consider early end as an error
After the fix, even on 64K page sized aarch64, above reflink now
works as expected:
# xfs_io -f -c "reflink $mnt/source_inlined 0 60k 4k" $mnt/dest
linked 4096/4096 bytes at offset 61440
And results the correct file layout:
item 9 key (258 INODE_ITEM 0) itemoff 15542 itemsize 160
generation 10 transid 10 size 65536 nbytes 4096
block group 0 mode 100600 links 1 uid 0 gid 0 rdev 0
sequence 1 flags 0x0(none)
item 10 key (258 INODE_REF 256) itemoff 15528 itemsize 14
index 3 namelen 4 name: dest
item 11 key (258 XATTR_ITEM 3817753667) itemoff 15445 itemsize 83
location key (0 UNKNOWN.0 0) type XATTR
transid 10 data_len 37 name_len 16
name: security.selinux
data unconfined_u:object_r:unlabeled_t:s0
item 12 key (258 EXTENT_DATA 61440) itemoff 15392 itemsize 53
generation 10 type 1 (regular)
extent data disk byte 13631488 nr 4096
extent data offset 0 nr 4096 ram 4096
extent compression 0 (none)
Signed-off-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2024-01-08 09:08:45 +00:00
|
|
|
struct page *dest_page, unsigned long dest_pgoff, size_t srclen,
|
2020-08-17 08:58:38 +00:00
|
|
|
size_t destlen);
|
|
|
|
|
struct list_head *lzo_alloc_workspace(unsigned int level);
|
|
|
|
|
void lzo_free_workspace(struct list_head *ws);
|
|
|
|
|
|
2024-01-29 09:46:11 +00:00
|
|
|
int zstd_compress_folios(struct list_head *ws, struct address_space *mapping,
|
|
|
|
|
u64 start, struct folio **folios, unsigned long *out_folios,
|
2020-08-17 08:58:38 +00:00
|
|
|
unsigned long *total_in, unsigned long *total_out);
|
|
|
|
|
int zstd_decompress_bio(struct list_head *ws, struct compressed_bio *cb);
|
2022-11-07 16:30:21 +00:00
|
|
|
int zstd_decompress(struct list_head *ws, const u8 *data_in,
|
btrfs: zstd: fix and simplify the inline extent decompression (v2)
Note: this is a fixed version that was previously reverted as
e01a83e12604 ("Revert "btrfs: zstd: fix and simplify the inline extent
decompression""), with fixed parameters to memzero_page().
[BUG]
If we have a filesystem with 4k sectorsize, and an inlined compressed
extent created like this:
item 4 key (257 INODE_ITEM 0) itemoff 15863 itemsize 160
generation 8 transid 8 size 4096 nbytes 4096
block group 0 mode 100600 links 1 uid 0 gid 0 rdev 0
sequence 1 flags 0x0(none)
item 5 key (257 INODE_REF 256) itemoff 15839 itemsize 24
index 2 namelen 14 name: source_inlined
item 6 key (257 EXTENT_DATA 0) itemoff 15770 itemsize 69
generation 8 type 0 (inline)
inline extent data size 48 ram_bytes 4096 compression 3 (zstd)
Then trying to reflink that extent in an aarch64 system with 64K page
size, the reflink would just fail:
# xfs_io -f -c "reflink $mnt/source_inlined 0 60k 4k" $mnt/dest
XFS_IOC_CLONE_RANGE: Input/output error
[CAUSE]
In zstd_decompress(), we didn't treat @start_byte as just a page offset,
but also use it as an indicator on whether we should error out, without
any proper explanation (this is copied from other decompression code).
In reality, for subpage cases, although @start_byte can be non-zero,
we should never switch input/output buffer nor error out, since the whole
input/output buffer should never exceed one sector, thus we should not
need to do any buffer switch.
Thus the current code using @start_byte as a condition to switch
input/output buffer or finish the decompression is completely incorrect.
[FIX]
The fix involves several modification:
- Rename @start_byte to @dest_pgoff to properly express its meaning
- Use @sectorsize other than PAGE_SIZE to properly initialize the
output buffer size
- Use correct destination offset inside the destination page
- Simplify the main loop
Since the input/output buffer should never switch, we only need one
zstd_decompress_stream() call.
- Consider early end as an error
After the fix, even on 64K page sized aarch64, above reflink now
works as expected:
# xfs_io -f -c "reflink $mnt/source_inlined 0 60k 4k" $mnt/dest
linked 4096/4096 bytes at offset 61440
And results the correct file layout:
item 9 key (258 INODE_ITEM 0) itemoff 15542 itemsize 160
generation 10 transid 10 size 65536 nbytes 4096
block group 0 mode 100600 links 1 uid 0 gid 0 rdev 0
sequence 1 flags 0x0(none)
item 10 key (258 INODE_REF 256) itemoff 15528 itemsize 14
index 3 namelen 4 name: dest
item 11 key (258 XATTR_ITEM 3817753667) itemoff 15445 itemsize 83
location key (0 UNKNOWN.0 0) type XATTR
transid 10 data_len 37 name_len 16
name: security.selinux
data unconfined_u:object_r:unlabeled_t:s0
item 12 key (258 EXTENT_DATA 61440) itemoff 15392 itemsize 53
generation 10 type 1 (regular)
extent data disk byte 13631488 nr 4096
extent data offset 0 nr 4096 ram 4096
extent compression 0 (none)
Signed-off-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2024-01-23 03:03:30 +00:00
|
|
|
struct page *dest_page, unsigned long dest_pgoff, size_t srclen,
|
2020-08-17 08:58:38 +00:00
|
|
|
size_t destlen);
|
|
|
|
|
void zstd_init_workspace_manager(void);
|
|
|
|
|
void zstd_cleanup_workspace_manager(void);
|
|
|
|
|
struct list_head *zstd_alloc_workspace(unsigned int level);
|
|
|
|
|
void zstd_free_workspace(struct list_head *ws);
|
|
|
|
|
struct list_head *zstd_get_workspace(unsigned int level);
|
|
|
|
|
void zstd_put_workspace(struct list_head *ws);
|
|
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 18:49:59 +00:00
|
|
|
#endif
|