mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 20:02:17 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
-----BEGIN PGP SIGNATURE----- iQIzBAABCgAdFiEE8rQSAMVO+zA4DBdWxWXV+ddtWDsFAmF/7PAACgkQxWXV+ddt WDtp6A//SbVYeuHWpsXkhBiOpJt2PpS1K8VY5LIJc3brua5EZm8IarlR57X9IqYu 89ZlWnuANrw4d5RRiIO+NYhc+DR6+ydxHesJG+I2B+o5OnR0Ynb06gLhsP1tSK6y lYZORQFJZP051ODU/uEc8A0KZN7DySIUmqezAibfyxepF6oPEap0nFp17/B80tWp sKdMp2TBN5ymZwsdSK1nZ7ws1ZL57HgkFDPqp8m8CuPTkneG4CtNol6yUpuPExpL QzvQsqTygmiFoy0uNTG7Rg7IlKqEuhbR7lwfkmcBZCV66JmhFco5QhxN13QIn42s +YSug52SMWc8YVHIEj16xtBgHEqZXWYey8d2ewhc0tDSGDm0HmXCNjcn1vYr0NJr 5bW/7/3bpkHYejasy1wDEK5P8Uo2xsgpRyAvuEReGoRi8ze66EohahvP3o7YJi/Q o0pROXdCT89JbM/T4MTvN/5MUlCSM7rnexXZ39ldGNacPgn9FAUCPw6KtzKKyVRe DF19nPOUXSg6SLECbVkRQUwcOjxOTFP+T0Jx61Um8bomFskYJJnmr4SD3pqlzgp7 NxV5ad0+r7zU0x9MADkyqboObo0ROAfD4hthcZiRN+0UIK+Gq5nATTD5ur6/nwsT 0PJGOXDPz7cmfqUdmvpA0ctRxbFEqpaz6sDh7nq/iUSmaGITcUM= =HvYu -----END PGP SIGNATURE----- Merge tag 'for-5.16-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux Pull btrfs updates from David Sterba: "The updates this time are more under the hood and enhancing existing features (subpage with compression and zoned namespaces). Performance related: - misc small inode logging improvements (+3% throughput, -11% latency on sample dbench workload) - more efficient directory logging: bulk item insertion, less tree searches and locking - speed up bulk insertion of items into a b-tree, which is used when logging directories, when running delayed items for directories (fsync and transaction commits) and when running the slow path (full sync) of an fsync (bulk creation run time -4%, deletion -12%) Core: - continued subpage support - make defragmentation work - make compression write work - zoned mode - support ZNS (zoned namespaces), zone capacity is number of usable blocks in each zone - add dedicated block group (zoned) for relocation, to prevent out of order writes in some cases - greedy block group reclaim, pick the ones with least usable space first - preparatory work for send protocol updates - error handling improvements - cleanups and refactoring Fixes: - lockdep warnings - in show_devname callback, on seeding device - device delete on loop device due to conversions to workqueues - fix deadlock between chunk allocation and chunk btree modifications - fix tracking of missing device count and status" * tag 'for-5.16-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux: (140 commits) btrfs: remove root argument from check_item_in_log() btrfs: remove root argument from add_link() btrfs: remove root argument from btrfs_unlink_inode() btrfs: remove root argument from drop_one_dir_item() btrfs: clear MISSING device status bit in btrfs_close_one_device btrfs: call btrfs_check_rw_degradable only if there is a missing device btrfs: send: prepare for v2 protocol btrfs: fix comment about sector sizes supported in 64K systems btrfs: update device path inode time instead of bd_inode fs: export an inode_update_time helper btrfs: fix deadlock when defragging transparent huge pages btrfs: sysfs: convert scnprintf and snprintf to sysfs_emit btrfs: make btrfs_super_block size match BTRFS_SUPER_INFO_SIZE btrfs: update comments for chunk allocation -ENOSPC cases btrfs: fix deadlock between chunk allocation and chunk btree modifications btrfs: zoned: use greedy gc for auto reclaim btrfs: check-integrity: stop storing the block device name in btrfsic_dev_state btrfs: use btrfs_get_dev_args_from_path in dev removal ioctls btrfs: add a btrfs_get_dev_args_from_path helper btrfs: handle device lookup with btrfs_dev_lookup_args ...
1889 lines
50 KiB
C
1889 lines
50 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2008 Oracle. All rights reserved.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/bio.h>
|
|
#include <linux/file.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/highmem.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/time.h>
|
|
#include <linux/init.h>
|
|
#include <linux/string.h>
|
|
#include <linux/backing-dev.h>
|
|
#include <linux/writeback.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/sched/mm.h>
|
|
#include <linux/log2.h>
|
|
#include <crypto/hash.h>
|
|
#include "misc.h"
|
|
#include "ctree.h"
|
|
#include "disk-io.h"
|
|
#include "transaction.h"
|
|
#include "btrfs_inode.h"
|
|
#include "volumes.h"
|
|
#include "ordered-data.h"
|
|
#include "compression.h"
|
|
#include "extent_io.h"
|
|
#include "extent_map.h"
|
|
#include "subpage.h"
|
|
#include "zoned.h"
|
|
|
|
static const char* const btrfs_compress_types[] = { "", "zlib", "lzo", "zstd" };
|
|
|
|
const char* btrfs_compress_type2str(enum btrfs_compression_type type)
|
|
{
|
|
switch (type) {
|
|
case BTRFS_COMPRESS_ZLIB:
|
|
case BTRFS_COMPRESS_LZO:
|
|
case BTRFS_COMPRESS_ZSTD:
|
|
case BTRFS_COMPRESS_NONE:
|
|
return btrfs_compress_types[type];
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool btrfs_compress_is_valid_type(const char *str, size_t len)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < ARRAY_SIZE(btrfs_compress_types); i++) {
|
|
size_t comp_len = strlen(btrfs_compress_types[i]);
|
|
|
|
if (len < comp_len)
|
|
continue;
|
|
|
|
if (!strncmp(btrfs_compress_types[i], str, comp_len))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static int compression_compress_pages(int type, struct list_head *ws,
|
|
struct address_space *mapping, u64 start, struct page **pages,
|
|
unsigned long *out_pages, unsigned long *total_in,
|
|
unsigned long *total_out)
|
|
{
|
|
switch (type) {
|
|
case BTRFS_COMPRESS_ZLIB:
|
|
return zlib_compress_pages(ws, mapping, start, pages,
|
|
out_pages, total_in, total_out);
|
|
case BTRFS_COMPRESS_LZO:
|
|
return lzo_compress_pages(ws, mapping, start, pages,
|
|
out_pages, total_in, total_out);
|
|
case BTRFS_COMPRESS_ZSTD:
|
|
return zstd_compress_pages(ws, mapping, start, pages,
|
|
out_pages, total_in, total_out);
|
|
case BTRFS_COMPRESS_NONE:
|
|
default:
|
|
/*
|
|
* This can happen when compression races with remount setting
|
|
* it to 'no compress', while caller doesn't call
|
|
* inode_need_compress() to check if we really need to
|
|
* compress.
|
|
*
|
|
* Not a big deal, just need to inform caller that we
|
|
* haven't allocated any pages yet.
|
|
*/
|
|
*out_pages = 0;
|
|
return -E2BIG;
|
|
}
|
|
}
|
|
|
|
static int compression_decompress_bio(int type, struct list_head *ws,
|
|
struct compressed_bio *cb)
|
|
{
|
|
switch (type) {
|
|
case BTRFS_COMPRESS_ZLIB: return zlib_decompress_bio(ws, cb);
|
|
case BTRFS_COMPRESS_LZO: return lzo_decompress_bio(ws, cb);
|
|
case BTRFS_COMPRESS_ZSTD: return zstd_decompress_bio(ws, cb);
|
|
case BTRFS_COMPRESS_NONE:
|
|
default:
|
|
/*
|
|
* This can't happen, the type is validated several times
|
|
* before we get here.
|
|
*/
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
static int compression_decompress(int type, struct list_head *ws,
|
|
unsigned char *data_in, struct page *dest_page,
|
|
unsigned long start_byte, size_t srclen, size_t destlen)
|
|
{
|
|
switch (type) {
|
|
case BTRFS_COMPRESS_ZLIB: return zlib_decompress(ws, data_in, dest_page,
|
|
start_byte, srclen, destlen);
|
|
case BTRFS_COMPRESS_LZO: return lzo_decompress(ws, data_in, dest_page,
|
|
start_byte, srclen, destlen);
|
|
case BTRFS_COMPRESS_ZSTD: return zstd_decompress(ws, data_in, dest_page,
|
|
start_byte, srclen, destlen);
|
|
case BTRFS_COMPRESS_NONE:
|
|
default:
|
|
/*
|
|
* This can't happen, the type is validated several times
|
|
* before we get here.
|
|
*/
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
static int btrfs_decompress_bio(struct compressed_bio *cb);
|
|
|
|
static inline int compressed_bio_size(struct btrfs_fs_info *fs_info,
|
|
unsigned long disk_size)
|
|
{
|
|
return sizeof(struct compressed_bio) +
|
|
(DIV_ROUND_UP(disk_size, fs_info->sectorsize)) * fs_info->csum_size;
|
|
}
|
|
|
|
static int check_compressed_csum(struct btrfs_inode *inode, struct bio *bio,
|
|
u64 disk_start)
|
|
{
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
|
|
const u32 csum_size = fs_info->csum_size;
|
|
const u32 sectorsize = fs_info->sectorsize;
|
|
struct page *page;
|
|
unsigned int i;
|
|
char *kaddr;
|
|
u8 csum[BTRFS_CSUM_SIZE];
|
|
struct compressed_bio *cb = bio->bi_private;
|
|
u8 *cb_sum = cb->sums;
|
|
|
|
if (!fs_info->csum_root || (inode->flags & BTRFS_INODE_NODATASUM))
|
|
return 0;
|
|
|
|
shash->tfm = fs_info->csum_shash;
|
|
|
|
for (i = 0; i < cb->nr_pages; i++) {
|
|
u32 pg_offset;
|
|
u32 bytes_left = PAGE_SIZE;
|
|
page = cb->compressed_pages[i];
|
|
|
|
/* Determine the remaining bytes inside the page first */
|
|
if (i == cb->nr_pages - 1)
|
|
bytes_left = cb->compressed_len - i * PAGE_SIZE;
|
|
|
|
/* Hash through the page sector by sector */
|
|
for (pg_offset = 0; pg_offset < bytes_left;
|
|
pg_offset += sectorsize) {
|
|
kaddr = kmap_atomic(page);
|
|
crypto_shash_digest(shash, kaddr + pg_offset,
|
|
sectorsize, csum);
|
|
kunmap_atomic(kaddr);
|
|
|
|
if (memcmp(&csum, cb_sum, csum_size) != 0) {
|
|
btrfs_print_data_csum_error(inode, disk_start,
|
|
csum, cb_sum, cb->mirror_num);
|
|
if (btrfs_bio(bio)->device)
|
|
btrfs_dev_stat_inc_and_print(
|
|
btrfs_bio(bio)->device,
|
|
BTRFS_DEV_STAT_CORRUPTION_ERRS);
|
|
return -EIO;
|
|
}
|
|
cb_sum += csum_size;
|
|
disk_start += sectorsize;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Reduce bio and io accounting for a compressed_bio with its corresponding bio.
|
|
*
|
|
* Return true if there is no pending bio nor io.
|
|
* Return false otherwise.
|
|
*/
|
|
static bool dec_and_test_compressed_bio(struct compressed_bio *cb, struct bio *bio)
|
|
{
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(cb->inode->i_sb);
|
|
unsigned int bi_size = 0;
|
|
bool last_io = false;
|
|
struct bio_vec *bvec;
|
|
struct bvec_iter_all iter_all;
|
|
|
|
/*
|
|
* At endio time, bi_iter.bi_size doesn't represent the real bio size.
|
|
* Thus here we have to iterate through all segments to grab correct
|
|
* bio size.
|
|
*/
|
|
bio_for_each_segment_all(bvec, bio, iter_all)
|
|
bi_size += bvec->bv_len;
|
|
|
|
if (bio->bi_status)
|
|
cb->errors = 1;
|
|
|
|
ASSERT(bi_size && bi_size <= cb->compressed_len);
|
|
last_io = refcount_sub_and_test(bi_size >> fs_info->sectorsize_bits,
|
|
&cb->pending_sectors);
|
|
/*
|
|
* Here we must wake up the possible error handler after all other
|
|
* operations on @cb finished, or we can race with
|
|
* finish_compressed_bio_*() which may free @cb.
|
|
*/
|
|
wake_up_var(cb);
|
|
|
|
return last_io;
|
|
}
|
|
|
|
static void finish_compressed_bio_read(struct compressed_bio *cb, struct bio *bio)
|
|
{
|
|
unsigned int index;
|
|
struct page *page;
|
|
|
|
/* Release the compressed pages */
|
|
for (index = 0; index < cb->nr_pages; index++) {
|
|
page = cb->compressed_pages[index];
|
|
page->mapping = NULL;
|
|
put_page(page);
|
|
}
|
|
|
|
/* Do io completion on the original bio */
|
|
if (cb->errors) {
|
|
bio_io_error(cb->orig_bio);
|
|
} else {
|
|
struct bio_vec *bvec;
|
|
struct bvec_iter_all iter_all;
|
|
|
|
ASSERT(bio);
|
|
ASSERT(!bio->bi_status);
|
|
/*
|
|
* We have verified the checksum already, set page checked so
|
|
* the end_io handlers know about it
|
|
*/
|
|
ASSERT(!bio_flagged(bio, BIO_CLONED));
|
|
bio_for_each_segment_all(bvec, cb->orig_bio, iter_all) {
|
|
u64 bvec_start = page_offset(bvec->bv_page) +
|
|
bvec->bv_offset;
|
|
|
|
btrfs_page_set_checked(btrfs_sb(cb->inode->i_sb),
|
|
bvec->bv_page, bvec_start,
|
|
bvec->bv_len);
|
|
}
|
|
|
|
bio_endio(cb->orig_bio);
|
|
}
|
|
|
|
/* Finally free the cb struct */
|
|
kfree(cb->compressed_pages);
|
|
kfree(cb);
|
|
}
|
|
|
|
/* when we finish reading compressed pages from the disk, we
|
|
* decompress them and then run the bio end_io routines on the
|
|
* decompressed pages (in the inode address space).
|
|
*
|
|
* This allows the checksumming and other IO error handling routines
|
|
* to work normally
|
|
*
|
|
* The compressed pages are freed here, and it must be run
|
|
* in process context
|
|
*/
|
|
static void end_compressed_bio_read(struct bio *bio)
|
|
{
|
|
struct compressed_bio *cb = bio->bi_private;
|
|
struct inode *inode;
|
|
unsigned int mirror = btrfs_bio(bio)->mirror_num;
|
|
int ret = 0;
|
|
|
|
if (!dec_and_test_compressed_bio(cb, bio))
|
|
goto out;
|
|
|
|
/*
|
|
* Record the correct mirror_num in cb->orig_bio so that
|
|
* read-repair can work properly.
|
|
*/
|
|
btrfs_bio(cb->orig_bio)->mirror_num = mirror;
|
|
cb->mirror_num = mirror;
|
|
|
|
/*
|
|
* Some IO in this cb have failed, just skip checksum as there
|
|
* is no way it could be correct.
|
|
*/
|
|
if (cb->errors == 1)
|
|
goto csum_failed;
|
|
|
|
inode = cb->inode;
|
|
ret = check_compressed_csum(BTRFS_I(inode), bio,
|
|
bio->bi_iter.bi_sector << 9);
|
|
if (ret)
|
|
goto csum_failed;
|
|
|
|
/* ok, we're the last bio for this extent, lets start
|
|
* the decompression.
|
|
*/
|
|
ret = btrfs_decompress_bio(cb);
|
|
|
|
csum_failed:
|
|
if (ret)
|
|
cb->errors = 1;
|
|
finish_compressed_bio_read(cb, bio);
|
|
out:
|
|
bio_put(bio);
|
|
}
|
|
|
|
/*
|
|
* Clear the writeback bits on all of the file
|
|
* pages for a compressed write
|
|
*/
|
|
static noinline void end_compressed_writeback(struct inode *inode,
|
|
const struct compressed_bio *cb)
|
|
{
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
|
|
unsigned long index = cb->start >> PAGE_SHIFT;
|
|
unsigned long end_index = (cb->start + cb->len - 1) >> PAGE_SHIFT;
|
|
struct page *pages[16];
|
|
unsigned long nr_pages = end_index - index + 1;
|
|
int i;
|
|
int ret;
|
|
|
|
if (cb->errors)
|
|
mapping_set_error(inode->i_mapping, -EIO);
|
|
|
|
while (nr_pages > 0) {
|
|
ret = find_get_pages_contig(inode->i_mapping, index,
|
|
min_t(unsigned long,
|
|
nr_pages, ARRAY_SIZE(pages)), pages);
|
|
if (ret == 0) {
|
|
nr_pages -= 1;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
for (i = 0; i < ret; i++) {
|
|
if (cb->errors)
|
|
SetPageError(pages[i]);
|
|
btrfs_page_clamp_clear_writeback(fs_info, pages[i],
|
|
cb->start, cb->len);
|
|
put_page(pages[i]);
|
|
}
|
|
nr_pages -= ret;
|
|
index += ret;
|
|
}
|
|
/* the inode may be gone now */
|
|
}
|
|
|
|
static void finish_compressed_bio_write(struct compressed_bio *cb)
|
|
{
|
|
struct inode *inode = cb->inode;
|
|
unsigned int index;
|
|
|
|
/*
|
|
* Ok, we're the last bio for this extent, step one is to call back
|
|
* into the FS and do all the end_io operations.
|
|
*/
|
|
btrfs_writepage_endio_finish_ordered(BTRFS_I(inode), NULL,
|
|
cb->start, cb->start + cb->len - 1,
|
|
!cb->errors);
|
|
|
|
end_compressed_writeback(inode, cb);
|
|
/* Note, our inode could be gone now */
|
|
|
|
/*
|
|
* Release the compressed pages, these came from alloc_page and
|
|
* are not attached to the inode at all
|
|
*/
|
|
for (index = 0; index < cb->nr_pages; index++) {
|
|
struct page *page = cb->compressed_pages[index];
|
|
|
|
page->mapping = NULL;
|
|
put_page(page);
|
|
}
|
|
|
|
/* Finally free the cb struct */
|
|
kfree(cb->compressed_pages);
|
|
kfree(cb);
|
|
}
|
|
|
|
/*
|
|
* Do the cleanup once all the compressed pages hit the disk. This will clear
|
|
* writeback on the file pages and free the compressed pages.
|
|
*
|
|
* This also calls the writeback end hooks for the file pages so that metadata
|
|
* and checksums can be updated in the file.
|
|
*/
|
|
static void end_compressed_bio_write(struct bio *bio)
|
|
{
|
|
struct compressed_bio *cb = bio->bi_private;
|
|
|
|
if (!dec_and_test_compressed_bio(cb, bio))
|
|
goto out;
|
|
|
|
btrfs_record_physical_zoned(cb->inode, cb->start, bio);
|
|
|
|
finish_compressed_bio_write(cb);
|
|
out:
|
|
bio_put(bio);
|
|
}
|
|
|
|
static blk_status_t submit_compressed_bio(struct btrfs_fs_info *fs_info,
|
|
struct compressed_bio *cb,
|
|
struct bio *bio, int mirror_num)
|
|
{
|
|
blk_status_t ret;
|
|
|
|
ASSERT(bio->bi_iter.bi_size);
|
|
ret = btrfs_bio_wq_end_io(fs_info, bio, BTRFS_WQ_ENDIO_DATA);
|
|
if (ret)
|
|
return ret;
|
|
ret = btrfs_map_bio(fs_info, bio, mirror_num);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Allocate a compressed_bio, which will be used to read/write on-disk
|
|
* (aka, compressed) * data.
|
|
*
|
|
* @cb: The compressed_bio structure, which records all the needed
|
|
* information to bind the compressed data to the uncompressed
|
|
* page cache.
|
|
* @disk_byten: The logical bytenr where the compressed data will be read
|
|
* from or written to.
|
|
* @endio_func: The endio function to call after the IO for compressed data
|
|
* is finished.
|
|
* @next_stripe_start: Return value of logical bytenr of where next stripe starts.
|
|
* Let the caller know to only fill the bio up to the stripe
|
|
* boundary.
|
|
*/
|
|
|
|
|
|
static struct bio *alloc_compressed_bio(struct compressed_bio *cb, u64 disk_bytenr,
|
|
unsigned int opf, bio_end_io_t endio_func,
|
|
u64 *next_stripe_start)
|
|
{
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(cb->inode->i_sb);
|
|
struct btrfs_io_geometry geom;
|
|
struct extent_map *em;
|
|
struct bio *bio;
|
|
int ret;
|
|
|
|
bio = btrfs_bio_alloc(BIO_MAX_VECS);
|
|
|
|
bio->bi_iter.bi_sector = disk_bytenr >> SECTOR_SHIFT;
|
|
bio->bi_opf = opf;
|
|
bio->bi_private = cb;
|
|
bio->bi_end_io = endio_func;
|
|
|
|
em = btrfs_get_chunk_map(fs_info, disk_bytenr, fs_info->sectorsize);
|
|
if (IS_ERR(em)) {
|
|
bio_put(bio);
|
|
return ERR_CAST(em);
|
|
}
|
|
|
|
if (bio_op(bio) == REQ_OP_ZONE_APPEND)
|
|
bio_set_dev(bio, em->map_lookup->stripes[0].dev->bdev);
|
|
|
|
ret = btrfs_get_io_geometry(fs_info, em, btrfs_op(bio), disk_bytenr, &geom);
|
|
free_extent_map(em);
|
|
if (ret < 0) {
|
|
bio_put(bio);
|
|
return ERR_PTR(ret);
|
|
}
|
|
*next_stripe_start = disk_bytenr + geom.len;
|
|
|
|
return bio;
|
|
}
|
|
|
|
/*
|
|
* worker function to build and submit bios for previously compressed pages.
|
|
* The corresponding pages in the inode should be marked for writeback
|
|
* and the compressed pages should have a reference on them for dropping
|
|
* when the IO is complete.
|
|
*
|
|
* This also checksums the file bytes and gets things ready for
|
|
* the end io hooks.
|
|
*/
|
|
blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
|
|
unsigned int len, u64 disk_start,
|
|
unsigned int compressed_len,
|
|
struct page **compressed_pages,
|
|
unsigned int nr_pages,
|
|
unsigned int write_flags,
|
|
struct cgroup_subsys_state *blkcg_css)
|
|
{
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
struct bio *bio = NULL;
|
|
struct compressed_bio *cb;
|
|
u64 cur_disk_bytenr = disk_start;
|
|
u64 next_stripe_start;
|
|
blk_status_t ret;
|
|
int skip_sum = inode->flags & BTRFS_INODE_NODATASUM;
|
|
const bool use_append = btrfs_use_zone_append(inode, disk_start);
|
|
const unsigned int bio_op = use_append ? REQ_OP_ZONE_APPEND : REQ_OP_WRITE;
|
|
|
|
ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
|
|
IS_ALIGNED(len, fs_info->sectorsize));
|
|
cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);
|
|
if (!cb)
|
|
return BLK_STS_RESOURCE;
|
|
refcount_set(&cb->pending_sectors, compressed_len >> fs_info->sectorsize_bits);
|
|
cb->errors = 0;
|
|
cb->inode = &inode->vfs_inode;
|
|
cb->start = start;
|
|
cb->len = len;
|
|
cb->mirror_num = 0;
|
|
cb->compressed_pages = compressed_pages;
|
|
cb->compressed_len = compressed_len;
|
|
cb->orig_bio = NULL;
|
|
cb->nr_pages = nr_pages;
|
|
|
|
while (cur_disk_bytenr < disk_start + compressed_len) {
|
|
u64 offset = cur_disk_bytenr - disk_start;
|
|
unsigned int index = offset >> PAGE_SHIFT;
|
|
unsigned int real_size;
|
|
unsigned int added;
|
|
struct page *page = compressed_pages[index];
|
|
bool submit = false;
|
|
|
|
/* Allocate new bio if submitted or not yet allocated */
|
|
if (!bio) {
|
|
bio = alloc_compressed_bio(cb, cur_disk_bytenr,
|
|
bio_op | write_flags, end_compressed_bio_write,
|
|
&next_stripe_start);
|
|
if (IS_ERR(bio)) {
|
|
ret = errno_to_blk_status(PTR_ERR(bio));
|
|
bio = NULL;
|
|
goto finish_cb;
|
|
}
|
|
}
|
|
/*
|
|
* We should never reach next_stripe_start start as we will
|
|
* submit comp_bio when reach the boundary immediately.
|
|
*/
|
|
ASSERT(cur_disk_bytenr != next_stripe_start);
|
|
|
|
/*
|
|
* We have various limits on the real read size:
|
|
* - stripe boundary
|
|
* - page boundary
|
|
* - compressed length boundary
|
|
*/
|
|
real_size = min_t(u64, U32_MAX, next_stripe_start - cur_disk_bytenr);
|
|
real_size = min_t(u64, real_size, PAGE_SIZE - offset_in_page(offset));
|
|
real_size = min_t(u64, real_size, compressed_len - offset);
|
|
ASSERT(IS_ALIGNED(real_size, fs_info->sectorsize));
|
|
|
|
if (use_append)
|
|
added = bio_add_zone_append_page(bio, page, real_size,
|
|
offset_in_page(offset));
|
|
else
|
|
added = bio_add_page(bio, page, real_size,
|
|
offset_in_page(offset));
|
|
/* Reached zoned boundary */
|
|
if (added == 0)
|
|
submit = true;
|
|
|
|
cur_disk_bytenr += added;
|
|
/* Reached stripe boundary */
|
|
if (cur_disk_bytenr == next_stripe_start)
|
|
submit = true;
|
|
|
|
/* Finished the range */
|
|
if (cur_disk_bytenr == disk_start + compressed_len)
|
|
submit = true;
|
|
|
|
if (submit) {
|
|
if (!skip_sum) {
|
|
ret = btrfs_csum_one_bio(inode, bio, start, 1);
|
|
if (ret)
|
|
goto finish_cb;
|
|
}
|
|
|
|
ret = submit_compressed_bio(fs_info, cb, bio, 0);
|
|
if (ret)
|
|
goto finish_cb;
|
|
bio = NULL;
|
|
}
|
|
cond_resched();
|
|
}
|
|
if (blkcg_css)
|
|
kthread_associate_blkcg(NULL);
|
|
|
|
return 0;
|
|
|
|
finish_cb:
|
|
if (bio) {
|
|
bio->bi_status = ret;
|
|
bio_endio(bio);
|
|
}
|
|
/* Last byte of @cb is submitted, endio will free @cb */
|
|
if (cur_disk_bytenr == disk_start + compressed_len)
|
|
return ret;
|
|
|
|
wait_var_event(cb, refcount_read(&cb->pending_sectors) ==
|
|
(disk_start + compressed_len - cur_disk_bytenr) >>
|
|
fs_info->sectorsize_bits);
|
|
/*
|
|
* Even with previous bio ended, we should still have io not yet
|
|
* submitted, thus need to finish manually.
|
|
*/
|
|
ASSERT(refcount_read(&cb->pending_sectors));
|
|
/* Now we are the only one referring @cb, can finish it safely. */
|
|
finish_compressed_bio_write(cb);
|
|
return ret;
|
|
}
|
|
|
|
static u64 bio_end_offset(struct bio *bio)
|
|
{
|
|
struct bio_vec *last = bio_last_bvec_all(bio);
|
|
|
|
return page_offset(last->bv_page) + last->bv_len + last->bv_offset;
|
|
}
|
|
|
|
/*
|
|
* Add extra pages in the same compressed file extent so that we don't need to
|
|
* re-read the same extent again and again.
|
|
*
|
|
* NOTE: this won't work well for subpage, as for subpage read, we lock the
|
|
* full page then submit bio for each compressed/regular extents.
|
|
*
|
|
* This means, if we have several sectors in the same page points to the same
|
|
* on-disk compressed data, we will re-read the same extent many times and
|
|
* this function can only help for the next page.
|
|
*/
|
|
static noinline int add_ra_bio_pages(struct inode *inode,
|
|
u64 compressed_end,
|
|
struct compressed_bio *cb)
|
|
{
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
|
|
unsigned long end_index;
|
|
u64 cur = bio_end_offset(cb->orig_bio);
|
|
u64 isize = i_size_read(inode);
|
|
int ret;
|
|
struct page *page;
|
|
struct extent_map *em;
|
|
struct address_space *mapping = inode->i_mapping;
|
|
struct extent_map_tree *em_tree;
|
|
struct extent_io_tree *tree;
|
|
int sectors_missed = 0;
|
|
|
|
em_tree = &BTRFS_I(inode)->extent_tree;
|
|
tree = &BTRFS_I(inode)->io_tree;
|
|
|
|
if (isize == 0)
|
|
return 0;
|
|
|
|
/*
|
|
* For current subpage support, we only support 64K page size,
|
|
* which means maximum compressed extent size (128K) is just 2x page
|
|
* size.
|
|
* This makes readahead less effective, so here disable readahead for
|
|
* subpage for now, until full compressed write is supported.
|
|
*/
|
|
if (btrfs_sb(inode->i_sb)->sectorsize < PAGE_SIZE)
|
|
return 0;
|
|
|
|
end_index = (i_size_read(inode) - 1) >> PAGE_SHIFT;
|
|
|
|
while (cur < compressed_end) {
|
|
u64 page_end;
|
|
u64 pg_index = cur >> PAGE_SHIFT;
|
|
u32 add_size;
|
|
|
|
if (pg_index > end_index)
|
|
break;
|
|
|
|
page = xa_load(&mapping->i_pages, pg_index);
|
|
if (page && !xa_is_value(page)) {
|
|
sectors_missed += (PAGE_SIZE - offset_in_page(cur)) >>
|
|
fs_info->sectorsize_bits;
|
|
|
|
/* Beyond threshold, no need to continue */
|
|
if (sectors_missed > 4)
|
|
break;
|
|
|
|
/*
|
|
* Jump to next page start as we already have page for
|
|
* current offset.
|
|
*/
|
|
cur = (pg_index << PAGE_SHIFT) + PAGE_SIZE;
|
|
continue;
|
|
}
|
|
|
|
page = __page_cache_alloc(mapping_gfp_constraint(mapping,
|
|
~__GFP_FS));
|
|
if (!page)
|
|
break;
|
|
|
|
if (add_to_page_cache_lru(page, mapping, pg_index, GFP_NOFS)) {
|
|
put_page(page);
|
|
/* There is already a page, skip to page end */
|
|
cur = (pg_index << PAGE_SHIFT) + PAGE_SIZE;
|
|
continue;
|
|
}
|
|
|
|
ret = set_page_extent_mapped(page);
|
|
if (ret < 0) {
|
|
unlock_page(page);
|
|
put_page(page);
|
|
break;
|
|
}
|
|
|
|
page_end = (pg_index << PAGE_SHIFT) + PAGE_SIZE - 1;
|
|
lock_extent(tree, cur, page_end);
|
|
read_lock(&em_tree->lock);
|
|
em = lookup_extent_mapping(em_tree, cur, page_end + 1 - cur);
|
|
read_unlock(&em_tree->lock);
|
|
|
|
/*
|
|
* At this point, we have a locked page in the page cache for
|
|
* these bytes in the file. But, we have to make sure they map
|
|
* to this compressed extent on disk.
|
|
*/
|
|
if (!em || cur < em->start ||
|
|
(cur + fs_info->sectorsize > extent_map_end(em)) ||
|
|
(em->block_start >> 9) != cb->orig_bio->bi_iter.bi_sector) {
|
|
free_extent_map(em);
|
|
unlock_extent(tree, cur, page_end);
|
|
unlock_page(page);
|
|
put_page(page);
|
|
break;
|
|
}
|
|
free_extent_map(em);
|
|
|
|
if (page->index == end_index) {
|
|
size_t zero_offset = offset_in_page(isize);
|
|
|
|
if (zero_offset) {
|
|
int zeros;
|
|
zeros = PAGE_SIZE - zero_offset;
|
|
memzero_page(page, zero_offset, zeros);
|
|
flush_dcache_page(page);
|
|
}
|
|
}
|
|
|
|
add_size = min(em->start + em->len, page_end + 1) - cur;
|
|
ret = bio_add_page(cb->orig_bio, page, add_size, offset_in_page(cur));
|
|
if (ret != add_size) {
|
|
unlock_extent(tree, cur, page_end);
|
|
unlock_page(page);
|
|
put_page(page);
|
|
break;
|
|
}
|
|
/*
|
|
* If it's subpage, we also need to increase its
|
|
* subpage::readers number, as at endio we will decrease
|
|
* subpage::readers and to unlock the page.
|
|
*/
|
|
if (fs_info->sectorsize < PAGE_SIZE)
|
|
btrfs_subpage_start_reader(fs_info, page, cur, add_size);
|
|
put_page(page);
|
|
cur += add_size;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* for a compressed read, the bio we get passed has all the inode pages
|
|
* in it. We don't actually do IO on those pages but allocate new ones
|
|
* to hold the compressed pages on disk.
|
|
*
|
|
* bio->bi_iter.bi_sector points to the compressed extent on disk
|
|
* bio->bi_io_vec points to all of the inode pages
|
|
*
|
|
* After the compressed pages are read, we copy the bytes into the
|
|
* bio we were passed and then call the bio end_io calls
|
|
*/
|
|
blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
|
|
int mirror_num, unsigned long bio_flags)
|
|
{
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
|
|
struct extent_map_tree *em_tree;
|
|
struct compressed_bio *cb;
|
|
unsigned int compressed_len;
|
|
unsigned int nr_pages;
|
|
unsigned int pg_index;
|
|
struct bio *comp_bio = NULL;
|
|
const u64 disk_bytenr = bio->bi_iter.bi_sector << SECTOR_SHIFT;
|
|
u64 cur_disk_byte = disk_bytenr;
|
|
u64 next_stripe_start;
|
|
u64 file_offset;
|
|
u64 em_len;
|
|
u64 em_start;
|
|
struct extent_map *em;
|
|
blk_status_t ret = BLK_STS_RESOURCE;
|
|
int faili = 0;
|
|
u8 *sums;
|
|
|
|
em_tree = &BTRFS_I(inode)->extent_tree;
|
|
|
|
file_offset = bio_first_bvec_all(bio)->bv_offset +
|
|
page_offset(bio_first_page_all(bio));
|
|
|
|
/* we need the actual starting offset of this extent in the file */
|
|
read_lock(&em_tree->lock);
|
|
em = lookup_extent_mapping(em_tree, file_offset, fs_info->sectorsize);
|
|
read_unlock(&em_tree->lock);
|
|
if (!em)
|
|
return BLK_STS_IOERR;
|
|
|
|
ASSERT(em->compress_type != BTRFS_COMPRESS_NONE);
|
|
compressed_len = em->block_len;
|
|
cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);
|
|
if (!cb)
|
|
goto out;
|
|
|
|
refcount_set(&cb->pending_sectors, compressed_len >> fs_info->sectorsize_bits);
|
|
cb->errors = 0;
|
|
cb->inode = inode;
|
|
cb->mirror_num = mirror_num;
|
|
sums = cb->sums;
|
|
|
|
cb->start = em->orig_start;
|
|
em_len = em->len;
|
|
em_start = em->start;
|
|
|
|
free_extent_map(em);
|
|
em = NULL;
|
|
|
|
cb->len = bio->bi_iter.bi_size;
|
|
cb->compressed_len = compressed_len;
|
|
cb->compress_type = extent_compress_type(bio_flags);
|
|
cb->orig_bio = bio;
|
|
|
|
nr_pages = DIV_ROUND_UP(compressed_len, PAGE_SIZE);
|
|
cb->compressed_pages = kcalloc(nr_pages, sizeof(struct page *),
|
|
GFP_NOFS);
|
|
if (!cb->compressed_pages)
|
|
goto fail1;
|
|
|
|
for (pg_index = 0; pg_index < nr_pages; pg_index++) {
|
|
cb->compressed_pages[pg_index] = alloc_page(GFP_NOFS);
|
|
if (!cb->compressed_pages[pg_index]) {
|
|
faili = pg_index - 1;
|
|
ret = BLK_STS_RESOURCE;
|
|
goto fail2;
|
|
}
|
|
}
|
|
faili = nr_pages - 1;
|
|
cb->nr_pages = nr_pages;
|
|
|
|
add_ra_bio_pages(inode, em_start + em_len, cb);
|
|
|
|
/* include any pages we added in add_ra-bio_pages */
|
|
cb->len = bio->bi_iter.bi_size;
|
|
|
|
while (cur_disk_byte < disk_bytenr + compressed_len) {
|
|
u64 offset = cur_disk_byte - disk_bytenr;
|
|
unsigned int index = offset >> PAGE_SHIFT;
|
|
unsigned int real_size;
|
|
unsigned int added;
|
|
struct page *page = cb->compressed_pages[index];
|
|
bool submit = false;
|
|
|
|
/* Allocate new bio if submitted or not yet allocated */
|
|
if (!comp_bio) {
|
|
comp_bio = alloc_compressed_bio(cb, cur_disk_byte,
|
|
REQ_OP_READ, end_compressed_bio_read,
|
|
&next_stripe_start);
|
|
if (IS_ERR(comp_bio)) {
|
|
ret = errno_to_blk_status(PTR_ERR(comp_bio));
|
|
comp_bio = NULL;
|
|
goto finish_cb;
|
|
}
|
|
}
|
|
/*
|
|
* We should never reach next_stripe_start start as we will
|
|
* submit comp_bio when reach the boundary immediately.
|
|
*/
|
|
ASSERT(cur_disk_byte != next_stripe_start);
|
|
/*
|
|
* We have various limit on the real read size:
|
|
* - stripe boundary
|
|
* - page boundary
|
|
* - compressed length boundary
|
|
*/
|
|
real_size = min_t(u64, U32_MAX, next_stripe_start - cur_disk_byte);
|
|
real_size = min_t(u64, real_size, PAGE_SIZE - offset_in_page(offset));
|
|
real_size = min_t(u64, real_size, compressed_len - offset);
|
|
ASSERT(IS_ALIGNED(real_size, fs_info->sectorsize));
|
|
|
|
added = bio_add_page(comp_bio, page, real_size, offset_in_page(offset));
|
|
/*
|
|
* Maximum compressed extent is smaller than bio size limit,
|
|
* thus bio_add_page() should always success.
|
|
*/
|
|
ASSERT(added == real_size);
|
|
cur_disk_byte += added;
|
|
|
|
/* Reached stripe boundary, need to submit */
|
|
if (cur_disk_byte == next_stripe_start)
|
|
submit = true;
|
|
|
|
/* Has finished the range, need to submit */
|
|
if (cur_disk_byte == disk_bytenr + compressed_len)
|
|
submit = true;
|
|
|
|
if (submit) {
|
|
unsigned int nr_sectors;
|
|
|
|
ret = btrfs_lookup_bio_sums(inode, comp_bio, sums);
|
|
if (ret)
|
|
goto finish_cb;
|
|
|
|
nr_sectors = DIV_ROUND_UP(comp_bio->bi_iter.bi_size,
|
|
fs_info->sectorsize);
|
|
sums += fs_info->csum_size * nr_sectors;
|
|
|
|
ret = submit_compressed_bio(fs_info, cb, comp_bio, mirror_num);
|
|
if (ret)
|
|
goto finish_cb;
|
|
comp_bio = NULL;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
fail2:
|
|
while (faili >= 0) {
|
|
__free_page(cb->compressed_pages[faili]);
|
|
faili--;
|
|
}
|
|
|
|
kfree(cb->compressed_pages);
|
|
fail1:
|
|
kfree(cb);
|
|
out:
|
|
free_extent_map(em);
|
|
return ret;
|
|
finish_cb:
|
|
if (comp_bio) {
|
|
comp_bio->bi_status = ret;
|
|
bio_endio(comp_bio);
|
|
}
|
|
/* All bytes of @cb is submitted, endio will free @cb */
|
|
if (cur_disk_byte == disk_bytenr + compressed_len)
|
|
return ret;
|
|
|
|
wait_var_event(cb, refcount_read(&cb->pending_sectors) ==
|
|
(disk_bytenr + compressed_len - cur_disk_byte) >>
|
|
fs_info->sectorsize_bits);
|
|
/*
|
|
* Even with previous bio ended, we should still have io not yet
|
|
* submitted, thus need to finish @cb manually.
|
|
*/
|
|
ASSERT(refcount_read(&cb->pending_sectors));
|
|
/* Now we are the only one referring @cb, can finish it safely. */
|
|
finish_compressed_bio_read(cb, NULL);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Heuristic uses systematic sampling to collect data from the input data
|
|
* range, the logic can be tuned by the following constants:
|
|
*
|
|
* @SAMPLING_READ_SIZE - how many bytes will be copied from for each sample
|
|
* @SAMPLING_INTERVAL - range from which the sampled data can be collected
|
|
*/
|
|
#define SAMPLING_READ_SIZE (16)
|
|
#define SAMPLING_INTERVAL (256)
|
|
|
|
/*
|
|
* For statistical analysis of the input data we consider bytes that form a
|
|
* Galois Field of 256 objects. Each object has an attribute count, ie. how
|
|
* many times the object appeared in the sample.
|
|
*/
|
|
#define BUCKET_SIZE (256)
|
|
|
|
/*
|
|
* The size of the sample is based on a statistical sampling rule of thumb.
|
|
* The common way is to perform sampling tests as long as the number of
|
|
* elements in each cell is at least 5.
|
|
*
|
|
* Instead of 5, we choose 32 to obtain more accurate results.
|
|
* If the data contain the maximum number of symbols, which is 256, we obtain a
|
|
* sample size bound by 8192.
|
|
*
|
|
* For a sample of at most 8KB of data per data range: 16 consecutive bytes
|
|
* from up to 512 locations.
|
|
*/
|
|
#define MAX_SAMPLE_SIZE (BTRFS_MAX_UNCOMPRESSED * \
|
|
SAMPLING_READ_SIZE / SAMPLING_INTERVAL)
|
|
|
|
struct bucket_item {
|
|
u32 count;
|
|
};
|
|
|
|
struct heuristic_ws {
|
|
/* Partial copy of input data */
|
|
u8 *sample;
|
|
u32 sample_size;
|
|
/* Buckets store counters for each byte value */
|
|
struct bucket_item *bucket;
|
|
/* Sorting buffer */
|
|
struct bucket_item *bucket_b;
|
|
struct list_head list;
|
|
};
|
|
|
|
static struct workspace_manager heuristic_wsm;
|
|
|
|
static void free_heuristic_ws(struct list_head *ws)
|
|
{
|
|
struct heuristic_ws *workspace;
|
|
|
|
workspace = list_entry(ws, struct heuristic_ws, list);
|
|
|
|
kvfree(workspace->sample);
|
|
kfree(workspace->bucket);
|
|
kfree(workspace->bucket_b);
|
|
kfree(workspace);
|
|
}
|
|
|
|
static struct list_head *alloc_heuristic_ws(unsigned int level)
|
|
{
|
|
struct heuristic_ws *ws;
|
|
|
|
ws = kzalloc(sizeof(*ws), GFP_KERNEL);
|
|
if (!ws)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
ws->sample = kvmalloc(MAX_SAMPLE_SIZE, GFP_KERNEL);
|
|
if (!ws->sample)
|
|
goto fail;
|
|
|
|
ws->bucket = kcalloc(BUCKET_SIZE, sizeof(*ws->bucket), GFP_KERNEL);
|
|
if (!ws->bucket)
|
|
goto fail;
|
|
|
|
ws->bucket_b = kcalloc(BUCKET_SIZE, sizeof(*ws->bucket_b), GFP_KERNEL);
|
|
if (!ws->bucket_b)
|
|
goto fail;
|
|
|
|
INIT_LIST_HEAD(&ws->list);
|
|
return &ws->list;
|
|
fail:
|
|
free_heuristic_ws(&ws->list);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
const struct btrfs_compress_op btrfs_heuristic_compress = {
|
|
.workspace_manager = &heuristic_wsm,
|
|
};
|
|
|
|
static const struct btrfs_compress_op * const btrfs_compress_op[] = {
|
|
/* The heuristic is represented as compression type 0 */
|
|
&btrfs_heuristic_compress,
|
|
&btrfs_zlib_compress,
|
|
&btrfs_lzo_compress,
|
|
&btrfs_zstd_compress,
|
|
};
|
|
|
|
static struct list_head *alloc_workspace(int type, unsigned int level)
|
|
{
|
|
switch (type) {
|
|
case BTRFS_COMPRESS_NONE: return alloc_heuristic_ws(level);
|
|
case BTRFS_COMPRESS_ZLIB: return zlib_alloc_workspace(level);
|
|
case BTRFS_COMPRESS_LZO: return lzo_alloc_workspace(level);
|
|
case BTRFS_COMPRESS_ZSTD: return zstd_alloc_workspace(level);
|
|
default:
|
|
/*
|
|
* This can't happen, the type is validated several times
|
|
* before we get here.
|
|
*/
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
static void free_workspace(int type, struct list_head *ws)
|
|
{
|
|
switch (type) {
|
|
case BTRFS_COMPRESS_NONE: return free_heuristic_ws(ws);
|
|
case BTRFS_COMPRESS_ZLIB: return zlib_free_workspace(ws);
|
|
case BTRFS_COMPRESS_LZO: return lzo_free_workspace(ws);
|
|
case BTRFS_COMPRESS_ZSTD: return zstd_free_workspace(ws);
|
|
default:
|
|
/*
|
|
* This can't happen, the type is validated several times
|
|
* before we get here.
|
|
*/
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
static void btrfs_init_workspace_manager(int type)
|
|
{
|
|
struct workspace_manager *wsm;
|
|
struct list_head *workspace;
|
|
|
|
wsm = btrfs_compress_op[type]->workspace_manager;
|
|
INIT_LIST_HEAD(&wsm->idle_ws);
|
|
spin_lock_init(&wsm->ws_lock);
|
|
atomic_set(&wsm->total_ws, 0);
|
|
init_waitqueue_head(&wsm->ws_wait);
|
|
|
|
/*
|
|
* Preallocate one workspace for each compression type so we can
|
|
* guarantee forward progress in the worst case
|
|
*/
|
|
workspace = alloc_workspace(type, 0);
|
|
if (IS_ERR(workspace)) {
|
|
pr_warn(
|
|
"BTRFS: cannot preallocate compression workspace, will try later\n");
|
|
} else {
|
|
atomic_set(&wsm->total_ws, 1);
|
|
wsm->free_ws = 1;
|
|
list_add(workspace, &wsm->idle_ws);
|
|
}
|
|
}
|
|
|
|
static void btrfs_cleanup_workspace_manager(int type)
|
|
{
|
|
struct workspace_manager *wsman;
|
|
struct list_head *ws;
|
|
|
|
wsman = btrfs_compress_op[type]->workspace_manager;
|
|
while (!list_empty(&wsman->idle_ws)) {
|
|
ws = wsman->idle_ws.next;
|
|
list_del(ws);
|
|
free_workspace(type, ws);
|
|
atomic_dec(&wsman->total_ws);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This finds an available workspace or allocates a new one.
|
|
* If it's not possible to allocate a new one, waits until there's one.
|
|
* Preallocation makes a forward progress guarantees and we do not return
|
|
* errors.
|
|
*/
|
|
struct list_head *btrfs_get_workspace(int type, unsigned int level)
|
|
{
|
|
struct workspace_manager *wsm;
|
|
struct list_head *workspace;
|
|
int cpus = num_online_cpus();
|
|
unsigned nofs_flag;
|
|
struct list_head *idle_ws;
|
|
spinlock_t *ws_lock;
|
|
atomic_t *total_ws;
|
|
wait_queue_head_t *ws_wait;
|
|
int *free_ws;
|
|
|
|
wsm = btrfs_compress_op[type]->workspace_manager;
|
|
idle_ws = &wsm->idle_ws;
|
|
ws_lock = &wsm->ws_lock;
|
|
total_ws = &wsm->total_ws;
|
|
ws_wait = &wsm->ws_wait;
|
|
free_ws = &wsm->free_ws;
|
|
|
|
again:
|
|
spin_lock(ws_lock);
|
|
if (!list_empty(idle_ws)) {
|
|
workspace = idle_ws->next;
|
|
list_del(workspace);
|
|
(*free_ws)--;
|
|
spin_unlock(ws_lock);
|
|
return workspace;
|
|
|
|
}
|
|
if (atomic_read(total_ws) > cpus) {
|
|
DEFINE_WAIT(wait);
|
|
|
|
spin_unlock(ws_lock);
|
|
prepare_to_wait(ws_wait, &wait, TASK_UNINTERRUPTIBLE);
|
|
if (atomic_read(total_ws) > cpus && !*free_ws)
|
|
schedule();
|
|
finish_wait(ws_wait, &wait);
|
|
goto again;
|
|
}
|
|
atomic_inc(total_ws);
|
|
spin_unlock(ws_lock);
|
|
|
|
/*
|
|
* Allocation helpers call vmalloc that can't use GFP_NOFS, so we have
|
|
* to turn it off here because we might get called from the restricted
|
|
* context of btrfs_compress_bio/btrfs_compress_pages
|
|
*/
|
|
nofs_flag = memalloc_nofs_save();
|
|
workspace = alloc_workspace(type, level);
|
|
memalloc_nofs_restore(nofs_flag);
|
|
|
|
if (IS_ERR(workspace)) {
|
|
atomic_dec(total_ws);
|
|
wake_up(ws_wait);
|
|
|
|
/*
|
|
* Do not return the error but go back to waiting. There's a
|
|
* workspace preallocated for each type and the compression
|
|
* time is bounded so we get to a workspace eventually. This
|
|
* makes our caller's life easier.
|
|
*
|
|
* To prevent silent and low-probability deadlocks (when the
|
|
* initial preallocation fails), check if there are any
|
|
* workspaces at all.
|
|
*/
|
|
if (atomic_read(total_ws) == 0) {
|
|
static DEFINE_RATELIMIT_STATE(_rs,
|
|
/* once per minute */ 60 * HZ,
|
|
/* no burst */ 1);
|
|
|
|
if (__ratelimit(&_rs)) {
|
|
pr_warn("BTRFS: no compression workspaces, low memory, retrying\n");
|
|
}
|
|
}
|
|
goto again;
|
|
}
|
|
return workspace;
|
|
}
|
|
|
|
static struct list_head *get_workspace(int type, int level)
|
|
{
|
|
switch (type) {
|
|
case BTRFS_COMPRESS_NONE: return btrfs_get_workspace(type, level);
|
|
case BTRFS_COMPRESS_ZLIB: return zlib_get_workspace(level);
|
|
case BTRFS_COMPRESS_LZO: return btrfs_get_workspace(type, level);
|
|
case BTRFS_COMPRESS_ZSTD: return zstd_get_workspace(level);
|
|
default:
|
|
/*
|
|
* This can't happen, the type is validated several times
|
|
* before we get here.
|
|
*/
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* put a workspace struct back on the list or free it if we have enough
|
|
* idle ones sitting around
|
|
*/
|
|
void btrfs_put_workspace(int type, struct list_head *ws)
|
|
{
|
|
struct workspace_manager *wsm;
|
|
struct list_head *idle_ws;
|
|
spinlock_t *ws_lock;
|
|
atomic_t *total_ws;
|
|
wait_queue_head_t *ws_wait;
|
|
int *free_ws;
|
|
|
|
wsm = btrfs_compress_op[type]->workspace_manager;
|
|
idle_ws = &wsm->idle_ws;
|
|
ws_lock = &wsm->ws_lock;
|
|
total_ws = &wsm->total_ws;
|
|
ws_wait = &wsm->ws_wait;
|
|
free_ws = &wsm->free_ws;
|
|
|
|
spin_lock(ws_lock);
|
|
if (*free_ws <= num_online_cpus()) {
|
|
list_add(ws, idle_ws);
|
|
(*free_ws)++;
|
|
spin_unlock(ws_lock);
|
|
goto wake;
|
|
}
|
|
spin_unlock(ws_lock);
|
|
|
|
free_workspace(type, ws);
|
|
atomic_dec(total_ws);
|
|
wake:
|
|
cond_wake_up(ws_wait);
|
|
}
|
|
|
|
static void put_workspace(int type, struct list_head *ws)
|
|
{
|
|
switch (type) {
|
|
case BTRFS_COMPRESS_NONE: return btrfs_put_workspace(type, ws);
|
|
case BTRFS_COMPRESS_ZLIB: return btrfs_put_workspace(type, ws);
|
|
case BTRFS_COMPRESS_LZO: return btrfs_put_workspace(type, ws);
|
|
case BTRFS_COMPRESS_ZSTD: return zstd_put_workspace(ws);
|
|
default:
|
|
/*
|
|
* This can't happen, the type is validated several times
|
|
* before we get here.
|
|
*/
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Adjust @level according to the limits of the compression algorithm or
|
|
* fallback to default
|
|
*/
|
|
static unsigned int btrfs_compress_set_level(int type, unsigned level)
|
|
{
|
|
const struct btrfs_compress_op *ops = btrfs_compress_op[type];
|
|
|
|
if (level == 0)
|
|
level = ops->default_level;
|
|
else
|
|
level = min(level, ops->max_level);
|
|
|
|
return level;
|
|
}
|
|
|
|
/*
|
|
* Given an address space and start and length, compress the bytes into @pages
|
|
* that are allocated on demand.
|
|
*
|
|
* @type_level is encoded algorithm and level, where level 0 means whatever
|
|
* default the algorithm chooses and is opaque here;
|
|
* - 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
|
|
* and returns number of actually allocated pages
|
|
*
|
|
* @total_in is used to return the number of bytes actually read. It
|
|
* may be smaller than the input length if we had to exit early because we
|
|
* ran out of room in the pages array or because we cross the
|
|
* max_out threshold.
|
|
*
|
|
* @total_out is an in/out parameter, must be set to the input length and will
|
|
* be also used to return the total number of compressed bytes
|
|
*/
|
|
int btrfs_compress_pages(unsigned int type_level, struct address_space *mapping,
|
|
u64 start, struct page **pages,
|
|
unsigned long *out_pages,
|
|
unsigned long *total_in,
|
|
unsigned long *total_out)
|
|
{
|
|
int type = btrfs_compress_type(type_level);
|
|
int level = btrfs_compress_level(type_level);
|
|
struct list_head *workspace;
|
|
int ret;
|
|
|
|
level = btrfs_compress_set_level(type, level);
|
|
workspace = get_workspace(type, level);
|
|
ret = compression_compress_pages(type, workspace, mapping, start, pages,
|
|
out_pages, total_in, total_out);
|
|
put_workspace(type, workspace);
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_decompress_bio(struct compressed_bio *cb)
|
|
{
|
|
struct list_head *workspace;
|
|
int ret;
|
|
int type = cb->compress_type;
|
|
|
|
workspace = get_workspace(type, 0);
|
|
ret = compression_decompress_bio(type, workspace, cb);
|
|
put_workspace(type, workspace);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* a less complex decompression routine. Our compressed data fits in a
|
|
* single page, and we want to read a single page out of it.
|
|
* start_byte tells us the offset into the compressed data we're interested in
|
|
*/
|
|
int btrfs_decompress(int type, unsigned char *data_in, struct page *dest_page,
|
|
unsigned long start_byte, size_t srclen, size_t destlen)
|
|
{
|
|
struct list_head *workspace;
|
|
int ret;
|
|
|
|
workspace = get_workspace(type, 0);
|
|
ret = compression_decompress(type, workspace, data_in, dest_page,
|
|
start_byte, srclen, destlen);
|
|
put_workspace(type, workspace);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void __init btrfs_init_compress(void)
|
|
{
|
|
btrfs_init_workspace_manager(BTRFS_COMPRESS_NONE);
|
|
btrfs_init_workspace_manager(BTRFS_COMPRESS_ZLIB);
|
|
btrfs_init_workspace_manager(BTRFS_COMPRESS_LZO);
|
|
zstd_init_workspace_manager();
|
|
}
|
|
|
|
void __cold btrfs_exit_compress(void)
|
|
{
|
|
btrfs_cleanup_workspace_manager(BTRFS_COMPRESS_NONE);
|
|
btrfs_cleanup_workspace_manager(BTRFS_COMPRESS_ZLIB);
|
|
btrfs_cleanup_workspace_manager(BTRFS_COMPRESS_LZO);
|
|
zstd_cleanup_workspace_manager();
|
|
}
|
|
|
|
/*
|
|
* Copy decompressed data from working buffer to pages.
|
|
*
|
|
* @buf: The decompressed data buffer
|
|
* @buf_len: The decompressed data length
|
|
* @decompressed: Number of bytes that are already decompressed inside the
|
|
* compressed extent
|
|
* @cb: The compressed extent descriptor
|
|
* @orig_bio: The original bio that the caller wants to read for
|
|
*
|
|
* An easier to understand graph is like below:
|
|
*
|
|
* |<- orig_bio ->| |<- orig_bio->|
|
|
* |<------- full decompressed extent ----->|
|
|
* |<----------- @cb range ---->|
|
|
* | |<-- @buf_len -->|
|
|
* |<--- @decompressed --->|
|
|
*
|
|
* Note that, @cb can be a subpage of the full decompressed extent, but
|
|
* @cb->start always has the same as the orig_file_offset value of the full
|
|
* decompressed extent.
|
|
*
|
|
* When reading compressed extent, we have to read the full compressed extent,
|
|
* while @orig_bio may only want part of the range.
|
|
* Thus this function will ensure only data covered by @orig_bio will be copied
|
|
* to.
|
|
*
|
|
* Return 0 if we have copied all needed contents for @orig_bio.
|
|
* Return >0 if we need continue decompress.
|
|
*/
|
|
int btrfs_decompress_buf2page(const char *buf, u32 buf_len,
|
|
struct compressed_bio *cb, u32 decompressed)
|
|
{
|
|
struct bio *orig_bio = cb->orig_bio;
|
|
/* Offset inside the full decompressed extent */
|
|
u32 cur_offset;
|
|
|
|
cur_offset = decompressed;
|
|
/* The main loop to do the copy */
|
|
while (cur_offset < decompressed + buf_len) {
|
|
struct bio_vec bvec;
|
|
size_t copy_len;
|
|
u32 copy_start;
|
|
/* Offset inside the full decompressed extent */
|
|
u32 bvec_offset;
|
|
|
|
bvec = bio_iter_iovec(orig_bio, orig_bio->bi_iter);
|
|
/*
|
|
* cb->start may underflow, but subtracting that value can still
|
|
* give us correct offset inside the full decompressed extent.
|
|
*/
|
|
bvec_offset = page_offset(bvec.bv_page) + bvec.bv_offset - cb->start;
|
|
|
|
/* Haven't reached the bvec range, exit */
|
|
if (decompressed + buf_len <= bvec_offset)
|
|
return 1;
|
|
|
|
copy_start = max(cur_offset, bvec_offset);
|
|
copy_len = min(bvec_offset + bvec.bv_len,
|
|
decompressed + buf_len) - copy_start;
|
|
ASSERT(copy_len);
|
|
|
|
/*
|
|
* Extra range check to ensure we didn't go beyond
|
|
* @buf + @buf_len.
|
|
*/
|
|
ASSERT(copy_start - decompressed < buf_len);
|
|
memcpy_to_page(bvec.bv_page, bvec.bv_offset,
|
|
buf + copy_start - decompressed, copy_len);
|
|
flush_dcache_page(bvec.bv_page);
|
|
cur_offset += copy_len;
|
|
|
|
bio_advance(orig_bio, copy_len);
|
|
/* Finished the bio */
|
|
if (!orig_bio->bi_iter.bi_size)
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Shannon Entropy calculation
|
|
*
|
|
* Pure byte distribution analysis fails to determine compressibility of data.
|
|
* Try calculating entropy to estimate the average minimum number of bits
|
|
* needed to encode the sampled data.
|
|
*
|
|
* For convenience, return the percentage of needed bits, instead of amount of
|
|
* bits directly.
|
|
*
|
|
* @ENTROPY_LVL_ACEPTABLE - below that threshold, sample has low byte entropy
|
|
* and can be compressible with high probability
|
|
*
|
|
* @ENTROPY_LVL_HIGH - data are not compressible with high probability
|
|
*
|
|
* Use of ilog2() decreases precision, we lower the LVL to 5 to compensate.
|
|
*/
|
|
#define ENTROPY_LVL_ACEPTABLE (65)
|
|
#define ENTROPY_LVL_HIGH (80)
|
|
|
|
/*
|
|
* For increasead precision in shannon_entropy calculation,
|
|
* let's do pow(n, M) to save more digits after comma:
|
|
*
|
|
* - maximum int bit length is 64
|
|
* - ilog2(MAX_SAMPLE_SIZE) -> 13
|
|
* - 13 * 4 = 52 < 64 -> M = 4
|
|
*
|
|
* So use pow(n, 4).
|
|
*/
|
|
static inline u32 ilog2_w(u64 n)
|
|
{
|
|
return ilog2(n * n * n * n);
|
|
}
|
|
|
|
static u32 shannon_entropy(struct heuristic_ws *ws)
|
|
{
|
|
const u32 entropy_max = 8 * ilog2_w(2);
|
|
u32 entropy_sum = 0;
|
|
u32 p, p_base, sz_base;
|
|
u32 i;
|
|
|
|
sz_base = ilog2_w(ws->sample_size);
|
|
for (i = 0; i < BUCKET_SIZE && ws->bucket[i].count > 0; i++) {
|
|
p = ws->bucket[i].count;
|
|
p_base = ilog2_w(p);
|
|
entropy_sum += p * (sz_base - p_base);
|
|
}
|
|
|
|
entropy_sum /= ws->sample_size;
|
|
return entropy_sum * 100 / entropy_max;
|
|
}
|
|
|
|
#define RADIX_BASE 4U
|
|
#define COUNTERS_SIZE (1U << RADIX_BASE)
|
|
|
|
static u8 get4bits(u64 num, int shift) {
|
|
u8 low4bits;
|
|
|
|
num >>= shift;
|
|
/* Reverse order */
|
|
low4bits = (COUNTERS_SIZE - 1) - (num % COUNTERS_SIZE);
|
|
return low4bits;
|
|
}
|
|
|
|
/*
|
|
* Use 4 bits as radix base
|
|
* Use 16 u32 counters for calculating new position in buf array
|
|
*
|
|
* @array - array that will be sorted
|
|
* @array_buf - buffer array to store sorting results
|
|
* must be equal in size to @array
|
|
* @num - array size
|
|
*/
|
|
static void radix_sort(struct bucket_item *array, struct bucket_item *array_buf,
|
|
int num)
|
|
{
|
|
u64 max_num;
|
|
u64 buf_num;
|
|
u32 counters[COUNTERS_SIZE];
|
|
u32 new_addr;
|
|
u32 addr;
|
|
int bitlen;
|
|
int shift;
|
|
int i;
|
|
|
|
/*
|
|
* Try avoid useless loop iterations for small numbers stored in big
|
|
* counters. Example: 48 33 4 ... in 64bit array
|
|
*/
|
|
max_num = array[0].count;
|
|
for (i = 1; i < num; i++) {
|
|
buf_num = array[i].count;
|
|
if (buf_num > max_num)
|
|
max_num = buf_num;
|
|
}
|
|
|
|
buf_num = ilog2(max_num);
|
|
bitlen = ALIGN(buf_num, RADIX_BASE * 2);
|
|
|
|
shift = 0;
|
|
while (shift < bitlen) {
|
|
memset(counters, 0, sizeof(counters));
|
|
|
|
for (i = 0; i < num; i++) {
|
|
buf_num = array[i].count;
|
|
addr = get4bits(buf_num, shift);
|
|
counters[addr]++;
|
|
}
|
|
|
|
for (i = 1; i < COUNTERS_SIZE; i++)
|
|
counters[i] += counters[i - 1];
|
|
|
|
for (i = num - 1; i >= 0; i--) {
|
|
buf_num = array[i].count;
|
|
addr = get4bits(buf_num, shift);
|
|
counters[addr]--;
|
|
new_addr = counters[addr];
|
|
array_buf[new_addr] = array[i];
|
|
}
|
|
|
|
shift += RADIX_BASE;
|
|
|
|
/*
|
|
* Normal radix expects to move data from a temporary array, to
|
|
* the main one. But that requires some CPU time. Avoid that
|
|
* by doing another sort iteration to original array instead of
|
|
* memcpy()
|
|
*/
|
|
memset(counters, 0, sizeof(counters));
|
|
|
|
for (i = 0; i < num; i ++) {
|
|
buf_num = array_buf[i].count;
|
|
addr = get4bits(buf_num, shift);
|
|
counters[addr]++;
|
|
}
|
|
|
|
for (i = 1; i < COUNTERS_SIZE; i++)
|
|
counters[i] += counters[i - 1];
|
|
|
|
for (i = num - 1; i >= 0; i--) {
|
|
buf_num = array_buf[i].count;
|
|
addr = get4bits(buf_num, shift);
|
|
counters[addr]--;
|
|
new_addr = counters[addr];
|
|
array[new_addr] = array_buf[i];
|
|
}
|
|
|
|
shift += RADIX_BASE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Size of the core byte set - how many bytes cover 90% of the sample
|
|
*
|
|
* There are several types of structured binary data that use nearly all byte
|
|
* values. The distribution can be uniform and counts in all buckets will be
|
|
* nearly the same (eg. encrypted data). Unlikely to be compressible.
|
|
*
|
|
* Other possibility is normal (Gaussian) distribution, where the data could
|
|
* be potentially compressible, but we have to take a few more steps to decide
|
|
* how much.
|
|
*
|
|
* @BYTE_CORE_SET_LOW - main part of byte values repeated frequently,
|
|
* compression algo can easy fix that
|
|
* @BYTE_CORE_SET_HIGH - data have uniform distribution and with high
|
|
* probability is not compressible
|
|
*/
|
|
#define BYTE_CORE_SET_LOW (64)
|
|
#define BYTE_CORE_SET_HIGH (200)
|
|
|
|
static int byte_core_set_size(struct heuristic_ws *ws)
|
|
{
|
|
u32 i;
|
|
u32 coreset_sum = 0;
|
|
const u32 core_set_threshold = ws->sample_size * 90 / 100;
|
|
struct bucket_item *bucket = ws->bucket;
|
|
|
|
/* Sort in reverse order */
|
|
radix_sort(ws->bucket, ws->bucket_b, BUCKET_SIZE);
|
|
|
|
for (i = 0; i < BYTE_CORE_SET_LOW; i++)
|
|
coreset_sum += bucket[i].count;
|
|
|
|
if (coreset_sum > core_set_threshold)
|
|
return i;
|
|
|
|
for (; i < BYTE_CORE_SET_HIGH && bucket[i].count > 0; i++) {
|
|
coreset_sum += bucket[i].count;
|
|
if (coreset_sum > core_set_threshold)
|
|
break;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
* Count byte values in buckets.
|
|
* This heuristic can detect textual data (configs, xml, json, html, etc).
|
|
* Because in most text-like data byte set is restricted to limited number of
|
|
* possible characters, and that restriction in most cases makes data easy to
|
|
* compress.
|
|
*
|
|
* @BYTE_SET_THRESHOLD - consider all data within this byte set size:
|
|
* less - compressible
|
|
* more - need additional analysis
|
|
*/
|
|
#define BYTE_SET_THRESHOLD (64)
|
|
|
|
static u32 byte_set_size(const struct heuristic_ws *ws)
|
|
{
|
|
u32 i;
|
|
u32 byte_set_size = 0;
|
|
|
|
for (i = 0; i < BYTE_SET_THRESHOLD; i++) {
|
|
if (ws->bucket[i].count > 0)
|
|
byte_set_size++;
|
|
}
|
|
|
|
/*
|
|
* Continue collecting count of byte values in buckets. If the byte
|
|
* set size is bigger then the threshold, it's pointless to continue,
|
|
* the detection technique would fail for this type of data.
|
|
*/
|
|
for (; i < BUCKET_SIZE; i++) {
|
|
if (ws->bucket[i].count > 0) {
|
|
byte_set_size++;
|
|
if (byte_set_size > BYTE_SET_THRESHOLD)
|
|
return byte_set_size;
|
|
}
|
|
}
|
|
|
|
return byte_set_size;
|
|
}
|
|
|
|
static bool sample_repeated_patterns(struct heuristic_ws *ws)
|
|
{
|
|
const u32 half_of_sample = ws->sample_size / 2;
|
|
const u8 *data = ws->sample;
|
|
|
|
return memcmp(&data[0], &data[half_of_sample], half_of_sample) == 0;
|
|
}
|
|
|
|
static void heuristic_collect_sample(struct inode *inode, u64 start, u64 end,
|
|
struct heuristic_ws *ws)
|
|
{
|
|
struct page *page;
|
|
u64 index, index_end;
|
|
u32 i, curr_sample_pos;
|
|
u8 *in_data;
|
|
|
|
/*
|
|
* Compression handles the input data by chunks of 128KiB
|
|
* (defined by BTRFS_MAX_UNCOMPRESSED)
|
|
*
|
|
* We do the same for the heuristic and loop over the whole range.
|
|
*
|
|
* MAX_SAMPLE_SIZE - calculated under assumption that heuristic will
|
|
* process no more than BTRFS_MAX_UNCOMPRESSED at a time.
|
|
*/
|
|
if (end - start > BTRFS_MAX_UNCOMPRESSED)
|
|
end = start + BTRFS_MAX_UNCOMPRESSED;
|
|
|
|
index = start >> PAGE_SHIFT;
|
|
index_end = end >> PAGE_SHIFT;
|
|
|
|
/* Don't miss unaligned end */
|
|
if (!IS_ALIGNED(end, PAGE_SIZE))
|
|
index_end++;
|
|
|
|
curr_sample_pos = 0;
|
|
while (index < index_end) {
|
|
page = find_get_page(inode->i_mapping, index);
|
|
in_data = kmap_local_page(page);
|
|
/* Handle case where the start is not aligned to PAGE_SIZE */
|
|
i = start % PAGE_SIZE;
|
|
while (i < PAGE_SIZE - SAMPLING_READ_SIZE) {
|
|
/* Don't sample any garbage from the last page */
|
|
if (start > end - SAMPLING_READ_SIZE)
|
|
break;
|
|
memcpy(&ws->sample[curr_sample_pos], &in_data[i],
|
|
SAMPLING_READ_SIZE);
|
|
i += SAMPLING_INTERVAL;
|
|
start += SAMPLING_INTERVAL;
|
|
curr_sample_pos += SAMPLING_READ_SIZE;
|
|
}
|
|
kunmap_local(in_data);
|
|
put_page(page);
|
|
|
|
index++;
|
|
}
|
|
|
|
ws->sample_size = curr_sample_pos;
|
|
}
|
|
|
|
/*
|
|
* Compression heuristic.
|
|
*
|
|
* For now is's a naive and optimistic 'return true', we'll extend the logic to
|
|
* quickly (compared to direct compression) detect data characteristics
|
|
* (compressible/uncompressible) to avoid wasting CPU time on uncompressible
|
|
* data.
|
|
*
|
|
* The following types of analysis can be performed:
|
|
* - detect mostly zero data
|
|
* - detect data with low "byte set" size (text, etc)
|
|
* - detect data with low/high "core byte" set
|
|
*
|
|
* Return non-zero if the compression should be done, 0 otherwise.
|
|
*/
|
|
int btrfs_compress_heuristic(struct inode *inode, u64 start, u64 end)
|
|
{
|
|
struct list_head *ws_list = get_workspace(0, 0);
|
|
struct heuristic_ws *ws;
|
|
u32 i;
|
|
u8 byte;
|
|
int ret = 0;
|
|
|
|
ws = list_entry(ws_list, struct heuristic_ws, list);
|
|
|
|
heuristic_collect_sample(inode, start, end, ws);
|
|
|
|
if (sample_repeated_patterns(ws)) {
|
|
ret = 1;
|
|
goto out;
|
|
}
|
|
|
|
memset(ws->bucket, 0, sizeof(*ws->bucket)*BUCKET_SIZE);
|
|
|
|
for (i = 0; i < ws->sample_size; i++) {
|
|
byte = ws->sample[i];
|
|
ws->bucket[byte].count++;
|
|
}
|
|
|
|
i = byte_set_size(ws);
|
|
if (i < BYTE_SET_THRESHOLD) {
|
|
ret = 2;
|
|
goto out;
|
|
}
|
|
|
|
i = byte_core_set_size(ws);
|
|
if (i <= BYTE_CORE_SET_LOW) {
|
|
ret = 3;
|
|
goto out;
|
|
}
|
|
|
|
if (i >= BYTE_CORE_SET_HIGH) {
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
|
|
i = shannon_entropy(ws);
|
|
if (i <= ENTROPY_LVL_ACEPTABLE) {
|
|
ret = 4;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* For the levels below ENTROPY_LVL_HIGH, additional analysis would be
|
|
* needed to give green light to compression.
|
|
*
|
|
* For now just assume that compression at that level is not worth the
|
|
* resources because:
|
|
*
|
|
* 1. it is possible to defrag the data later
|
|
*
|
|
* 2. the data would turn out to be hardly compressible, eg. 150 byte
|
|
* values, every bucket has counter at level ~54. The heuristic would
|
|
* be confused. This can happen when data have some internal repeated
|
|
* patterns like "abbacbbc...". This can be detected by analyzing
|
|
* pairs of bytes, which is too costly.
|
|
*/
|
|
if (i < ENTROPY_LVL_HIGH) {
|
|
ret = 5;
|
|
goto out;
|
|
} else {
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
put_workspace(0, ws_list);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Convert the compression suffix (eg. after "zlib" starting with ":") to
|
|
* level, unrecognized string will set the default level
|
|
*/
|
|
unsigned int btrfs_compress_str2level(unsigned int type, const char *str)
|
|
{
|
|
unsigned int level = 0;
|
|
int ret;
|
|
|
|
if (!type)
|
|
return 0;
|
|
|
|
if (str[0] == ':') {
|
|
ret = kstrtouint(str + 1, 10, &level);
|
|
if (ret)
|
|
level = 0;
|
|
}
|
|
|
|
level = btrfs_compress_set_level(type, level);
|
|
|
|
return level;
|
|
}
|