iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Btrfs: use linux/sizes.h to represent constants

Browse Source 
We use many constants to represent size and offset value.  And to make
code readable we use '256 * 1024 * 1024' instead of '268435456' to
represent '256MB'.  However we can make far more readable with 'SZ_256MB'
which is defined in the 'linux/sizes.h'.

So this patch replaces 'xxx * 1024 * 1024' kind of expression with
single 'SZ_xxxMB' if 'xxx' is a power of 2 then 'xxx * SZ_1M' if 'xxx' is
not a power of 2. And I haven't touched to '4096' & '8192' because it's
more intuitive than 'SZ_4KB' & 'SZ_8KB'.

Signed-off-by: Byongho Lee <bhlee.kernel@gmail.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Byongho Lee 2015-12-15 01:42:10 +09:00 committed by David Sterba
parent 7928d672ff
commit ee22184b53
17 changed files with 147 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/btrfs/ctree.c
View File

@ -1555,7 +1555,7 @@ noinline int btrfs_cow_block(struct btrfs_trans_handle *trans,
return 0; return 0;
} }
search_start = buf->start & ~((u64)(1024 * 1024 * 1024) - 1); search_start = buf->start & ~((u64)SZ_1G - 1);
if (parent) if (parent)
btrfs_set_lock_blocking(parent); btrfs_set_lock_blocking(parent);

5
fs/btrfs/ctree.h
View File

@ -35,6 +35,7 @@
#include <linux/btrfs.h> #include <linux/btrfs.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <linux/security.h> #include <linux/security.h>
#include <linux/sizes.h>
#include "extent_io.h" #include "extent_io.h"
#include "extent_map.h" #include "extent_map.h"
#include "async-thread.h" #include "async-thread.h"
@ -196,9 +197,9 @@ static int btrfs_csum_sizes[] = { 4 };
/* ioprio of readahead is set to idle */ /* ioprio of readahead is set to idle */
#define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0)) #define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
#define BTRFS_DIRTY_METADATA_THRESH (32 * 1024 * 1024) #define BTRFS_DIRTY_METADATA_THRESH SZ_32M
#define BTRFS_MAX_EXTENT_SIZE (128 * 1024 * 1024) #define BTRFS_MAX_EXTENT_SIZE SZ_128M
/* /*
* The key defines the order in the tree, and so it also defines (optimal) * The key defines the order in the tree, and so it also defines (optimal)

2
fs/btrfs/disk-io.c
View File

@ -2809,7 +2809,7 @@ int open_ctree(struct super_block *sb,
fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super); fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages, fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
4 * 1024 * 1024 / PAGE_CACHE_SIZE); SZ_4M / PAGE_CACHE_SIZE);
tree_root->nodesize = nodesize; tree_root->nodesize = nodesize;
tree_root->sectorsize = sectorsize; tree_root->sectorsize = sectorsize;

4
fs/btrfs/disk-io.h
View File

@ -19,7 +19,7 @@
#ifndef __DISKIO__ #ifndef __DISKIO__
#define __DISKIO__ #define __DISKIO__
#define BTRFS_SUPER_INFO_OFFSET (64 * 1024) #define BTRFS_SUPER_INFO_OFFSET SZ_64K
#define BTRFS_SUPER_INFO_SIZE 4096 #define BTRFS_SUPER_INFO_SIZE 4096
#define BTRFS_SUPER_MIRROR_MAX 3 #define BTRFS_SUPER_MIRROR_MAX 3
@ -35,7 +35,7 @@ enum btrfs_wq_endio_type {
static inline u64 btrfs_sb_offset(int mirror) static inline u64 btrfs_sb_offset(int mirror)
{ {
u64 start = 16 * 1024; u64 start = SZ_16K;
if (mirror) if (mirror)
return start << (BTRFS_SUPER_MIRROR_SHIFT * mirror); return start << (BTRFS_SUPER_MIRROR_SHIFT * mirror);
return BTRFS_SUPER_INFO_OFFSET; return BTRFS_SUPER_INFO_OFFSET;

29
fs/btrfs/extent-tree.c
View File

@ -521,7 +521,7 @@ next:
else else
last = key.objectid + key.offset; last = key.objectid + key.offset;
if (total_found > (1024 * 1024 * 2)) { if (total_found > SZ_2M) {
total_found = 0; total_found = 0;
if (wakeup) if (wakeup)
wake_up(&caching_ctl->wait); wake_up(&caching_ctl->wait);
@ -3328,7 +3328,7 @@ static int cache_save_setup(struct btrfs_block_group_cache *block_group,
* If this block group is smaller than 100 megs don't bother caching the * If this block group is smaller than 100 megs don't bother caching the
* block group. * block group.
*/ */
if (block_group->key.offset < (100 * 1024 * 1024)) { if (block_group->key.offset < (100 * SZ_1M)) {
spin_lock(&block_group->lock); spin_lock(&block_group->lock);
block_group->disk_cache_state = BTRFS_DC_WRITTEN; block_group->disk_cache_state = BTRFS_DC_WRITTEN;
spin_unlock(&block_group->lock); spin_unlock(&block_group->lock);
@ -3428,7 +3428,7 @@ again:
* taking up quite a bit since it's not folded into the other space * taking up quite a bit since it's not folded into the other space
* cache. * cache.
*/ */
num_pages = div_u64(block_group->key.offset, 256 * 1024 * 1024); num_pages = div_u64(block_group->key.offset, SZ_256M);
if (!num_pages) if (!num_pages)
num_pages = 1; num_pages = 1;
@ -4239,14 +4239,13 @@ static int should_alloc_chunk(struct btrfs_root *root,
*/ */
if (force == CHUNK_ALLOC_LIMITED) { if (force == CHUNK_ALLOC_LIMITED) {
thresh = btrfs_super_total_bytes(root->fs_info->super_copy); thresh = btrfs_super_total_bytes(root->fs_info->super_copy);
thresh = max_t(u64, 64 * 1024 * 1024, thresh = max_t(u64, SZ_64M, div_factor_fine(thresh, 1));
div_factor_fine(thresh, 1));
if (num_bytes - num_allocated < thresh) if (num_bytes - num_allocated < thresh)
return 1; return 1;
} }
if (num_allocated + 2 * 1024 * 1024 < div_factor(num_bytes, 8)) if (num_allocated + SZ_2M < div_factor(num_bytes, 8))
return 0; return 0;
return 1; return 1;
} }
@ -4446,7 +4445,7 @@ out:
* transaction. * transaction.
*/ */
if (trans->can_flush_pending_bgs && if (trans->can_flush_pending_bgs &&
trans->chunk_bytes_reserved >= (2 * 1024 * 1024ull)) { trans->chunk_bytes_reserved >= (u64)SZ_2M) {
btrfs_create_pending_block_groups(trans, trans->root); btrfs_create_pending_block_groups(trans, trans->root);
btrfs_trans_release_chunk_metadata(trans); btrfs_trans_release_chunk_metadata(trans);
} }
@ -4544,7 +4543,7 @@ static inline int calc_reclaim_items_nr(struct btrfs_root *root, u64 to_reclaim)
return nr; return nr;
} }
#define EXTENT_SIZE_PER_ITEM (256 * 1024) #define EXTENT_SIZE_PER_ITEM SZ_256K
/* /*
* shrink metadata reservation for delalloc * shrink metadata reservation for delalloc
@ -4749,8 +4748,7 @@ btrfs_calc_reclaim_metadata_size(struct btrfs_root *root,
u64 expected; u64 expected;
u64 to_reclaim; u64 to_reclaim;
to_reclaim = min_t(u64, num_online_cpus() * 1024 * 1024, to_reclaim = min_t(u64, num_online_cpus() * SZ_1M, SZ_16M);
16 * 1024 * 1024);
spin_lock(&space_info->lock); spin_lock(&space_info->lock);
if (can_overcommit(root, space_info, to_reclaim, if (can_overcommit(root, space_info, to_reclaim,
BTRFS_RESERVE_FLUSH_ALL)) { BTRFS_RESERVE_FLUSH_ALL)) {
@ -4761,8 +4759,7 @@ btrfs_calc_reclaim_metadata_size(struct btrfs_root *root,
used = space_info->bytes_used + space_info->bytes_reserved + used = space_info->bytes_used + space_info->bytes_reserved +
space_info->bytes_pinned + space_info->bytes_readonly + space_info->bytes_pinned + space_info->bytes_readonly +
space_info->bytes_may_use; space_info->bytes_may_use;
if (can_overcommit(root, space_info, 1024 * 1024, if (can_overcommit(root, space_info, SZ_1M, BTRFS_RESERVE_FLUSH_ALL))
BTRFS_RESERVE_FLUSH_ALL))
expected = div_factor_fine(space_info->total_bytes, 95); expected = div_factor_fine(space_info->total_bytes, 95);
else else
expected = div_factor_fine(space_info->total_bytes, 90); expected = div_factor_fine(space_info->total_bytes, 90);
@ -5318,7 +5315,7 @@ static void update_global_block_rsv(struct btrfs_fs_info *fs_info)
spin_lock(&sinfo->lock); spin_lock(&sinfo->lock);
spin_lock(&block_rsv->lock); spin_lock(&block_rsv->lock);
block_rsv->size = min_t(u64, num_bytes, 512 * 1024 * 1024); block_rsv->size = min_t(u64, num_bytes, SZ_512M);
num_bytes = sinfo->bytes_used + sinfo->bytes_pinned + num_bytes = sinfo->bytes_used + sinfo->bytes_pinned +
sinfo->bytes_reserved + sinfo->bytes_readonly + sinfo->bytes_reserved + sinfo->bytes_readonly +
@ -6222,11 +6219,11 @@ fetch_cluster_info(struct btrfs_root *root, struct btrfs_space_info *space_info,
return ret; return ret;
if (ssd) if (ssd)
*empty_cluster = 2 * 1024 * 1024; *empty_cluster = SZ_2M;
if (space_info->flags & BTRFS_BLOCK_GROUP_METADATA) { if (space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {
ret = &root->fs_info->meta_alloc_cluster; ret = &root->fs_info->meta_alloc_cluster;
if (!ssd) if (!ssd)
*empty_cluster = 64 * 1024; *empty_cluster = SZ_64K;
} else if ((space_info->flags & BTRFS_BLOCK_GROUP_DATA) && ssd) { } else if ((space_info->flags & BTRFS_BLOCK_GROUP_DATA) && ssd) {
ret = &root->fs_info->data_alloc_cluster; ret = &root->fs_info->data_alloc_cluster;
} }
@ -9124,7 +9121,7 @@ static int inc_block_group_ro(struct btrfs_block_group_cache *cache, int force)
if ((sinfo->flags & if ((sinfo->flags &
(BTRFS_BLOCK_GROUP_SYSTEM | BTRFS_BLOCK_GROUP_METADATA)) && (BTRFS_BLOCK_GROUP_SYSTEM | BTRFS_BLOCK_GROUP_METADATA)) &&
!force) !force)
min_allocable_bytes = 1 * 1024 * 1024; min_allocable_bytes = SZ_1M;
else else
min_allocable_bytes = 0; min_allocable_bytes = 0;

2
fs/btrfs/extent_io.c
View File

@ -4387,7 +4387,7 @@ int try_release_extent_mapping(struct extent_map_tree *map,
u64 end = start + PAGE_CACHE_SIZE - 1; u64 end = start + PAGE_CACHE_SIZE - 1;
if (gfpflags_allow_blocking(mask) && if (gfpflags_allow_blocking(mask) &&
page->mapping->host->i_size > 16 * 1024 * 1024) { page->mapping->host->i_size > SZ_16M) {
u64 len; u64 len;
while (start <= end) { while (start <= end) {
len = end - start + 1; len = end - start + 1;

10
fs/btrfs/free-space-cache.c
View File

@ -30,7 +30,7 @@
#include "volumes.h" #include "volumes.h"
#define BITS_PER_BITMAP (PAGE_CACHE_SIZE * 8) #define BITS_PER_BITMAP (PAGE_CACHE_SIZE * 8)
#define MAX_CACHE_BYTES_PER_GIG (32 * 1024) #define MAX_CACHE_BYTES_PER_GIG SZ_32K
struct btrfs_trim_range { struct btrfs_trim_range {
u64 start; u64 start;
@ -1656,11 +1656,10 @@ static void recalculate_thresholds(struct btrfs_free_space_ctl *ctl)
* at or below 32k, so we need to adjust how much memory we allow to be * at or below 32k, so we need to adjust how much memory we allow to be
* used by extent based free space tracking * used by extent based free space tracking
*/ */
if (size < 1024 * 1024 * 1024) if (size < SZ_1G)
max_bytes = MAX_CACHE_BYTES_PER_GIG; max_bytes = MAX_CACHE_BYTES_PER_GIG;
else else
max_bytes = MAX_CACHE_BYTES_PER_GIG * max_bytes = MAX_CACHE_BYTES_PER_GIG * div_u64(size, SZ_1G);
div_u64(size, 1024 * 1024 * 1024);
/* /*
* we want to account for 1 more bitmap than what we have so we can make * we want to account for 1 more bitmap than what we have so we can make
@ -2489,8 +2488,7 @@ void btrfs_init_free_space_ctl(struct btrfs_block_group_cache *block_group)
* track of free space, and if we pass 1/2 of that we want to * track of free space, and if we pass 1/2 of that we want to
* start converting things over to using bitmaps * start converting things over to using bitmaps
*/ */
ctl->extents_thresh = ((1024 * 32) / 2) / ctl->extents_thresh = (SZ_32K / 2) / sizeof(struct btrfs_free_space);
sizeof(struct btrfs_free_space);
} }
/* /*

2
fs/btrfs/inode-map.c
View File

@ -282,7 +282,7 @@ void btrfs_unpin_free_ino(struct btrfs_root *root)
} }
} }
#define INIT_THRESHOLD (((1024 * 32) / 2) / sizeof(struct btrfs_free_space)) #define INIT_THRESHOLD ((SZ_32K / 2) / sizeof(struct btrfs_free_space))
#define INODES_PER_BITMAP (PAGE_CACHE_SIZE * 8) #define INODES_PER_BITMAP (PAGE_CACHE_SIZE * 8)
/* /*

22
fs/btrfs/inode.c
View File

@ -414,15 +414,15 @@ static noinline void compress_file_range(struct inode *inode,
unsigned long nr_pages_ret = 0; unsigned long nr_pages_ret = 0;
unsigned long total_compressed = 0; unsigned long total_compressed = 0;
unsigned long total_in = 0; unsigned long total_in = 0;
unsigned long max_compressed = 128 * 1024; unsigned long max_compressed = SZ_128K;
unsigned long max_uncompressed = 128 * 1024; unsigned long max_uncompressed = SZ_128K;
int i; int i;
int will_compress; int will_compress;
int compress_type = root->fs_info->compress_type; int compress_type = root->fs_info->compress_type;
int redirty = 0; int redirty = 0;
/* if this is a small write inside eof, kick off a defrag */ /* if this is a small write inside eof, kick off a defrag */
if ((end - start + 1) < 16 * 1024 && if ((end - start + 1) < SZ_16K &&
(start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
btrfs_add_inode_defrag(NULL, inode); btrfs_add_inode_defrag(NULL, inode);
@ -430,7 +430,7 @@ static noinline void compress_file_range(struct inode *inode,
again: again:
will_compress = 0; will_compress = 0;
nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1; nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE); nr_pages = min_t(unsigned long, nr_pages, SZ_128K / PAGE_CACHE_SIZE);
/* /*
* we don't want to send crud past the end of i_size through * we don't want to send crud past the end of i_size through
@ -944,7 +944,7 @@ static noinline int cow_file_range(struct inode *inode,
disk_num_bytes = num_bytes; disk_num_bytes = num_bytes;
/* if this is a small write inside eof, kick off defrag */ /* if this is a small write inside eof, kick off defrag */
if (num_bytes < 64 * 1024 && if (num_bytes < SZ_64K &&
(start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
btrfs_add_inode_defrag(NULL, inode); btrfs_add_inode_defrag(NULL, inode);
@ -1107,7 +1107,7 @@ static noinline void async_cow_submit(struct btrfs_work *work)
* atomic_sub_return implies a barrier for waitqueue_active * atomic_sub_return implies a barrier for waitqueue_active
*/ */
if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) < if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) <
5 * 1024 * 1024 && 5 * SZ_1M &&
waitqueue_active(&root->fs_info->async_submit_wait)) waitqueue_active(&root->fs_info->async_submit_wait))
wake_up(&root->fs_info->async_submit_wait); wake_up(&root->fs_info->async_submit_wait);
@ -1132,7 +1132,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
struct btrfs_root *root = BTRFS_I(inode)->root; struct btrfs_root *root = BTRFS_I(inode)->root;
unsigned long nr_pages; unsigned long nr_pages;
u64 cur_end; u64 cur_end;
int limit = 10 * 1024 * 1024; int limit = 10 * SZ_1M;
clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED, clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
1, 0, NULL, GFP_NOFS); 1, 0, NULL, GFP_NOFS);
@ -1148,7 +1148,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
!btrfs_test_opt(root, FORCE_COMPRESS)) !btrfs_test_opt(root, FORCE_COMPRESS))
cur_end = end; cur_end = end;
else else
cur_end = min(end, start + 512 * 1024 - 1); cur_end = min(end, start + SZ_512K - 1);
async_cow->end = cur_end; async_cow->end = cur_end;
INIT_LIST_HEAD(&async_cow->extents); INIT_LIST_HEAD(&async_cow->extents);
@ -4348,7 +4348,7 @@ search_again:
* up a huge file in a single leaf. Most of the time that * up a huge file in a single leaf. Most of the time that
* bytes_deleted is > 0, it will be huge by the time we get here * bytes_deleted is > 0, it will be huge by the time we get here
*/ */
if (be_nice && bytes_deleted > 32 * 1024 * 1024) { if (be_nice && bytes_deleted > SZ_32M) {
if (btrfs_should_end_transaction(trans, root)) { if (btrfs_should_end_transaction(trans, root)) {
err = -EAGAIN; err = -EAGAIN;
goto error; goto error;
@ -4591,7 +4591,7 @@ error:
btrfs_free_path(path); btrfs_free_path(path);
if (be_nice && bytes_deleted > 32 * 1024 * 1024) { if (be_nice && bytes_deleted > SZ_32M) {
unsigned long updates = trans->delayed_ref_updates; unsigned long updates = trans->delayed_ref_updates;
if (updates) { if (updates) {
trans->delayed_ref_updates = 0; trans->delayed_ref_updates = 0;
@ -9757,7 +9757,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
} }
} }
cur_bytes = min(num_bytes, 256ULL * 1024 * 1024); cur_bytes = min_t(u64, num_bytes, SZ_256M);
cur_bytes = max(cur_bytes, min_size); cur_bytes = max(cur_bytes, min_size);
/* /*
* If we are severely fragmented we could end up with really * If we are severely fragmented we could end up with really

23
fs/btrfs/ioctl.c
View File

@ -1016,7 +1016,7 @@ static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em)
if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE) if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE)
ret = false; ret = false;
else if ((em->block_start + em->block_len == next->block_start) && else if ((em->block_start + em->block_len == next->block_start) &&
(em->block_len > 128 * 1024 && next->block_len > 128 * 1024)) (em->block_len > SZ_128K && next->block_len > SZ_128K))
ret = false; ret = false;
free_extent_map(next); free_extent_map(next);
@ -1262,9 +1262,9 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
int defrag_count = 0; int defrag_count = 0;
int compress_type = BTRFS_COMPRESS_ZLIB; int compress_type = BTRFS_COMPRESS_ZLIB;
u32 extent_thresh = range->extent_thresh; u32 extent_thresh = range->extent_thresh;
unsigned long max_cluster = (256 * 1024) >> PAGE_CACHE_SHIFT; unsigned long max_cluster = SZ_256K >> PAGE_CACHE_SHIFT;
unsigned long cluster = max_cluster; unsigned long cluster = max_cluster;
u64 new_align = ~((u64)128 * 1024 - 1); u64 new_align = ~((u64)SZ_128K - 1);
struct page **pages = NULL; struct page **pages = NULL;
if (isize == 0) if (isize == 0)
@ -1281,7 +1281,7 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
} }
if (extent_thresh == 0) if (extent_thresh == 0)
extent_thresh = 256 * 1024; extent_thresh = SZ_256K;
/* /*
* if we were not given a file, allocate a readahead * if we were not given a file, allocate a readahead
@ -1313,7 +1313,7 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
if (newer_than) { if (newer_than) {
ret = find_new_extents(root, inode, newer_than, ret = find_new_extents(root, inode, newer_than,
&newer_off, 64 * 1024); &newer_off, SZ_64K);
if (!ret) { if (!ret) {
range->start = newer_off; range->start = newer_off;
/* /*
@ -1403,9 +1403,8 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
newer_off = max(newer_off + 1, newer_off = max(newer_off + 1,
(u64)i << PAGE_CACHE_SHIFT); (u64)i << PAGE_CACHE_SHIFT);
ret = find_new_extents(root, inode, ret = find_new_extents(root, inode, newer_than,
newer_than, &newer_off, &newer_off, SZ_64K);
64 * 1024);
if (!ret) { if (!ret) {
range->start = newer_off; range->start = newer_off;
i = (newer_off & new_align) >> PAGE_CACHE_SHIFT; i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
@ -1571,7 +1570,7 @@ static noinline int btrfs_ioctl_resize(struct file *file,
new_size = old_size + new_size; new_size = old_size + new_size;
} }
if (new_size < 256 * 1024 * 1024) { if (new_size < SZ_256M) {
ret = -EINVAL; ret = -EINVAL;
goto out_free; goto out_free;
} }
@ -2160,7 +2159,7 @@ static noinline int btrfs_ioctl_tree_search_v2(struct file *file,
struct inode *inode; struct inode *inode;
int ret; int ret;
size_t buf_size; size_t buf_size;
const size_t buf_limit = 16 * 1024 * 1024; const size_t buf_limit = SZ_16M;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EPERM; return -EPERM;
@ -3096,7 +3095,7 @@ out_unlock:
return ret; return ret;
} }
#define BTRFS_MAX_DEDUPE_LEN (16 * 1024 * 1024) #define BTRFS_MAX_DEDUPE_LEN SZ_16M
static long btrfs_ioctl_file_extent_same(struct file *file, static long btrfs_ioctl_file_extent_same(struct file *file,
struct btrfs_ioctl_same_args __user *argp) struct btrfs_ioctl_same_args __user *argp)
@ -4524,7 +4523,7 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
goto out; goto out;
} }
size = min_t(u32, loi->size, 64 * 1024); size = min_t(u32, loi->size, SZ_64K);
inodes = init_data_container(size); inodes = init_data_container(size);
if (IS_ERR(inodes)) { if (IS_ERR(inodes)) {
ret = PTR_ERR(inodes); ret = PTR_ERR(inodes);

4
fs/btrfs/send.h
View File

@ -22,8 +22,8 @@
#define BTRFS_SEND_STREAM_MAGIC "btrfs-stream" #define BTRFS_SEND_STREAM_MAGIC "btrfs-stream"
#define BTRFS_SEND_STREAM_VERSION 1 #define BTRFS_SEND_STREAM_VERSION 1
#define BTRFS_SEND_BUF_SIZE (1024 * 64) #define BTRFS_SEND_BUF_SIZE SZ_64K
#define BTRFS_SEND_READ_SIZE (1024 * 48) #define BTRFS_SEND_READ_SIZE (48 * SZ_1K)
enum btrfs_tlv_type { enum btrfs_tlv_type {
BTRFS_TLV_U8, BTRFS_TLV_U8,

2
fs/btrfs/super.c
View File

@ -1865,7 +1865,7 @@ static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
* btrfs starts at an offset of at least 1MB when doing chunk * btrfs starts at an offset of at least 1MB when doing chunk
* allocation. * allocation.
*/ */
skip_space = 1024 * 1024; skip_space = SZ_1M;
/* user can set the offset in fs_info->alloc_start. */ /* user can set the offset in fs_info->alloc_start. */
if (fs_info->alloc_start && if (fs_info->alloc_start &&

11
fs/btrfs/tests/extent-io-tests.c
View File

@ -18,6 +18,7 @@
#include <linux/pagemap.h> #include <linux/pagemap.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/sizes.h>
#include "btrfs-tests.h" #include "btrfs-tests.h"
#include "../extent_io.h" #include "../extent_io.h"
@ -70,8 +71,8 @@ static int test_find_delalloc(void)
struct page *page; struct page *page;
struct page *locked_page = NULL; struct page *locked_page = NULL;
unsigned long index = 0; unsigned long index = 0;
u64 total_dirty = 256 * 1024 * 1024; u64 total_dirty = SZ_256M;
u64 max_bytes = 128 * 1024 * 1024; u64 max_bytes = SZ_128M;
u64 start, end, test_start; u64 start, end, test_start;
u64 found; u64 found;
int ret = -EINVAL; int ret = -EINVAL;
@ -133,7 +134,7 @@ static int test_find_delalloc(void)
* |--- delalloc ---| * |--- delalloc ---|
* |--- search ---| * |--- search ---|
*/ */
test_start = 64 * 1024 * 1024; test_start = SZ_64M;
locked_page = find_lock_page(inode->i_mapping, locked_page = find_lock_page(inode->i_mapping,
test_start >> PAGE_CACHE_SHIFT); test_start >> PAGE_CACHE_SHIFT);
if (!locked_page) { if (!locked_page) {
@ -220,8 +221,8 @@ static int test_find_delalloc(void)
* Now to test where we run into a page that is no longer dirty in the * Now to test where we run into a page that is no longer dirty in the
* range we want to find. * range we want to find.
*/ */
page = find_get_page(inode->i_mapping, (max_bytes + (1 * 1024 * 1024)) page = find_get_page(inode->i_mapping,
>> PAGE_CACHE_SHIFT); (max_bytes + SZ_1M) >> PAGE_CACHE_SHIFT);
if (!page) { if (!page) {
test_msg("Couldn't find our page\n"); test_msg("Couldn't find our page\n");
goto out_bits; goto out_bits;

186
fs/btrfs/tests/free-space-tests.c
View File

@ -44,7 +44,7 @@ static struct btrfs_block_group_cache *init_test_block_group(void)
} }
cache->key.objectid = 0; cache->key.objectid = 0;
cache->key.offset = 1024 * 1024 * 1024; cache->key.offset = SZ_1G;
cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
cache->sectorsize = 4096; cache->sectorsize = 4096;
cache->full_stripe_len = 4096; cache->full_stripe_len = 4096;
@ -71,59 +71,59 @@ static int test_extents(struct btrfs_block_group_cache *cache)
test_msg("Running extent only tests\n"); test_msg("Running extent only tests\n");
/* First just make sure we can remove an entire entry */ /* First just make sure we can remove an entire entry */
ret = btrfs_add_free_space(cache, 0, 4 * 1024 * 1024); ret = btrfs_add_free_space(cache, 0, SZ_4M);
if (ret) { if (ret) {
test_msg("Error adding initial extents %d\n", ret); test_msg("Error adding initial extents %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 0, 4 * 1024 * 1024); ret = btrfs_remove_free_space(cache, 0, SZ_4M);
if (ret) { if (ret) {
test_msg("Error removing extent %d\n", ret); test_msg("Error removing extent %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, 0, 4 * 1024 * 1024)) { if (test_check_exists(cache, 0, SZ_4M)) {
test_msg("Full remove left some lingering space\n"); test_msg("Full remove left some lingering space\n");
return -1; return -1;
} }
/* Ok edge and middle cases now */ /* Ok edge and middle cases now */
ret = btrfs_add_free_space(cache, 0, 4 * 1024 * 1024); ret = btrfs_add_free_space(cache, 0, SZ_4M);
if (ret) { if (ret) {
test_msg("Error adding half extent %d\n", ret); test_msg("Error adding half extent %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 3 * 1024 * 1024, 1 * 1024 * 1024); ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_1M);
if (ret) { if (ret) {
test_msg("Error removing tail end %d\n", ret); test_msg("Error removing tail end %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 0, 1 * 1024 * 1024); ret = btrfs_remove_free_space(cache, 0, SZ_1M);
if (ret) { if (ret) {
test_msg("Error removing front end %d\n", ret); test_msg("Error removing front end %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 2 * 1024 * 1024, 4096); ret = btrfs_remove_free_space(cache, SZ_2M, 4096);
if (ret) { if (ret) {
test_msg("Error removing middle piece %d\n", ret); test_msg("Error removing middle piece %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, 0, 1 * 1024 * 1024)) { if (test_check_exists(cache, 0, SZ_1M)) {
test_msg("Still have space at the front\n"); test_msg("Still have space at the front\n");
return -1; return -1;
} }
if (test_check_exists(cache, 2 * 1024 * 1024, 4096)) { if (test_check_exists(cache, SZ_2M, 4096)) {
test_msg("Still have space in the middle\n"); test_msg("Still have space in the middle\n");
return -1; return -1;
} }
if (test_check_exists(cache, 3 * 1024 * 1024, 1 * 1024 * 1024)) { if (test_check_exists(cache, 3 * SZ_1M, SZ_1M)) {
test_msg("Still have space at the end\n"); test_msg("Still have space at the end\n");
return -1; return -1;
} }
@ -141,30 +141,30 @@ static int test_bitmaps(struct btrfs_block_group_cache *cache)
test_msg("Running bitmap only tests\n"); test_msg("Running bitmap only tests\n");
ret = test_add_free_space_entry(cache, 0, 4 * 1024 * 1024, 1); ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
if (ret) { if (ret) {
test_msg("Couldn't create a bitmap entry %d\n", ret); test_msg("Couldn't create a bitmap entry %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 0, 4 * 1024 * 1024); ret = btrfs_remove_free_space(cache, 0, SZ_4M);
if (ret) { if (ret) {
test_msg("Error removing bitmap full range %d\n", ret); test_msg("Error removing bitmap full range %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, 0, 4 * 1024 * 1024)) { if (test_check_exists(cache, 0, SZ_4M)) {
test_msg("Left some space in bitmap\n"); test_msg("Left some space in bitmap\n");
return -1; return -1;
} }
ret = test_add_free_space_entry(cache, 0, 4 * 1024 * 1024, 1); ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
if (ret) { if (ret) {
test_msg("Couldn't add to our bitmap entry %d\n", ret); test_msg("Couldn't add to our bitmap entry %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 1 * 1024 * 1024, 2 * 1024 * 1024); ret = btrfs_remove_free_space(cache, SZ_1M, SZ_2M);
if (ret) { if (ret) {
test_msg("Couldn't remove middle chunk %d\n", ret); test_msg("Couldn't remove middle chunk %d\n", ret);
return ret; return ret;
@ -177,23 +177,21 @@ static int test_bitmaps(struct btrfs_block_group_cache *cache)
next_bitmap_offset = (u64)(BITS_PER_BITMAP * 4096); next_bitmap_offset = (u64)(BITS_PER_BITMAP * 4096);
/* Test a bit straddling two bitmaps */ /* Test a bit straddling two bitmaps */
ret = test_add_free_space_entry(cache, next_bitmap_offset - ret = test_add_free_space_entry(cache, next_bitmap_offset - SZ_2M,
(2 * 1024 * 1024), 4 * 1024 * 1024, 1); SZ_4M, 1);
if (ret) { if (ret) {
test_msg("Couldn't add space that straddles two bitmaps %d\n", test_msg("Couldn't add space that straddles two bitmaps %d\n",
ret); ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, next_bitmap_offset - ret = btrfs_remove_free_space(cache, next_bitmap_offset - SZ_1M, SZ_2M);
(1 * 1024 * 1024), 2 * 1024 * 1024);
if (ret) { if (ret) {
test_msg("Couldn't remove overlapping space %d\n", ret); test_msg("Couldn't remove overlapping space %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, next_bitmap_offset - (1 * 1024 * 1024), if (test_check_exists(cache, next_bitmap_offset - SZ_1M, SZ_2M)) {
2 * 1024 * 1024)) {
test_msg("Left some space when removing overlapping\n"); test_msg("Left some space when removing overlapping\n");
return -1; return -1;
} }
@ -216,43 +214,43 @@ static int test_bitmaps_and_extents(struct btrfs_block_group_cache *cache)
* bitmap, but the free space completely in the extent and then * bitmap, but the free space completely in the extent and then
* completely in the bitmap. * completely in the bitmap.
*/ */
ret = test_add_free_space_entry(cache, 4 * 1024 * 1024, 1 * 1024 * 1024, 1); ret = test_add_free_space_entry(cache, SZ_4M, SZ_1M, 1);
if (ret) { if (ret) {
test_msg("Couldn't create bitmap entry %d\n", ret); test_msg("Couldn't create bitmap entry %d\n", ret);
return ret; return ret;
} }
ret = test_add_free_space_entry(cache, 0, 1 * 1024 * 1024, 0); ret = test_add_free_space_entry(cache, 0, SZ_1M, 0);
if (ret) { if (ret) {
test_msg("Couldn't add extent entry %d\n", ret); test_msg("Couldn't add extent entry %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 0, 1 * 1024 * 1024); ret = btrfs_remove_free_space(cache, 0, SZ_1M);
if (ret) { if (ret) {
test_msg("Couldn't remove extent entry %d\n", ret); test_msg("Couldn't remove extent entry %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, 0, 1 * 1024 * 1024)) { if (test_check_exists(cache, 0, SZ_1M)) {
test_msg("Left remnants after our remove\n"); test_msg("Left remnants after our remove\n");
return -1; return -1;
} }
/* Now to add back the extent entry and remove from the bitmap */ /* Now to add back the extent entry and remove from the bitmap */
ret = test_add_free_space_entry(cache, 0, 1 * 1024 * 1024, 0); ret = test_add_free_space_entry(cache, 0, SZ_1M, 0);
if (ret) { if (ret) {
test_msg("Couldn't re-add extent entry %d\n", ret); test_msg("Couldn't re-add extent entry %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 4 * 1024 * 1024, 1 * 1024 * 1024); ret = btrfs_remove_free_space(cache, SZ_4M, SZ_1M);
if (ret) { if (ret) {
test_msg("Couldn't remove from bitmap %d\n", ret); test_msg("Couldn't remove from bitmap %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, 4 * 1024 * 1024, 1 * 1024 * 1024)) { if (test_check_exists(cache, SZ_4M, SZ_1M)) {
test_msg("Left remnants in the bitmap\n"); test_msg("Left remnants in the bitmap\n");
return -1; return -1;
} }
@ -261,19 +259,19 @@ static int test_bitmaps_and_extents(struct btrfs_block_group_cache *cache)
* Ok so a little more evil, extent entry and bitmap at the same offset, * Ok so a little more evil, extent entry and bitmap at the same offset,
* removing an overlapping chunk. * removing an overlapping chunk.
*/ */
ret = test_add_free_space_entry(cache, 1 * 1024 * 1024, 4 * 1024 * 1024, 1); ret = test_add_free_space_entry(cache, SZ_1M, SZ_4M, 1);
if (ret) { if (ret) {
test_msg("Couldn't add to a bitmap %d\n", ret); test_msg("Couldn't add to a bitmap %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 512 * 1024, 3 * 1024 * 1024); ret = btrfs_remove_free_space(cache, SZ_512K, 3 * SZ_1M);
if (ret) { if (ret) {
test_msg("Couldn't remove overlapping space %d\n", ret); test_msg("Couldn't remove overlapping space %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, 512 * 1024, 3 * 1024 * 1024)) { if (test_check_exists(cache, SZ_512K, 3 * SZ_1M)) {
test_msg("Left over pieces after removing overlapping\n"); test_msg("Left over pieces after removing overlapping\n");
return -1; return -1;
} }
@ -281,25 +279,25 @@ static int test_bitmaps_and_extents(struct btrfs_block_group_cache *cache)
__btrfs_remove_free_space_cache(cache->free_space_ctl); __btrfs_remove_free_space_cache(cache->free_space_ctl);
/* Now with the extent entry offset into the bitmap */ /* Now with the extent entry offset into the bitmap */
ret = test_add_free_space_entry(cache, 4 * 1024 * 1024, 4 * 1024 * 1024, 1); ret = test_add_free_space_entry(cache, SZ_4M, SZ_4M, 1);
if (ret) { if (ret) {
test_msg("Couldn't add space to the bitmap %d\n", ret); test_msg("Couldn't add space to the bitmap %d\n", ret);
return ret; return ret;
} }
ret = test_add_free_space_entry(cache, 2 * 1024 * 1024, 2 * 1024 * 1024, 0); ret = test_add_free_space_entry(cache, SZ_2M, SZ_2M, 0);
if (ret) { if (ret) {
test_msg("Couldn't add extent to the cache %d\n", ret); test_msg("Couldn't add extent to the cache %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 3 * 1024 * 1024, 4 * 1024 * 1024); ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_4M);
if (ret) { if (ret) {
test_msg("Problem removing overlapping space %d\n", ret); test_msg("Problem removing overlapping space %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, 3 * 1024 * 1024, 4 * 1024 * 1024)) { if (test_check_exists(cache, 3 * SZ_1M, SZ_4M)) {
test_msg("Left something behind when removing space"); test_msg("Left something behind when removing space");
return -1; return -1;
} }
@ -315,29 +313,26 @@ static int test_bitmaps_and_extents(struct btrfs_block_group_cache *cache)
* [ del ] * [ del ]
*/ */
__btrfs_remove_free_space_cache(cache->free_space_ctl); __btrfs_remove_free_space_cache(cache->free_space_ctl);
ret = test_add_free_space_entry(cache, bitmap_offset + 4 * 1024 * 1024, ret = test_add_free_space_entry(cache, bitmap_offset + SZ_4M, SZ_4M, 1);
4 * 1024 * 1024, 1);
if (ret) { if (ret) {
test_msg("Couldn't add bitmap %d\n", ret); test_msg("Couldn't add bitmap %d\n", ret);
return ret; return ret;
} }
ret = test_add_free_space_entry(cache, bitmap_offset - 1 * 1024 * 1024, ret = test_add_free_space_entry(cache, bitmap_offset - SZ_1M,
5 * 1024 * 1024, 0); 5 * SZ_1M, 0);
if (ret) { if (ret) {
test_msg("Couldn't add extent entry %d\n", ret); test_msg("Couldn't add extent entry %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, bitmap_offset + 1 * 1024 * 1024, ret = btrfs_remove_free_space(cache, bitmap_offset + SZ_1M, 5 * SZ_1M);
5 * 1024 * 1024);
if (ret) { if (ret) {
test_msg("Failed to free our space %d\n", ret); test_msg("Failed to free our space %d\n", ret);
return ret; return ret;
} }
if (test_check_exists(cache, bitmap_offset + 1 * 1024 * 1024, if (test_check_exists(cache, bitmap_offset + SZ_1M, 5 * SZ_1M)) {
5 * 1024 * 1024)) {
test_msg("Left stuff over\n"); test_msg("Left stuff over\n");
return -1; return -1;
} }
@ -350,19 +345,19 @@ static int test_bitmaps_and_extents(struct btrfs_block_group_cache *cache)
* to return -EAGAIN back from btrfs_remove_extent, make sure this * to return -EAGAIN back from btrfs_remove_extent, make sure this
* doesn't happen. * doesn't happen.
*/ */
ret = test_add_free_space_entry(cache, 1 * 1024 * 1024, 2 * 1024 * 1024, 1); ret = test_add_free_space_entry(cache, SZ_1M, SZ_2M, 1);
if (ret) { if (ret) {
test_msg("Couldn't add bitmap entry %d\n", ret); test_msg("Couldn't add bitmap entry %d\n", ret);
return ret; return ret;
} }
ret = test_add_free_space_entry(cache, 3 * 1024 * 1024, 1 * 1024 * 1024, 0); ret = test_add_free_space_entry(cache, 3 * SZ_1M, SZ_1M, 0);
if (ret) { if (ret) {
test_msg("Couldn't add extent entry %d\n", ret); test_msg("Couldn't add extent entry %d\n", ret);
return ret; return ret;
} }
ret = btrfs_remove_free_space(cache, 1 * 1024 * 1024, 3 * 1024 * 1024); ret = btrfs_remove_free_space(cache, SZ_1M, 3 * SZ_1M);
if (ret) { if (ret) {
test_msg("Error removing bitmap and extent overlapping %d\n", ret); test_msg("Error removing bitmap and extent overlapping %d\n", ret);
return ret; return ret;
@ -475,16 +470,15 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
/* /*
* Extent entry covering free space range [128Mb - 256Kb, 128Mb - 128Kb[ * Extent entry covering free space range [128Mb - 256Kb, 128Mb - 128Kb[
*/ */
ret = test_add_free_space_entry(cache, 128 * 1024 * 1024 - 256 * 1024, ret = test_add_free_space_entry(cache, SZ_128M - SZ_256K, SZ_128K, 0);
128 * 1024, 0);
if (ret) { if (ret) {
test_msg("Couldn't add extent entry %d\n", ret); test_msg("Couldn't add extent entry %d\n", ret);
return ret; return ret;
} }
/* Bitmap entry covering free space range [128Mb + 512Kb, 256Mb[ */ /* Bitmap entry covering free space range [128Mb + 512Kb, 256Mb[ */
ret = test_add_free_space_entry(cache, 128 * 1024 * 1024 + 512 * 1024, ret = test_add_free_space_entry(cache, SZ_128M + SZ_512K,
128 * 1024 * 1024 - 512 * 1024, 1); SZ_128M - SZ_512K, 1);
if (ret) { if (ret) {
test_msg("Couldn't add bitmap entry %d\n", ret); test_msg("Couldn't add bitmap entry %d\n", ret);
return ret; return ret;
@ -502,21 +496,19 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* [128Mb + 512Kb, 128Mb + 768Kb[ * [128Mb + 512Kb, 128Mb + 768Kb[
*/ */
ret = btrfs_remove_free_space(cache, ret = btrfs_remove_free_space(cache,
128 * 1024 * 1024 + 768 * 1024, SZ_128M + 768 * SZ_1K,
128 * 1024 * 1024 - 768 * 1024); SZ_128M - 768 * SZ_1K);
if (ret) { if (ret) {
test_msg("Failed to free part of bitmap space %d\n", ret); test_msg("Failed to free part of bitmap space %d\n", ret);
return ret; return ret;
} }
/* Confirm that only those 2 ranges are marked as free. */ /* Confirm that only those 2 ranges are marked as free. */
if (!test_check_exists(cache, 128 * 1024 * 1024 - 256 * 1024, if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_128K)) {
128 * 1024)) {
test_msg("Free space range missing\n"); test_msg("Free space range missing\n");
return -ENOENT; return -ENOENT;
} }
if (!test_check_exists(cache, 128 * 1024 * 1024 + 512 * 1024, if (!test_check_exists(cache, SZ_128M + SZ_512K, SZ_256K)) {
256 * 1024)) {
test_msg("Free space range missing\n"); test_msg("Free space range missing\n");
return -ENOENT; return -ENOENT;
} }
@ -525,8 +517,8 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* Confirm that the bitmap range [128Mb + 768Kb, 256Mb[ isn't marked * Confirm that the bitmap range [128Mb + 768Kb, 256Mb[ isn't marked
* as free anymore. * as free anymore.
*/ */
if (test_check_exists(cache, 128 * 1024 * 1024 + 768 * 1024, if (test_check_exists(cache, SZ_128M + 768 * SZ_1K,
128 * 1024 * 1024 - 768 * 1024)) { SZ_128M - 768 * SZ_1K)) {
test_msg("Bitmap region not removed from space cache\n"); test_msg("Bitmap region not removed from space cache\n");
return -EINVAL; return -EINVAL;
} }
@ -535,8 +527,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* Confirm that the region [128Mb + 256Kb, 128Mb + 512Kb[, which is * Confirm that the region [128Mb + 256Kb, 128Mb + 512Kb[, which is
* covered by the bitmap, isn't marked as free. * covered by the bitmap, isn't marked as free.
*/ */
if (test_check_exists(cache, 128 * 1024 * 1024 + 256 * 1024, if (test_check_exists(cache, SZ_128M + SZ_256K, SZ_256K)) {
256 * 1024)) {
test_msg("Invalid bitmap region marked as free\n"); test_msg("Invalid bitmap region marked as free\n");
return -EINVAL; return -EINVAL;
} }
@ -545,8 +536,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* Confirm that the region [128Mb, 128Mb + 256Kb[, which is covered * Confirm that the region [128Mb, 128Mb + 256Kb[, which is covered
* by the bitmap too, isn't marked as free either. * by the bitmap too, isn't marked as free either.
*/ */
if (test_check_exists(cache, 128 * 1024 * 1024, if (test_check_exists(cache, SZ_128M, SZ_256K)) {
256 * 1024)) {
test_msg("Invalid bitmap region marked as free\n"); test_msg("Invalid bitmap region marked as free\n");
return -EINVAL; return -EINVAL;
} }
@ -556,13 +546,13 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* lets make sure the free space cache marks it as free in the bitmap, * lets make sure the free space cache marks it as free in the bitmap,
* and doesn't insert a new extent entry to represent this region. * and doesn't insert a new extent entry to represent this region.
*/ */
ret = btrfs_add_free_space(cache, 128 * 1024 * 1024, 512 * 1024); ret = btrfs_add_free_space(cache, SZ_128M, SZ_512K);
if (ret) { if (ret) {
test_msg("Error adding free space: %d\n", ret); test_msg("Error adding free space: %d\n", ret);
return ret; return ret;
} }
/* Confirm the region is marked as free. */ /* Confirm the region is marked as free. */
if (!test_check_exists(cache, 128 * 1024 * 1024, 512 * 1024)) { if (!test_check_exists(cache, SZ_128M, SZ_512K)) {
test_msg("Bitmap region not marked as free\n"); test_msg("Bitmap region not marked as free\n");
return -ENOENT; return -ENOENT;
} }
@ -581,8 +571,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* The goal is to test that the bitmap entry space stealing doesn't * The goal is to test that the bitmap entry space stealing doesn't
* steal this space region. * steal this space region.
*/ */
ret = btrfs_add_free_space(cache, 128 * 1024 * 1024 + 16 * 1024 * 1024, ret = btrfs_add_free_space(cache, SZ_128M + SZ_16M, 4096);
4096);
if (ret) { if (ret) {
test_msg("Error adding free space: %d\n", ret); test_msg("Error adding free space: %d\n", ret);
return ret; return ret;
@ -601,15 +590,13 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* expand the range covered by the existing extent entry that represents * expand the range covered by the existing extent entry that represents
* the free space [128Mb - 256Kb, 128Mb - 128Kb[. * the free space [128Mb - 256Kb, 128Mb - 128Kb[.
*/ */
ret = btrfs_add_free_space(cache, 128 * 1024 * 1024 - 128 * 1024, ret = btrfs_add_free_space(cache, SZ_128M - SZ_128K, SZ_128K);
128 * 1024);
if (ret) { if (ret) {
test_msg("Error adding free space: %d\n", ret); test_msg("Error adding free space: %d\n", ret);
return ret; return ret;
} }
/* Confirm the region is marked as free. */ /* Confirm the region is marked as free. */
if (!test_check_exists(cache, 128 * 1024 * 1024 - 128 * 1024, if (!test_check_exists(cache, SZ_128M - SZ_128K, SZ_128K)) {
128 * 1024)) {
test_msg("Extent region not marked as free\n"); test_msg("Extent region not marked as free\n");
return -ENOENT; return -ENOENT;
} }
@ -637,21 +624,20 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* that represents the 1Mb free space, and therefore we're able to * that represents the 1Mb free space, and therefore we're able to
* allocate the whole free space at once. * allocate the whole free space at once.
*/ */
if (!test_check_exists(cache, 128 * 1024 * 1024 - 256 * 1024, if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_1M)) {
1 * 1024 * 1024)) {
test_msg("Expected region not marked as free\n"); test_msg("Expected region not marked as free\n");
return -ENOENT; return -ENOENT;
} }
if (cache->free_space_ctl->free_space != (1 * 1024 * 1024 + 4096)) { if (cache->free_space_ctl->free_space != (SZ_1M + 4096)) {
test_msg("Cache free space is not 1Mb + 4Kb\n"); test_msg("Cache free space is not 1Mb + 4Kb\n");
return -EINVAL; return -EINVAL;
} }
offset = btrfs_find_space_for_alloc(cache, offset = btrfs_find_space_for_alloc(cache,
0, 1 * 1024 * 1024, 0, 0, SZ_1M, 0,
&max_extent_size); &max_extent_size);
if (offset != (128 * 1024 * 1024 - 256 * 1024)) { if (offset != (SZ_128M - SZ_256K)) {
test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n", test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n",
offset); offset);
return -EINVAL; return -EINVAL;
@ -670,7 +656,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
offset = btrfs_find_space_for_alloc(cache, offset = btrfs_find_space_for_alloc(cache,
0, 4096, 0, 0, 4096, 0,
&max_extent_size); &max_extent_size);
if (offset != (128 * 1024 * 1024 + 16 * 1024 * 1024)) { if (offset != (SZ_128M + SZ_16M)) {
test_msg("Failed to allocate 4Kb from space cache, returned offset is: %llu\n", test_msg("Failed to allocate 4Kb from space cache, returned offset is: %llu\n",
offset); offset);
return -EINVAL; return -EINVAL;
@ -691,16 +677,14 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
/* /*
* Extent entry covering free space range [128Mb + 128Kb, 128Mb + 256Kb[ * Extent entry covering free space range [128Mb + 128Kb, 128Mb + 256Kb[
*/ */
ret = test_add_free_space_entry(cache, 128 * 1024 * 1024 + 128 * 1024, ret = test_add_free_space_entry(cache, SZ_128M + SZ_128K, SZ_128K, 0);
128 * 1024, 0);
if (ret) { if (ret) {
test_msg("Couldn't add extent entry %d\n", ret); test_msg("Couldn't add extent entry %d\n", ret);
return ret; return ret;
} }
/* Bitmap entry covering free space range [0, 128Mb - 512Kb[ */ /* Bitmap entry covering free space range [0, 128Mb - 512Kb[ */
ret = test_add_free_space_entry(cache, 0, ret = test_add_free_space_entry(cache, 0, SZ_128M - SZ_512K, 1);
128 * 1024 * 1024 - 512 * 1024, 1);
if (ret) { if (ret) {
test_msg("Couldn't add bitmap entry %d\n", ret); test_msg("Couldn't add bitmap entry %d\n", ret);
return ret; return ret;
@ -717,22 +701,18 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* [128Mb + 128b, 128Mb + 256Kb[ * [128Mb + 128b, 128Mb + 256Kb[
* [128Mb - 768Kb, 128Mb - 512Kb[ * [128Mb - 768Kb, 128Mb - 512Kb[
*/ */
ret = btrfs_remove_free_space(cache, ret = btrfs_remove_free_space(cache, 0, SZ_128M - 768 * SZ_1K);
0,
128 * 1024 * 1024 - 768 * 1024);
if (ret) { if (ret) {
test_msg("Failed to free part of bitmap space %d\n", ret); test_msg("Failed to free part of bitmap space %d\n", ret);
return ret; return ret;
} }
/* Confirm that only those 2 ranges are marked as free. */ /* Confirm that only those 2 ranges are marked as free. */
if (!test_check_exists(cache, 128 * 1024 * 1024 + 128 * 1024, if (!test_check_exists(cache, SZ_128M + SZ_128K, SZ_128K)) {
128 * 1024)) {
test_msg("Free space range missing\n"); test_msg("Free space range missing\n");
return -ENOENT; return -ENOENT;
} }
if (!test_check_exists(cache, 128 * 1024 * 1024 - 768 * 1024, if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_256K)) {
256 * 1024)) {
test_msg("Free space range missing\n"); test_msg("Free space range missing\n");
return -ENOENT; return -ENOENT;
} }
@ -741,8 +721,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* Confirm that the bitmap range [0, 128Mb - 768Kb[ isn't marked * Confirm that the bitmap range [0, 128Mb - 768Kb[ isn't marked
* as free anymore. * as free anymore.
*/ */
if (test_check_exists(cache, 0, if (test_check_exists(cache, 0, SZ_128M - 768 * SZ_1K)) {
128 * 1024 * 1024 - 768 * 1024)) {
test_msg("Bitmap region not removed from space cache\n"); test_msg("Bitmap region not removed from space cache\n");
return -EINVAL; return -EINVAL;
} }
@ -751,8 +730,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* Confirm that the region [128Mb - 512Kb, 128Mb[, which is * Confirm that the region [128Mb - 512Kb, 128Mb[, which is
* covered by the bitmap, isn't marked as free. * covered by the bitmap, isn't marked as free.
*/ */
if (test_check_exists(cache, 128 * 1024 * 1024 - 512 * 1024, if (test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) {
512 * 1024)) {
test_msg("Invalid bitmap region marked as free\n"); test_msg("Invalid bitmap region marked as free\n");
return -EINVAL; return -EINVAL;
} }
@ -762,15 +740,13 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* lets make sure the free space cache marks it as free in the bitmap, * lets make sure the free space cache marks it as free in the bitmap,
* and doesn't insert a new extent entry to represent this region. * and doesn't insert a new extent entry to represent this region.
*/ */
ret = btrfs_add_free_space(cache, 128 * 1024 * 1024 - 512 * 1024, ret = btrfs_add_free_space(cache, SZ_128M - SZ_512K, SZ_512K);
512 * 1024);
if (ret) { if (ret) {
test_msg("Error adding free space: %d\n", ret); test_msg("Error adding free space: %d\n", ret);
return ret; return ret;
} }
/* Confirm the region is marked as free. */ /* Confirm the region is marked as free. */
if (!test_check_exists(cache, 128 * 1024 * 1024 - 512 * 1024, if (!test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) {
512 * 1024)) {
test_msg("Bitmap region not marked as free\n"); test_msg("Bitmap region not marked as free\n");
return -ENOENT; return -ENOENT;
} }
@ -789,7 +765,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* The goal is to test that the bitmap entry space stealing doesn't * The goal is to test that the bitmap entry space stealing doesn't
* steal this space region. * steal this space region.
*/ */
ret = btrfs_add_free_space(cache, 32 * 1024 * 1024, 8192); ret = btrfs_add_free_space(cache, SZ_32M, 8192);
if (ret) { if (ret) {
test_msg("Error adding free space: %d\n", ret); test_msg("Error adding free space: %d\n", ret);
return ret; return ret;
@ -800,13 +776,13 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* expand the range covered by the existing extent entry that represents * expand the range covered by the existing extent entry that represents
* the free space [128Mb + 128Kb, 128Mb + 256Kb[. * the free space [128Mb + 128Kb, 128Mb + 256Kb[.
*/ */
ret = btrfs_add_free_space(cache, 128 * 1024 * 1024, 128 * 1024); ret = btrfs_add_free_space(cache, SZ_128M, SZ_128K);
if (ret) { if (ret) {
test_msg("Error adding free space: %d\n", ret); test_msg("Error adding free space: %d\n", ret);
return ret; return ret;
} }
/* Confirm the region is marked as free. */ /* Confirm the region is marked as free. */
if (!test_check_exists(cache, 128 * 1024 * 1024, 128 * 1024)) { if (!test_check_exists(cache, SZ_128M, SZ_128K)) {
test_msg("Extent region not marked as free\n"); test_msg("Extent region not marked as free\n");
return -ENOENT; return -ENOENT;
} }
@ -834,21 +810,19 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
* that represents the 1Mb free space, and therefore we're able to * that represents the 1Mb free space, and therefore we're able to
* allocate the whole free space at once. * allocate the whole free space at once.
*/ */
if (!test_check_exists(cache, 128 * 1024 * 1024 - 768 * 1024, if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_1M)) {
1 * 1024 * 1024)) {
test_msg("Expected region not marked as free\n"); test_msg("Expected region not marked as free\n");
return -ENOENT; return -ENOENT;
} }
if (cache->free_space_ctl->free_space != (1 * 1024 * 1024 + 8192)) { if (cache->free_space_ctl->free_space != (SZ_1M + 8192)) {
test_msg("Cache free space is not 1Mb + 8Kb\n"); test_msg("Cache free space is not 1Mb + 8Kb\n");
return -EINVAL; return -EINVAL;
} }
offset = btrfs_find_space_for_alloc(cache, offset = btrfs_find_space_for_alloc(cache, 0, SZ_1M, 0,
0, 1 * 1024 * 1024, 0,
&max_extent_size); &max_extent_size);
if (offset != (128 * 1024 * 1024 - 768 * 1024)) { if (offset != (SZ_128M - 768 * SZ_1K)) {
test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n", test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n",
offset); offset);
return -EINVAL; return -EINVAL;
@ -867,7 +841,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache)
offset = btrfs_find_space_for_alloc(cache, offset = btrfs_find_space_for_alloc(cache,
0, 8192, 0, 0, 8192, 0,
&max_extent_size); &max_extent_size);
if (offset != (32 * 1024 * 1024)) { if (offset != SZ_32M) {
test_msg("Failed to allocate 8Kb from space cache, returned offset is: %llu\n", test_msg("Failed to allocate 8Kb from space cache, returned offset is: %llu\n",
offset); offset);
return -EINVAL; return -EINVAL;

2
fs/btrfs/tests/inode-tests.c
View File

@ -100,7 +100,7 @@ static void insert_inode_item_key(struct btrfs_root *root)
static void setup_file_extents(struct btrfs_root *root) static void setup_file_extents(struct btrfs_root *root)
{ {
int slot = 0; int slot = 0;
u64 disk_bytenr = 1 * 1024 * 1024; u64 disk_bytenr = SZ_1M;
u64 offset = 0; u64 offset = 0;
/* First we want a hole */ /* First we want a hole */

16
fs/btrfs/volumes.c
View File

@ -1406,7 +1406,7 @@ int find_free_dev_extent(struct btrfs_trans_handle *trans,
* we don't want to overwrite the superblock on the drive, * we don't want to overwrite the superblock on the drive,
* so we make sure to start at an offset of at least 1MB * so we make sure to start at an offset of at least 1MB
*/ */
search_start = max(root->fs_info->alloc_start, 1024ull * 1024); search_start = max_t(u64, root->fs_info->alloc_start, SZ_1M);
return find_free_dev_extent_start(trans->transaction, device, return find_free_dev_extent_start(trans->transaction, device,
num_bytes, search_start, start, len); num_bytes, search_start, start, len);
} }
@ -3405,7 +3405,7 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info)
list_for_each_entry(device, devices, dev_list) { list_for_each_entry(device, devices, dev_list) {
old_size = btrfs_device_get_total_bytes(device); old_size = btrfs_device_get_total_bytes(device);
size_to_free = div_factor(old_size, 1); size_to_free = div_factor(old_size, 1);
size_to_free = min(size_to_free, (u64)1 * 1024 * 1024); size_to_free = min_t(u64, size_to_free, SZ_1M);
if (!device->writeable || if (!device->writeable ||
btrfs_device_get_total_bytes(device) - btrfs_device_get_total_bytes(device) -
btrfs_device_get_bytes_used(device) > size_to_free || btrfs_device_get_bytes_used(device) > size_to_free ||
@ -4459,7 +4459,7 @@ static int btrfs_cmp_device_info(const void *a, const void *b)
static u32 find_raid56_stripe_len(u32 data_devices, u32 dev_stripe_target) static u32 find_raid56_stripe_len(u32 data_devices, u32 dev_stripe_target)
{ {
/* TODO allow them to set a preferred stripe size */ /* TODO allow them to set a preferred stripe size */
return 64 * 1024; return SZ_64K;
} }
static void check_raid56_incompat_flag(struct btrfs_fs_info *info, u64 type) static void check_raid56_incompat_flag(struct btrfs_fs_info *info, u64 type)
@ -4527,21 +4527,21 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
ncopies = btrfs_raid_array[index].ncopies; ncopies = btrfs_raid_array[index].ncopies;
if (type & BTRFS_BLOCK_GROUP_DATA) { if (type & BTRFS_BLOCK_GROUP_DATA) {
max_stripe_size = 1024 * 1024 * 1024; max_stripe_size = SZ_1G;
max_chunk_size = 10 * max_stripe_size; max_chunk_size = 10 * max_stripe_size;
if (!devs_max) if (!devs_max)
devs_max = BTRFS_MAX_DEVS(info->chunk_root); devs_max = BTRFS_MAX_DEVS(info->chunk_root);
} else if (type & BTRFS_BLOCK_GROUP_METADATA) { } else if (type & BTRFS_BLOCK_GROUP_METADATA) {
/* for larger filesystems, use larger metadata chunks */ /* for larger filesystems, use larger metadata chunks */
if (fs_devices->total_rw_bytes > 50ULL * 1024 * 1024 * 1024) if (fs_devices->total_rw_bytes > 50ULL * SZ_1G)
max_stripe_size = 1024 * 1024 * 1024; max_stripe_size = SZ_1G;
else else
max_stripe_size = 256 * 1024 * 1024; max_stripe_size = SZ_256M;
max_chunk_size = max_stripe_size; max_chunk_size = max_stripe_size;
if (!devs_max) if (!devs_max)
devs_max = BTRFS_MAX_DEVS(info->chunk_root); devs_max = BTRFS_MAX_DEVS(info->chunk_root);
} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) { } else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
max_stripe_size = 32 * 1024 * 1024; max_stripe_size = SZ_32M;
max_chunk_size = 2 * max_stripe_size; max_chunk_size = 2 * max_stripe_size;
if (!devs_max) if (!devs_max)
devs_max = BTRFS_MAX_DEVS_SYS_CHUNK; devs_max = BTRFS_MAX_DEVS_SYS_CHUNK;

2
fs/btrfs/volumes.h
View File

@ -26,7 +26,7 @@
extern struct mutex uuid_mutex; extern struct mutex uuid_mutex;
#define BTRFS_STRIPE_LEN (64 * 1024) #define BTRFS_STRIPE_LEN SZ_64K
struct buffer_head; struct buffer_head;
struct btrfs_pending_bios { struct btrfs_pending_bios {