2018-04-04 01:23:33 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2007-06-12 21:07:21 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
|
|
*/
|
|
|
|
|
2007-08-29 21:11:44 +08:00
|
|
|
#include <linux/blkdev.h>
|
2007-03-21 23:12:56 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/init.h>
|
2009-04-03 04:46:06 +08:00
|
|
|
#include <linux/seq_file.h>
|
2007-03-21 23:12:56 +08:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/backing-dev.h>
|
2007-08-29 21:11:44 +08:00
|
|
|
#include <linux/mount.h>
|
2007-03-29 23:56:46 +08:00
|
|
|
#include <linux/writeback.h>
|
2007-04-20 09:01:03 +08:00
|
|
|
#include <linux/statfs.h>
|
2007-06-09 03:33:54 +08:00
|
|
|
#include <linux/compat.h>
|
2007-08-29 21:11:44 +08:00
|
|
|
#include <linux/parser.h>
|
2007-12-18 09:14:04 +08:00
|
|
|
#include <linux/ctype.h>
|
2007-12-19 05:15:09 +08:00
|
|
|
#include <linux/namei.h>
|
2008-03-25 03:02:04 +08:00
|
|
|
#include <linux/miscdevice.h>
|
2009-01-16 05:51:03 +08:00
|
|
|
#include <linux/magic.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2011-05-27 00:01:56 +08:00
|
|
|
#include <linux/cleancache.h>
|
2011-11-30 23:45:38 +08:00
|
|
|
#include <linux/ratelimit.h>
|
btrfs: Remove custom crc32c init code
The custom crc32 init code was introduced in
14a958e678cd ("Btrfs: fix btrfs boot when compiled as built-in") to
enable using btrfs as a built-in. However, later as pointed out by
60efa5eb2e88 ("Btrfs: use late_initcall instead of module_init") this
wasn't enough and finally btrfs was switched to late_initcall which
comes after the generic crc32c implementation is initiliased. The
latter commit superseeded the former. Now that we don't have to
maintain our own code let's just remove it and switch to using the
generic implementation.
Despite touching a lot of files the patch is really simple. Here is the gist of
the changes:
1. Select LIBCRC32C rather than the low-level modules.
2. s/btrfs_crc32c/crc32c/g
3. replace hash.h with linux/crc32c.h
4. Move the btrfs namehash funcs to ctree.h and change the tree accordingly.
I've tested this with btrfs being both a module and a built-in and xfstest
doesn't complain.
Does seem to fix the longstanding problem of not automatically selectiong
the crc32c module when btrfs is used. Possibly there is a workaround in
dracut.
The modinfo confirms that now all the module dependencies are there:
before:
depends: zstd_compress,zstd_decompress,raid6_pq,xor,zlib_deflate
after:
depends: libcrc32c,zstd_compress,zstd_decompress,raid6_pq,xor,zlib_deflate
Signed-off-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ add more info to changelog from mails ]
Signed-off-by: David Sterba <dsterba@suse.com>
2018-01-08 17:45:05 +08:00
|
|
|
#include <linux/crc32c.h>
|
2013-01-29 14:04:50 +08:00
|
|
|
#include <linux/btrfs.h>
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
#include "delayed-inode.h"
|
2007-03-21 23:12:56 +08:00
|
|
|
#include "ctree.h"
|
2007-03-23 00:13:20 +08:00
|
|
|
#include "disk-io.h"
|
2007-03-23 22:01:08 +08:00
|
|
|
#include "transaction.h"
|
2007-04-02 22:50:19 +08:00
|
|
|
#include "btrfs_inode.h"
|
2007-05-25 01:35:57 +08:00
|
|
|
#include "print-tree.h"
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 19:47:46 +08:00
|
|
|
#include "props.h"
|
2007-11-17 00:45:54 +08:00
|
|
|
#include "xattr.h"
|
2008-03-25 03:02:07 +08:00
|
|
|
#include "volumes.h"
|
2008-07-21 04:31:56 +08:00
|
|
|
#include "export.h"
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-30 02:49:59 +08:00
|
|
|
#include "compression.h"
|
2012-06-06 02:13:12 +08:00
|
|
|
#include "rcu-string.h"
|
2012-11-06 20:15:27 +08:00
|
|
|
#include "dev-replace.h"
|
2013-03-15 21:47:08 +08:00
|
|
|
#include "free-space-cache.h"
|
2013-08-09 13:25:36 +08:00
|
|
|
#include "backref.h"
|
2019-06-19 04:09:16 +08:00
|
|
|
#include "space-info.h"
|
2019-08-01 23:34:41 +08:00
|
|
|
#include "sysfs.h"
|
2013-08-15 03:05:12 +08:00
|
|
|
#include "tests/btrfs-tests.h"
|
2019-06-21 03:37:44 +08:00
|
|
|
#include "block-group.h"
|
2019-12-14 08:22:14 +08:00
|
|
|
#include "discard.h"
|
2007-03-21 23:12:56 +08:00
|
|
|
|
2014-07-18 03:39:00 +08:00
|
|
|
#include "qgroup.h"
|
Btrfs: add initial tracepoint support for btrfs
Tracepoints can provide insight into why btrfs hits bugs and be greatly
helpful for debugging, e.g
dd-7822 [000] 2121.641088: btrfs_inode_request: root = 5(FS_TREE), gen = 4, ino = 256, blocks = 8, disk_i_size = 0, last_trans = 8, logged_trans = 0
dd-7822 [000] 2121.641100: btrfs_inode_new: root = 5(FS_TREE), gen = 8, ino = 257, blocks = 0, disk_i_size = 0, last_trans = 0, logged_trans = 0
btrfs-transacti-7804 [001] 2146.935420: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29368320 (orig_level = 0), cow_buf = 29388800 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.935473: btrfs_cow_block: root = 1(ROOT_TREE), refs = 2, orig_buf = 29364224 (orig_level = 0), cow_buf = 29392896 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.972221: btrfs_transaction_commit: root = 1(ROOT_TREE), gen = 8
flush-btrfs-2-7821 [001] 2155.824210: btrfs_chunk_alloc: root = 3(CHUNK_TREE), offset = 1103101952, size = 1073741824, num_stripes = 1, sub_stripes = 0, type = DATA
flush-btrfs-2-7821 [001] 2155.824241: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29388800 (orig_level = 0), cow_buf = 29396992 (cow_level = 0)
flush-btrfs-2-7821 [001] 2155.824255: btrfs_cow_block: root = 4(DEV_TREE), refs = 2, orig_buf = 29372416 (orig_level = 0), cow_buf = 29401088 (cow_level = 0)
flush-btrfs-2-7821 [000] 2155.824329: btrfs_cow_block: root = 3(CHUNK_TREE), refs = 2, orig_buf = 20971520 (orig_level = 0), cow_buf = 20975616 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898019: btrfs_cow_block: root = 5(FS_TREE), refs = 2, orig_buf = 29384704 (orig_level = 0), cow_buf = 29405184 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898043: btrfs_cow_block: root = 7(CSUM_TREE), refs = 2, orig_buf = 29376512 (orig_level = 0), cow_buf = 29409280 (cow_level = 0)
Here is what I have added:
1) ordere_extent:
btrfs_ordered_extent_add
btrfs_ordered_extent_remove
btrfs_ordered_extent_start
btrfs_ordered_extent_put
These provide critical information to understand how ordered_extents are
updated.
2) extent_map:
btrfs_get_extent
extent_map is used in both read and write cases, and it is useful for tracking
how btrfs specific IO is running.
3) writepage:
__extent_writepage
btrfs_writepage_end_io_hook
Pages are cirtical resourses and produce a lot of corner cases during writeback,
so it is valuable to know how page is written to disk.
4) inode:
btrfs_inode_new
btrfs_inode_request
btrfs_inode_evict
These can show where and when a inode is created, when a inode is evicted.
5) sync:
btrfs_sync_file
btrfs_sync_fs
These show sync arguments.
6) transaction:
btrfs_transaction_commit
In transaction based filesystem, it will be useful to know the generation and
who does commit.
7) back reference and cow:
btrfs_delayed_tree_ref
btrfs_delayed_data_ref
btrfs_delayed_ref_head
btrfs_cow_block
Btrfs natively supports back references, these tracepoints are helpful on
understanding btrfs's COW mechanism.
8) chunk:
btrfs_chunk_alloc
btrfs_chunk_free
Chunk is a link between physical offset and logical offset, and stands for space
infomation in btrfs, and these are helpful on tracing space things.
9) reserved_extent:
btrfs_reserved_extent_alloc
btrfs_reserved_extent_free
These can show how btrfs uses its space.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-24 19:18:59 +08:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/btrfs.h>
|
|
|
|
|
2009-09-22 08:01:09 +08:00
|
|
|
static const struct super_operations btrfs_super_ops;
|
2017-12-14 16:24:30 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Types for mounting the default subvolume and a subvolume explicitly
|
|
|
|
* requested by subvol=/path. That way the callchain is straightforward and we
|
|
|
|
* don't have to play tricks with the mount options and recursive calls to
|
|
|
|
* btrfs_mount.
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
*
|
|
|
|
* The new btrfs_root_fs_type also servers as a tag for the bdev_holder.
|
2017-12-14 16:24:30 +08:00
|
|
|
*/
|
2011-07-26 03:55:42 +08:00
|
|
|
static struct file_system_type btrfs_fs_type;
|
2017-12-14 16:24:30 +08:00
|
|
|
static struct file_system_type btrfs_root_fs_type;
|
2007-03-29 23:56:46 +08:00
|
|
|
|
btrfs: allow mounting btrfs subvolumes with different ro/rw options
Given the following /etc/fstab entries:
/dev/sda3 /mnt/foo btrfs subvol=foo,ro 0 0
/dev/sda3 /mnt/bar btrfs subvol=bar,rw 0 0
you can't issue:
$ mount /mnt/foo
$ mount /mnt/bar
You would have to do:
$ mount /mnt/foo
$ mount -o remount,rw /mnt/foo
$ mount --bind -o remount,ro /mnt/foo
$ mount /mnt/bar
or
$ mount /mnt/bar
$ mount --rw /mnt/foo
$ mount --bind -o remount,ro /mnt/foo
With this patch you can do
$ mount /mnt/foo
$ mount /mnt/bar
$ cat /proc/self/mountinfo
49 33 0:41 /foo /mnt/foo ro,relatime shared:36 - btrfs /dev/sda3 rw,ssd,space_cache
87 33 0:41 /bar /mnt/bar rw,relatime shared:74 - btrfs /dev/sda3 rw,ssd,space_cache
Signed-off-by: Chris Mason <clm@fb.com>
2013-11-19 18:36:05 +08:00
|
|
|
static int btrfs_remount(struct super_block *sb, int *flags, char *data);
|
|
|
|
|
2019-10-02 01:57:37 +08:00
|
|
|
const char * __attribute_const__ btrfs_decode_error(int errno)
|
2011-01-06 19:30:25 +08:00
|
|
|
{
|
2013-03-12 22:46:08 +08:00
|
|
|
char *errstr = "unknown";
|
2011-01-06 19:30:25 +08:00
|
|
|
|
|
|
|
switch (errno) {
|
2020-04-28 23:10:27 +08:00
|
|
|
case -ENOENT: /* -2 */
|
|
|
|
errstr = "No such entry";
|
|
|
|
break;
|
|
|
|
case -EIO: /* -5 */
|
2011-01-06 19:30:25 +08:00
|
|
|
errstr = "IO failure";
|
|
|
|
break;
|
2020-04-28 23:10:27 +08:00
|
|
|
case -ENOMEM: /* -12*/
|
2011-01-06 19:30:25 +08:00
|
|
|
errstr = "Out of memory";
|
|
|
|
break;
|
2020-04-28 23:10:27 +08:00
|
|
|
case -EEXIST: /* -17 */
|
2011-10-04 11:22:31 +08:00
|
|
|
errstr = "Object already exists";
|
|
|
|
break;
|
2020-04-28 23:10:27 +08:00
|
|
|
case -ENOSPC: /* -28 */
|
2013-03-20 22:29:47 +08:00
|
|
|
errstr = "No space left";
|
|
|
|
break;
|
2020-04-28 23:10:27 +08:00
|
|
|
case -EROFS: /* -30 */
|
|
|
|
errstr = "Readonly filesystem";
|
2013-03-20 22:29:47 +08:00
|
|
|
break;
|
2020-04-28 23:10:29 +08:00
|
|
|
case -EOPNOTSUPP: /* -95 */
|
|
|
|
errstr = "Operation not supported";
|
|
|
|
break;
|
|
|
|
case -EUCLEAN: /* -117 */
|
|
|
|
errstr = "Filesystem corrupted";
|
|
|
|
break;
|
|
|
|
case -EDQUOT: /* -122 */
|
|
|
|
errstr = "Quota exceeded";
|
|
|
|
break;
|
2011-01-06 19:30:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return errstr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-03-16 16:43:06 +08:00
|
|
|
* __btrfs_handle_fs_error decodes expected errors from the caller and
|
2018-11-28 19:05:13 +08:00
|
|
|
* invokes the appropriate error response.
|
2011-01-06 19:30:25 +08:00
|
|
|
*/
|
2015-04-25 01:11:57 +08:00
|
|
|
__cold
|
2016-03-16 16:43:06 +08:00
|
|
|
void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
|
2012-03-01 21:57:30 +08:00
|
|
|
unsigned int line, int errno, const char *fmt, ...)
|
2011-01-06 19:30:25 +08:00
|
|
|
{
|
|
|
|
struct super_block *sb = fs_info->sb;
|
2015-08-14 18:32:52 +08:00
|
|
|
#ifdef CONFIG_PRINTK
|
2011-01-06 19:30:25 +08:00
|
|
|
const char *errstr;
|
2015-08-14 18:32:52 +08:00
|
|
|
#endif
|
2011-01-06 19:30:25 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Special case: if the error is EROFS, and we're already
|
2017-11-28 05:05:09 +08:00
|
|
|
* under SB_RDONLY, then it is safe here.
|
2011-01-06 19:30:25 +08:00
|
|
|
*/
|
2017-07-17 15:45:34 +08:00
|
|
|
if (errno == -EROFS && sb_rdonly(sb))
|
2012-03-01 21:57:30 +08:00
|
|
|
return;
|
|
|
|
|
2015-08-14 18:32:52 +08:00
|
|
|
#ifdef CONFIG_PRINTK
|
2013-03-12 22:46:08 +08:00
|
|
|
errstr = btrfs_decode_error(errno);
|
2012-03-01 21:57:30 +08:00
|
|
|
if (fmt) {
|
2013-01-31 08:54:58 +08:00
|
|
|
struct va_format vaf;
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
vaf.fmt = fmt;
|
|
|
|
vaf.va = &args;
|
2012-03-01 21:57:30 +08:00
|
|
|
|
2016-09-20 22:05:01 +08:00
|
|
|
pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s (%pV)\n",
|
2013-03-12 22:46:08 +08:00
|
|
|
sb->s_id, function, line, errno, errstr, &vaf);
|
2013-01-31 08:54:58 +08:00
|
|
|
va_end(args);
|
2012-03-01 21:57:30 +08:00
|
|
|
} else {
|
2016-09-20 22:05:01 +08:00
|
|
|
pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s\n",
|
2013-03-12 22:46:08 +08:00
|
|
|
sb->s_id, function, line, errno, errstr);
|
2012-03-01 21:57:30 +08:00
|
|
|
}
|
2015-08-14 18:32:52 +08:00
|
|
|
#endif
|
2011-01-06 19:30:25 +08:00
|
|
|
|
2016-03-17 10:38:57 +08:00
|
|
|
/*
|
|
|
|
* Today we only save the error info to memory. Long term we'll
|
|
|
|
* also send it down to the disk
|
|
|
|
*/
|
|
|
|
set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
|
|
|
|
|
2012-03-01 21:57:30 +08:00
|
|
|
/* Don't go through full error handling during mount */
|
2018-01-04 18:01:55 +08:00
|
|
|
if (!(sb->s_flags & SB_BORN))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (sb_rdonly(sb))
|
|
|
|
return;
|
|
|
|
|
2019-12-14 08:22:14 +08:00
|
|
|
btrfs_discard_stop(fs_info);
|
|
|
|
|
2018-01-04 18:01:55 +08:00
|
|
|
/* btrfs handle error by forcing the filesystem readonly */
|
|
|
|
sb->s_flags |= SB_RDONLY;
|
|
|
|
btrfs_info(fs_info, "forced readonly");
|
|
|
|
/*
|
|
|
|
* Note that a running device replace operation is not canceled here
|
|
|
|
* although there is no way to update the progress. It would add the
|
|
|
|
* risk of a deadlock, therefore the canceling is omitted. The only
|
|
|
|
* penalty is that some I/O remains active until the procedure
|
2018-11-28 19:05:13 +08:00
|
|
|
* completes. The next time when the filesystem is mounted writable
|
2018-01-04 18:01:55 +08:00
|
|
|
* again, the device replace operation continues.
|
|
|
|
*/
|
2012-03-01 21:57:30 +08:00
|
|
|
}
|
2011-01-06 19:30:25 +08:00
|
|
|
|
2015-08-14 18:32:52 +08:00
|
|
|
#ifdef CONFIG_PRINTK
|
2012-07-31 05:40:13 +08:00
|
|
|
static const char * const logtypes[] = {
|
2012-03-01 21:57:30 +08:00
|
|
|
"emergency",
|
|
|
|
"alert",
|
|
|
|
"critical",
|
|
|
|
"error",
|
|
|
|
"warning",
|
|
|
|
"notice",
|
|
|
|
"info",
|
|
|
|
"debug",
|
|
|
|
};
|
|
|
|
|
2016-07-13 21:19:15 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Use one ratelimit state per log level so that a flood of less important
|
|
|
|
* messages doesn't cause more important ones to be dropped.
|
|
|
|
*/
|
|
|
|
static struct ratelimit_state printk_limits[] = {
|
|
|
|
RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
|
|
|
|
RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
|
|
|
|
RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
|
|
|
|
RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
|
|
|
|
RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
|
|
|
|
RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
|
|
|
|
RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
|
|
|
|
RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
|
|
|
|
};
|
|
|
|
|
2019-10-02 01:57:35 +08:00
|
|
|
void __cold btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
|
2012-03-01 21:57:30 +08:00
|
|
|
{
|
2016-12-15 07:04:01 +08:00
|
|
|
char lvl[PRINTK_MAX_SINGLE_HEADER_LEN + 1] = "\0";
|
2012-03-01 21:57:30 +08:00
|
|
|
struct va_format vaf;
|
|
|
|
va_list args;
|
2012-07-31 05:40:13 +08:00
|
|
|
int kern_level;
|
2016-12-15 07:04:01 +08:00
|
|
|
const char *type = logtypes[4];
|
|
|
|
struct ratelimit_state *ratelimit = &printk_limits[4];
|
2012-03-01 21:57:30 +08:00
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
|
2016-12-13 08:45:50 +08:00
|
|
|
while ((kern_level = printk_get_level(fmt)) != 0) {
|
2012-07-31 05:40:13 +08:00
|
|
|
size_t size = printk_skip_level(fmt) - fmt;
|
2016-12-13 08:45:50 +08:00
|
|
|
|
|
|
|
if (kern_level >= '0' && kern_level <= '7') {
|
|
|
|
memcpy(lvl, fmt, size);
|
|
|
|
lvl[size] = '\0';
|
|
|
|
type = logtypes[kern_level - '0'];
|
|
|
|
ratelimit = &printk_limits[kern_level - '0'];
|
|
|
|
}
|
2012-07-31 05:40:13 +08:00
|
|
|
fmt += size;
|
2016-12-13 08:45:50 +08:00
|
|
|
}
|
|
|
|
|
2012-03-01 21:57:30 +08:00
|
|
|
vaf.fmt = fmt;
|
|
|
|
vaf.va = &args;
|
2012-07-31 05:40:13 +08:00
|
|
|
|
2016-07-13 21:19:15 +08:00
|
|
|
if (__ratelimit(ratelimit))
|
2017-09-11 23:15:28 +08:00
|
|
|
printk("%sBTRFS %s (device %s): %pV\n", lvl, type,
|
|
|
|
fs_info ? fs_info->sb->s_id : "<unknown>", &vaf);
|
2012-07-31 05:40:13 +08:00
|
|
|
|
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
#endif
|
2011-01-06 19:30:25 +08:00
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
/*
|
|
|
|
* We only mark the transaction aborted and then set the file system read-only.
|
|
|
|
* This will prevent new transactions from starting or trying to join this
|
|
|
|
* one.
|
|
|
|
*
|
|
|
|
* This means that error recovery at the call site is limited to freeing
|
|
|
|
* any local memory allocations and passing the error code up without
|
|
|
|
* further cleanup. The transaction should complete as it normally would
|
|
|
|
* in the call path but will return -EIO.
|
|
|
|
*
|
|
|
|
* We'll complete the cleanup in btrfs_end_transaction and
|
|
|
|
* btrfs_commit_transaction.
|
|
|
|
*/
|
2015-04-25 01:11:57 +08:00
|
|
|
__cold
|
2012-03-02 00:24:58 +08:00
|
|
|
void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
|
2016-06-11 06:19:25 +08:00
|
|
|
const char *function,
|
2012-03-02 00:24:58 +08:00
|
|
|
unsigned int line, int errno)
|
|
|
|
{
|
2016-06-11 06:19:25 +08:00
|
|
|
struct btrfs_fs_info *fs_info = trans->fs_info;
|
|
|
|
|
2020-02-06 00:34:34 +08:00
|
|
|
WRITE_ONCE(trans->aborted, errno);
|
2012-03-02 00:24:58 +08:00
|
|
|
/* Nothing used. The other threads that have joined this
|
|
|
|
* transaction may be able to continue. */
|
2016-06-08 12:36:38 +08:00
|
|
|
if (!trans->dirty && list_empty(&trans->new_bgs)) {
|
2012-09-06 18:04:44 +08:00
|
|
|
const char *errstr;
|
|
|
|
|
2013-03-12 22:46:08 +08:00
|
|
|
errstr = btrfs_decode_error(errno);
|
2016-06-11 06:19:25 +08:00
|
|
|
btrfs_warn(fs_info,
|
2013-03-20 06:41:23 +08:00
|
|
|
"%s:%d: Aborting unused transaction(%s).",
|
|
|
|
function, line, errstr);
|
2011-01-06 19:30:25 +08:00
|
|
|
return;
|
2012-03-02 00:24:58 +08:00
|
|
|
}
|
2016-12-15 21:38:16 +08:00
|
|
|
WRITE_ONCE(trans->transaction->aborted, errno);
|
2013-06-11 04:47:23 +08:00
|
|
|
/* Wake up anybody who may be waiting on this transaction */
|
2016-06-11 06:19:25 +08:00
|
|
|
wake_up(&fs_info->transaction_wait);
|
|
|
|
wake_up(&fs_info->transaction_blocked_wait);
|
|
|
|
__btrfs_handle_fs_error(fs_info, function, line, errno, NULL);
|
2012-03-02 00:24:58 +08:00
|
|
|
}
|
2011-10-04 11:22:31 +08:00
|
|
|
/*
|
|
|
|
* __btrfs_panic decodes unexpected, fatal errors from the caller,
|
|
|
|
* issues an alert, and either panics or BUGs, depending on mount options.
|
|
|
|
*/
|
2015-04-25 01:11:57 +08:00
|
|
|
__cold
|
2011-10-04 11:22:31 +08:00
|
|
|
void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
|
|
|
|
unsigned int line, int errno, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
char *s_id = "<unknown>";
|
|
|
|
const char *errstr;
|
|
|
|
struct va_format vaf = { .fmt = fmt };
|
|
|
|
va_list args;
|
2011-01-06 19:30:25 +08:00
|
|
|
|
2011-10-04 11:22:31 +08:00
|
|
|
if (fs_info)
|
|
|
|
s_id = fs_info->sb->s_id;
|
2011-01-06 19:30:25 +08:00
|
|
|
|
2011-10-04 11:22:31 +08:00
|
|
|
va_start(args, fmt);
|
|
|
|
vaf.va = &args;
|
|
|
|
|
2013-03-12 22:46:08 +08:00
|
|
|
errstr = btrfs_decode_error(errno);
|
2017-09-12 19:08:08 +08:00
|
|
|
if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR)))
|
2013-03-12 22:46:08 +08:00
|
|
|
panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
|
|
|
|
s_id, function, line, &vaf, errno, errstr);
|
2011-10-04 11:22:31 +08:00
|
|
|
|
2013-12-21 00:37:06 +08:00
|
|
|
btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
|
|
|
|
function, line, &vaf, errno, errstr);
|
2011-10-04 11:22:31 +08:00
|
|
|
va_end(args);
|
|
|
|
/* Caller calls BUG() */
|
2011-01-06 19:30:25 +08:00
|
|
|
}
|
|
|
|
|
2009-01-06 10:25:51 +08:00
|
|
|
static void btrfs_put_super(struct super_block *sb)
|
2007-04-18 01:26:50 +08:00
|
|
|
{
|
2016-06-22 09:16:51 +08:00
|
|
|
close_ctree(btrfs_sb(sb));
|
2007-03-29 23:56:46 +08:00
|
|
|
}
|
|
|
|
|
2007-08-29 21:11:44 +08:00
|
|
|
enum {
|
2018-03-09 21:37:01 +08:00
|
|
|
Opt_acl, Opt_noacl,
|
|
|
|
Opt_clear_cache,
|
|
|
|
Opt_commit_interval,
|
|
|
|
Opt_compress,
|
|
|
|
Opt_compress_force,
|
|
|
|
Opt_compress_force_type,
|
|
|
|
Opt_compress_type,
|
|
|
|
Opt_degraded,
|
|
|
|
Opt_device,
|
|
|
|
Opt_fatal_errors,
|
|
|
|
Opt_flushoncommit, Opt_noflushoncommit,
|
|
|
|
Opt_inode_cache, Opt_noinode_cache,
|
|
|
|
Opt_max_inline,
|
|
|
|
Opt_barrier, Opt_nobarrier,
|
|
|
|
Opt_datacow, Opt_nodatacow,
|
|
|
|
Opt_datasum, Opt_nodatasum,
|
|
|
|
Opt_defrag, Opt_nodefrag,
|
|
|
|
Opt_discard, Opt_nodiscard,
|
2019-12-14 08:22:14 +08:00
|
|
|
Opt_discard_mode,
|
2018-03-09 21:37:01 +08:00
|
|
|
Opt_norecovery,
|
|
|
|
Opt_ratio,
|
|
|
|
Opt_rescan_uuid_tree,
|
|
|
|
Opt_skip_balance,
|
|
|
|
Opt_space_cache, Opt_no_space_cache,
|
|
|
|
Opt_space_cache_version,
|
|
|
|
Opt_ssd, Opt_nossd,
|
|
|
|
Opt_ssd_spread, Opt_nossd_spread,
|
|
|
|
Opt_subvol,
|
2018-05-22 08:07:19 +08:00
|
|
|
Opt_subvol_empty,
|
2018-03-09 21:37:01 +08:00
|
|
|
Opt_subvolid,
|
|
|
|
Opt_thread_pool,
|
|
|
|
Opt_treelog, Opt_notreelog,
|
|
|
|
Opt_user_subvol_rm_allowed,
|
|
|
|
|
2020-06-04 15:18:06 +08:00
|
|
|
/* Rescue options */
|
|
|
|
Opt_rescue,
|
|
|
|
Opt_usebackuproot,
|
|
|
|
Opt_nologreplay,
|
|
|
|
|
2018-03-09 21:37:01 +08:00
|
|
|
/* Deprecated options */
|
|
|
|
Opt_recovery,
|
|
|
|
|
|
|
|
/* Debugging options */
|
|
|
|
Opt_check_integrity,
|
2015-09-30 11:50:38 +08:00
|
|
|
Opt_check_integrity_including_extent_data,
|
2018-03-09 21:37:01 +08:00
|
|
|
Opt_check_integrity_print_mask,
|
|
|
|
Opt_enospc_debug, Opt_noenospc_debug,
|
2015-09-24 02:54:14 +08:00
|
|
|
#ifdef CONFIG_BTRFS_DEBUG
|
|
|
|
Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all,
|
2017-09-30 03:43:48 +08:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_BTRFS_FS_REF_VERIFY
|
|
|
|
Opt_ref_verify,
|
2015-09-24 02:54:14 +08:00
|
|
|
#endif
|
2012-01-17 04:04:48 +08:00
|
|
|
Opt_err,
|
2007-08-29 21:11:44 +08:00
|
|
|
};
|
|
|
|
|
2015-11-19 18:42:31 +08:00
|
|
|
static const match_table_t tokens = {
|
2018-03-09 21:37:01 +08:00
|
|
|
{Opt_acl, "acl"},
|
|
|
|
{Opt_noacl, "noacl"},
|
|
|
|
{Opt_clear_cache, "clear_cache"},
|
|
|
|
{Opt_commit_interval, "commit=%u"},
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-30 02:49:59 +08:00
|
|
|
{Opt_compress, "compress"},
|
2010-12-17 14:21:50 +08:00
|
|
|
{Opt_compress_type, "compress=%s"},
|
2010-01-29 05:18:15 +08:00
|
|
|
{Opt_compress_force, "compress-force"},
|
2010-12-17 14:21:50 +08:00
|
|
|
{Opt_compress_force_type, "compress-force=%s"},
|
2018-03-09 21:37:01 +08:00
|
|
|
{Opt_degraded, "degraded"},
|
|
|
|
{Opt_device, "device=%s"},
|
|
|
|
{Opt_fatal_errors, "fatal_errors=%s"},
|
2009-04-03 04:59:01 +08:00
|
|
|
{Opt_flushoncommit, "flushoncommit"},
|
2014-01-06 09:58:29 +08:00
|
|
|
{Opt_noflushoncommit, "noflushoncommit"},
|
2018-03-09 21:37:01 +08:00
|
|
|
{Opt_inode_cache, "inode_cache"},
|
|
|
|
{Opt_noinode_cache, "noinode_cache"},
|
|
|
|
{Opt_max_inline, "max_inline=%s"},
|
|
|
|
{Opt_barrier, "barrier"},
|
|
|
|
{Opt_nobarrier, "nobarrier"},
|
|
|
|
{Opt_datacow, "datacow"},
|
|
|
|
{Opt_nodatacow, "nodatacow"},
|
|
|
|
{Opt_datasum, "datasum"},
|
|
|
|
{Opt_nodatasum, "nodatasum"},
|
|
|
|
{Opt_defrag, "autodefrag"},
|
|
|
|
{Opt_nodefrag, "noautodefrag"},
|
2009-10-14 21:24:59 +08:00
|
|
|
{Opt_discard, "discard"},
|
2019-12-14 08:22:14 +08:00
|
|
|
{Opt_discard_mode, "discard=%s"},
|
2014-01-06 09:58:27 +08:00
|
|
|
{Opt_nodiscard, "nodiscard"},
|
2018-03-09 21:37:01 +08:00
|
|
|
{Opt_norecovery, "norecovery"},
|
|
|
|
{Opt_ratio, "metadata_ratio=%u"},
|
|
|
|
{Opt_rescan_uuid_tree, "rescan_uuid_tree"},
|
|
|
|
{Opt_skip_balance, "skip_balance"},
|
2010-06-22 02:48:16 +08:00
|
|
|
{Opt_space_cache, "space_cache"},
|
2011-11-11 23:14:57 +08:00
|
|
|
{Opt_no_space_cache, "nospace_cache"},
|
2018-03-09 21:37:01 +08:00
|
|
|
{Opt_space_cache_version, "space_cache=%s"},
|
|
|
|
{Opt_ssd, "ssd"},
|
|
|
|
{Opt_nossd, "nossd"},
|
|
|
|
{Opt_ssd_spread, "ssd_spread"},
|
|
|
|
{Opt_nossd_spread, "nossd_spread"},
|
|
|
|
{Opt_subvol, "subvol=%s"},
|
2018-05-22 08:07:19 +08:00
|
|
|
{Opt_subvol_empty, "subvol="},
|
2018-03-09 21:37:01 +08:00
|
|
|
{Opt_subvolid, "subvolid=%s"},
|
|
|
|
{Opt_thread_pool, "thread_pool=%u"},
|
|
|
|
{Opt_treelog, "treelog"},
|
|
|
|
{Opt_notreelog, "notreelog"},
|
|
|
|
{Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
|
|
|
|
|
2020-06-04 15:18:06 +08:00
|
|
|
/* Rescue options */
|
|
|
|
{Opt_rescue, "rescue=%s"},
|
|
|
|
/* Deprecated, with alias rescue=nologreplay */
|
|
|
|
{Opt_nologreplay, "nologreplay"},
|
|
|
|
/* Deprecated, with alias rescue=usebackuproot */
|
|
|
|
{Opt_usebackuproot, "usebackuproot"},
|
|
|
|
|
2018-03-09 21:37:01 +08:00
|
|
|
/* Deprecated options */
|
|
|
|
{Opt_recovery, "recovery"},
|
|
|
|
|
|
|
|
/* Debugging options */
|
2011-11-09 20:44:05 +08:00
|
|
|
{Opt_check_integrity, "check_int"},
|
|
|
|
{Opt_check_integrity_including_extent_data, "check_int_data"},
|
2018-02-13 17:50:45 +08:00
|
|
|
{Opt_check_integrity_print_mask, "check_int_print_mask=%u"},
|
2018-03-09 21:37:01 +08:00
|
|
|
{Opt_enospc_debug, "enospc_debug"},
|
|
|
|
{Opt_noenospc_debug, "noenospc_debug"},
|
2015-09-24 02:54:14 +08:00
|
|
|
#ifdef CONFIG_BTRFS_DEBUG
|
|
|
|
{Opt_fragment_data, "fragment=data"},
|
|
|
|
{Opt_fragment_metadata, "fragment=metadata"},
|
|
|
|
{Opt_fragment_all, "fragment=all"},
|
2017-09-30 03:43:48 +08:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_BTRFS_FS_REF_VERIFY
|
|
|
|
{Opt_ref_verify, "ref_verify"},
|
2015-09-24 02:54:14 +08:00
|
|
|
#endif
|
2008-07-25 00:16:36 +08:00
|
|
|
{Opt_err, NULL},
|
2007-08-29 21:11:44 +08:00
|
|
|
};
|
|
|
|
|
2020-06-04 15:18:06 +08:00
|
|
|
static const match_table_t rescue_tokens = {
|
|
|
|
{Opt_usebackuproot, "usebackuproot"},
|
|
|
|
{Opt_nologreplay, "nologreplay"},
|
|
|
|
{Opt_err, NULL},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int parse_rescue_options(struct btrfs_fs_info *info, const char *options)
|
|
|
|
{
|
|
|
|
char *opts;
|
|
|
|
char *orig;
|
|
|
|
char *p;
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
opts = kstrdup(options, GFP_KERNEL);
|
|
|
|
if (!opts)
|
|
|
|
return -ENOMEM;
|
|
|
|
orig = opts;
|
|
|
|
|
|
|
|
while ((p = strsep(&opts, ":")) != NULL) {
|
|
|
|
int token;
|
|
|
|
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
token = match_token(p, rescue_tokens, args);
|
|
|
|
switch (token){
|
|
|
|
case Opt_usebackuproot:
|
|
|
|
btrfs_info(info,
|
|
|
|
"trying to use backup root at mount time");
|
|
|
|
btrfs_set_opt(info->mount_opt, USEBACKUPROOT);
|
|
|
|
break;
|
|
|
|
case Opt_nologreplay:
|
|
|
|
btrfs_set_and_info(info, NOLOGREPLAY,
|
|
|
|
"disabling log replay at mount time");
|
|
|
|
break;
|
|
|
|
case Opt_err:
|
|
|
|
btrfs_info(info, "unrecognized rescue option '%s'", p);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
kfree(orig);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-06-10 22:40:29 +08:00
|
|
|
/*
|
|
|
|
* Regular mount options parser. Everything that is needed only when
|
|
|
|
* reading in a new superblock is parsed here.
|
2012-03-02 00:24:58 +08:00
|
|
|
* XXX JDM: This needs to be cleaned up for remount.
|
2008-06-10 22:40:29 +08:00
|
|
|
*/
|
2016-06-23 06:54:24 +08:00
|
|
|
int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
|
2016-01-19 10:23:03 +08:00
|
|
|
unsigned long new_flags)
|
2007-08-29 21:11:44 +08:00
|
|
|
{
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
2017-12-14 16:28:00 +08:00
|
|
|
char *p, *num;
|
2011-10-04 02:07:49 +08:00
|
|
|
u64 cache_gen;
|
2008-06-12 09:47:56 +08:00
|
|
|
int intarg;
|
2009-11-07 14:19:16 +08:00
|
|
|
int ret = 0;
|
2010-12-17 14:21:50 +08:00
|
|
|
char *compress_type;
|
|
|
|
bool compress_force = false;
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
enum btrfs_compression_type saved_compress_type;
|
|
|
|
bool saved_compress_force;
|
|
|
|
int no_compress = 0;
|
2007-12-15 04:30:32 +08:00
|
|
|
|
2016-06-23 06:54:23 +08:00
|
|
|
cache_gen = btrfs_super_cache_generation(info->super_copy);
|
|
|
|
if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
|
2015-09-30 11:50:38 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, FREE_SPACE_TREE);
|
|
|
|
else if (cache_gen)
|
2011-10-04 02:07:49 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, SPACE_CACHE);
|
|
|
|
|
2016-01-19 10:23:03 +08:00
|
|
|
/*
|
|
|
|
* Even the options are empty, we still need to do extra check
|
|
|
|
* against new flags
|
|
|
|
*/
|
2007-08-29 21:11:44 +08:00
|
|
|
if (!options)
|
2016-01-19 10:23:03 +08:00
|
|
|
goto check;
|
2007-08-29 21:11:44 +08:00
|
|
|
|
2008-06-10 22:40:29 +08:00
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
2007-08-29 21:11:44 +08:00
|
|
|
int token;
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
token = match_token(p, tokens, args);
|
|
|
|
switch (token) {
|
2008-05-14 01:46:40 +08:00
|
|
|
case Opt_degraded:
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "allowing degraded mounts");
|
2008-06-10 22:40:29 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, DEGRADED);
|
2008-05-14 01:46:40 +08:00
|
|
|
break;
|
2007-08-29 21:11:44 +08:00
|
|
|
case Opt_subvol:
|
2018-05-22 08:07:19 +08:00
|
|
|
case Opt_subvol_empty:
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
case Opt_subvolid:
|
2008-06-10 22:40:46 +08:00
|
|
|
case Opt_device:
|
2008-06-10 22:40:29 +08:00
|
|
|
/*
|
2018-07-16 22:18:07 +08:00
|
|
|
* These are parsed by btrfs_parse_subvol_options or
|
|
|
|
* btrfs_parse_device_options and can be ignored here.
|
2008-06-10 22:40:29 +08:00
|
|
|
*/
|
2007-12-15 04:30:32 +08:00
|
|
|
break;
|
|
|
|
case Opt_nodatasum:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, NODATASUM,
|
2014-01-13 13:36:07 +08:00
|
|
|
"setting nodatasum");
|
2007-12-18 09:14:01 +08:00
|
|
|
break;
|
2014-01-06 09:58:32 +08:00
|
|
|
case Opt_datasum:
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, NODATASUM)) {
|
|
|
|
if (btrfs_test_opt(info, NODATACOW))
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info,
|
2016-09-20 22:05:00 +08:00
|
|
|
"setting datasum, datacow enabled");
|
2014-01-13 13:36:07 +08:00
|
|
|
else
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "setting datasum");
|
2014-01-13 13:36:07 +08:00
|
|
|
}
|
2014-01-06 09:58:32 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt, NODATACOW);
|
|
|
|
btrfs_clear_opt(info->mount_opt, NODATASUM);
|
|
|
|
break;
|
2007-12-18 09:14:01 +08:00
|
|
|
case Opt_nodatacow:
|
2016-06-10 09:38:35 +08:00
|
|
|
if (!btrfs_test_opt(info, NODATACOW)) {
|
|
|
|
if (!btrfs_test_opt(info, COMPRESS) ||
|
|
|
|
!btrfs_test_opt(info, FORCE_COMPRESS)) {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info,
|
2014-01-13 13:36:07 +08:00
|
|
|
"setting nodatacow, compression disabled");
|
|
|
|
} else {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "setting nodatacow");
|
2014-01-13 13:36:07 +08:00
|
|
|
}
|
2012-09-20 22:42:11 +08:00
|
|
|
}
|
|
|
|
btrfs_clear_opt(info->mount_opt, COMPRESS);
|
|
|
|
btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
|
2008-06-10 22:40:29 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, NODATACOW);
|
|
|
|
btrfs_set_opt(info->mount_opt, NODATASUM);
|
2007-08-29 21:11:44 +08:00
|
|
|
break;
|
2014-01-06 09:58:31 +08:00
|
|
|
case Opt_datacow:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_clear_and_info(info, NODATACOW,
|
2014-01-13 13:36:07 +08:00
|
|
|
"setting datacow");
|
2014-01-06 09:58:31 +08:00
|
|
|
break;
|
2010-01-29 05:18:15 +08:00
|
|
|
case Opt_compress_force:
|
2010-12-17 14:21:50 +08:00
|
|
|
case Opt_compress_force_type:
|
|
|
|
compress_force = true;
|
2020-06-17 02:54:29 +08:00
|
|
|
fallthrough;
|
2010-12-17 14:21:50 +08:00
|
|
|
case Opt_compress:
|
|
|
|
case Opt_compress_type:
|
2016-06-10 09:38:35 +08:00
|
|
|
saved_compress_type = btrfs_test_opt(info,
|
|
|
|
COMPRESS) ?
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
info->compress_type : BTRFS_COMPRESS_NONE;
|
|
|
|
saved_compress_force =
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_test_opt(info, FORCE_COMPRESS);
|
2010-12-17 14:21:50 +08:00
|
|
|
if (token == Opt_compress ||
|
|
|
|
token == Opt_compress_force ||
|
2017-07-18 00:11:10 +08:00
|
|
|
strncmp(args[0].from, "zlib", 4) == 0) {
|
2010-12-17 14:21:50 +08:00
|
|
|
compress_type = "zlib";
|
2017-11-06 10:43:18 +08:00
|
|
|
|
2010-12-17 14:21:50 +08:00
|
|
|
info->compress_type = BTRFS_COMPRESS_ZLIB;
|
2017-11-06 10:43:18 +08:00
|
|
|
info->compress_level = BTRFS_ZLIB_DEFAULT_LEVEL;
|
|
|
|
/*
|
|
|
|
* args[0] contains uninitialized data since
|
|
|
|
* for these tokens we don't expect any
|
|
|
|
* parameter.
|
|
|
|
*/
|
|
|
|
if (token != Opt_compress &&
|
|
|
|
token != Opt_compress_force)
|
|
|
|
info->compress_level =
|
2019-02-05 04:20:05 +08:00
|
|
|
btrfs_compress_str2level(
|
|
|
|
BTRFS_COMPRESS_ZLIB,
|
|
|
|
args[0].from + 4);
|
2012-04-16 21:27:51 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, COMPRESS);
|
2012-09-20 22:42:11 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt, NODATACOW);
|
|
|
|
btrfs_clear_opt(info->mount_opt, NODATASUM);
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
no_compress = 0;
|
2017-07-18 00:11:10 +08:00
|
|
|
} else if (strncmp(args[0].from, "lzo", 3) == 0) {
|
2010-10-25 15:12:26 +08:00
|
|
|
compress_type = "lzo";
|
|
|
|
info->compress_type = BTRFS_COMPRESS_LZO;
|
2012-04-16 21:27:51 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, COMPRESS);
|
2012-09-20 22:42:11 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt, NODATACOW);
|
|
|
|
btrfs_clear_opt(info->mount_opt, NODATASUM);
|
2012-07-25 01:58:43 +08:00
|
|
|
btrfs_set_fs_incompat(info, COMPRESS_LZO);
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
no_compress = 0;
|
2019-02-05 04:20:08 +08:00
|
|
|
} else if (strncmp(args[0].from, "zstd", 4) == 0) {
|
btrfs: Add zstd support
Add zstd compression and decompression support to BtrFS. zstd at its
fastest level compresses almost as well as zlib, while offering much
faster compression and decompression, approaching lzo speeds.
I benchmarked btrfs with zstd compression against no compression, lzo
compression, and zlib compression. I benchmarked two scenarios. Copying
a set of files to btrfs, and then reading the files. Copying a tarball
to btrfs, extracting it to btrfs, and then reading the extracted files.
After every operation, I call `sync` and include the sync time.
Between every pair of operations I unmount and remount the filesystem
to avoid caching. The benchmark files can be found in the upstream
zstd source repository under
`contrib/linux-kernel/{btrfs-benchmark.sh,btrfs-extract-benchmark.sh}`
[1] [2].
I ran the benchmarks on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.
The VM is running on a MacBook Pro with a 3.1 GHz Intel Core i7 processor,
16 GB of RAM, and a SSD.
The first compression benchmark is copying 10 copies of the unzipped
Silesia corpus [3] into a BtrFS filesystem mounted with
`-o compress-force=Method`. The decompression benchmark times how long
it takes to `tar` all 10 copies into `/dev/null`. The compression ratio is
measured by comparing the output of `df` and `du`. See the benchmark file
[1] for details. I benchmarked multiple zstd compression levels, although
the patch uses zstd level 1.
| Method | Ratio | Compression MB/s | Decompression speed |
|---------|-------|------------------|---------------------|
| None | 0.99 | 504 | 686 |
| lzo | 1.66 | 398 | 442 |
| zlib | 2.58 | 65 | 241 |
| zstd 1 | 2.57 | 260 | 383 |
| zstd 3 | 2.71 | 174 | 408 |
| zstd 6 | 2.87 | 70 | 398 |
| zstd 9 | 2.92 | 43 | 406 |
| zstd 12 | 2.93 | 21 | 408 |
| zstd 15 | 3.01 | 11 | 354 |
The next benchmark first copies `linux-4.11.6.tar` [4] to btrfs. Then it
measures the compression ratio, extracts the tar, and deletes the tar.
Then it measures the compression ratio again, and `tar`s the extracted
files into `/dev/null`. See the benchmark file [2] for details.
| Method | Tar Ratio | Extract Ratio | Copy (s) | Extract (s)| Read (s) |
|--------|-----------|---------------|----------|------------|----------|
| None | 0.97 | 0.78 | 0.981 | 5.501 | 8.807 |
| lzo | 2.06 | 1.38 | 1.631 | 8.458 | 8.585 |
| zlib | 3.40 | 1.86 | 7.750 | 21.544 | 11.744 |
| zstd 1 | 3.57 | 1.85 | 2.579 | 11.479 | 9.389 |
[1] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-benchmark.sh
[2] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-extract-benchmark.sh
[3] http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
[4] https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.11.6.tar.xz
zstd source repository: https://github.com/facebook/zstd
Signed-off-by: Nick Terrell <terrelln@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2017-08-10 10:39:02 +08:00
|
|
|
compress_type = "zstd";
|
|
|
|
info->compress_type = BTRFS_COMPRESS_ZSTD;
|
2019-02-05 04:20:08 +08:00
|
|
|
info->compress_level =
|
|
|
|
btrfs_compress_str2level(
|
|
|
|
BTRFS_COMPRESS_ZSTD,
|
|
|
|
args[0].from + 4);
|
btrfs: Add zstd support
Add zstd compression and decompression support to BtrFS. zstd at its
fastest level compresses almost as well as zlib, while offering much
faster compression and decompression, approaching lzo speeds.
I benchmarked btrfs with zstd compression against no compression, lzo
compression, and zlib compression. I benchmarked two scenarios. Copying
a set of files to btrfs, and then reading the files. Copying a tarball
to btrfs, extracting it to btrfs, and then reading the extracted files.
After every operation, I call `sync` and include the sync time.
Between every pair of operations I unmount and remount the filesystem
to avoid caching. The benchmark files can be found in the upstream
zstd source repository under
`contrib/linux-kernel/{btrfs-benchmark.sh,btrfs-extract-benchmark.sh}`
[1] [2].
I ran the benchmarks on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.
The VM is running on a MacBook Pro with a 3.1 GHz Intel Core i7 processor,
16 GB of RAM, and a SSD.
The first compression benchmark is copying 10 copies of the unzipped
Silesia corpus [3] into a BtrFS filesystem mounted with
`-o compress-force=Method`. The decompression benchmark times how long
it takes to `tar` all 10 copies into `/dev/null`. The compression ratio is
measured by comparing the output of `df` and `du`. See the benchmark file
[1] for details. I benchmarked multiple zstd compression levels, although
the patch uses zstd level 1.
| Method | Ratio | Compression MB/s | Decompression speed |
|---------|-------|------------------|---------------------|
| None | 0.99 | 504 | 686 |
| lzo | 1.66 | 398 | 442 |
| zlib | 2.58 | 65 | 241 |
| zstd 1 | 2.57 | 260 | 383 |
| zstd 3 | 2.71 | 174 | 408 |
| zstd 6 | 2.87 | 70 | 398 |
| zstd 9 | 2.92 | 43 | 406 |
| zstd 12 | 2.93 | 21 | 408 |
| zstd 15 | 3.01 | 11 | 354 |
The next benchmark first copies `linux-4.11.6.tar` [4] to btrfs. Then it
measures the compression ratio, extracts the tar, and deletes the tar.
Then it measures the compression ratio again, and `tar`s the extracted
files into `/dev/null`. See the benchmark file [2] for details.
| Method | Tar Ratio | Extract Ratio | Copy (s) | Extract (s)| Read (s) |
|--------|-----------|---------------|----------|------------|----------|
| None | 0.97 | 0.78 | 0.981 | 5.501 | 8.807 |
| lzo | 2.06 | 1.38 | 1.631 | 8.458 | 8.585 |
| zlib | 3.40 | 1.86 | 7.750 | 21.544 | 11.744 |
| zstd 1 | 3.57 | 1.85 | 2.579 | 11.479 | 9.389 |
[1] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-benchmark.sh
[2] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-extract-benchmark.sh
[3] http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
[4] https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.11.6.tar.xz
zstd source repository: https://github.com/facebook/zstd
Signed-off-by: Nick Terrell <terrelln@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2017-08-10 10:39:02 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, COMPRESS);
|
|
|
|
btrfs_clear_opt(info->mount_opt, NODATACOW);
|
|
|
|
btrfs_clear_opt(info->mount_opt, NODATASUM);
|
|
|
|
btrfs_set_fs_incompat(info, COMPRESS_ZSTD);
|
|
|
|
no_compress = 0;
|
2012-04-16 21:27:51 +08:00
|
|
|
} else if (strncmp(args[0].from, "no", 2) == 0) {
|
|
|
|
compress_type = "no";
|
|
|
|
btrfs_clear_opt(info->mount_opt, COMPRESS);
|
|
|
|
btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
|
|
|
|
compress_force = false;
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
no_compress++;
|
2010-12-17 14:21:50 +08:00
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (compress_force) {
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
|
2014-07-29 23:41:08 +08:00
|
|
|
} else {
|
2014-06-30 10:51:25 +08:00
|
|
|
/*
|
|
|
|
* If we remount from compress-force=xxx to
|
|
|
|
* compress=xxx, we need clear FORCE_COMPRESS
|
|
|
|
* flag, otherwise, there is no way for users
|
|
|
|
* to disable forcible compression separately.
|
|
|
|
*/
|
|
|
|
btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
|
2013-11-22 18:47:59 +08:00
|
|
|
}
|
2016-06-10 09:38:35 +08:00
|
|
|
if ((btrfs_test_opt(info, COMPRESS) &&
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
(info->compress_type != saved_compress_type ||
|
|
|
|
compress_force != saved_compress_force)) ||
|
2016-06-10 09:38:35 +08:00
|
|
|
(!btrfs_test_opt(info, COMPRESS) &&
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
no_compress == 1)) {
|
2017-09-15 23:36:57 +08:00
|
|
|
btrfs_info(info, "%s %s compression, level %d",
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
(compress_force) ? "force" : "use",
|
2017-09-15 23:36:57 +08:00
|
|
|
compress_type, info->compress_level);
|
Btrfs: fix output of compression message in btrfs_parse_options()
The compression message might not be correctly output.
Fix it.
[[before fix]]
# mount -o compress /dev/sdb3 /test3
[ 996.874264] BTRFS info (device sdb3): disk space caching is enabled
[ 996.874268] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 1035.075017] BTRFS info (device sdb3): force zlib compression
[ 1035.075021] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 1053.679092] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
[[after fix]]
# mount -o compress /dev/sdb3 /test3
[ 401.021753] BTRFS info (device sdb3): use zlib compression
[ 401.021758] BTRFS info (device sdb3): disk space caching is enabled
[ 401.021760] BTRFS: has skinny extents
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress-force /dev/sdb3 /test3
[ 439.824624] BTRFS info (device sdb3): force zlib compression
[ 439.824629] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress-force=zlib,space_cache,subvolid=5,subvol=/)
# mount -o remount,compress /dev/sdb3 /test3
[ 459.918430] BTRFS info (device sdb3): use zlib compression
[ 459.918434] BTRFS info (device sdb3): disk space caching is enabled
# mount | grep /test3
/dev/sdb3 on /test3 type btrfs (rw,relatime,compress=zlib,space_cache,subvolid=5,subvol=/)
Signed-off-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-01-06 16:03:40 +08:00
|
|
|
}
|
|
|
|
compress_force = false;
|
2010-01-29 05:18:15 +08:00
|
|
|
break;
|
2008-01-18 23:54:22 +08:00
|
|
|
case Opt_ssd:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, SSD,
|
btrfs: Do not use data_alloc_cluster in ssd mode
This patch provides a band aid to improve the 'out of the box'
behaviour of btrfs for disks that are detected as being an ssd. In a
general purpose mixed workload scenario, the current ssd mode causes
overallocation of available raw disk space for data, while leaving
behind increasing amounts of unused fragmented free space. This
situation leads to early ENOSPC problems which are harming user
experience and adoption of btrfs as a general purpose filesystem.
This patch modifies the data extent allocation behaviour of the ssd mode
to make it behave identical to nossd mode. The metadata behaviour and
additional ssd_spread option stay untouched so far.
Recommendations for future development are to reconsider the current
oversimplified nossd / ssd distinction and the broken detection
mechanism based on the rotational attribute in sysfs and provide
experienced users with a more flexible way to choose allocator behaviour
for data and metadata, optimized for certain use cases, while keeping
sane 'out of the box' default settings. The internals of the current
btrfs code have more potential than what currently gets exposed to the
user to choose from.
The SSD story...
In the first year of btrfs development, around early 2008, btrfs
gained a mount option which enables specific functionality for
filesystems on solid state devices. The first occurance of this
functionality is in commit e18e4809, labeled "Add mount -o ssd, which
includes optimizations for seek free storage".
The effect on allocating free space for doing (data) writes is to
'cluster' writes together, writing them out in contiguous space, as
opposed to a 'tetris' way of putting all separate writes into any free
space fragment that fits (which is what the -o nossd behaviour does).
A somewhat simplified explanation of what happens is that, when for
example, the 'cluster' size is set to 2MiB, when we do some writes, the
data allocator will search for a free space block that is 2MiB big, and
put the writes in there. The ssd mode itself might allow a 2MiB cluster
to be composed of multiple free space extents with some existing data in
between, while the additional ssd_spread mount option kills off this
option and requires fully free space.
The idea behind this is (commit 536ac8ae): "The [...] clusters make it
more likely a given IO will completely overwrite the ssd block, so it
doesn't have to do an internal rwm cycle."; ssd block meaning nand erase
block. So, effectively this means applying a "locality based algorithm"
and trying to outsmart the actual ssd.
Since then, various changes have been made to the involved code, but the
basic idea is still present, and gets activated whenever the ssd mount
option is active. This also happens by default, when the rotational flag
as seen at /sys/block/<device>/queue/rotational is set to 0.
However, there's a number of problems with this approach.
First, what the optimization is trying to do is outsmart the ssd by
assuming there is a relation between the physical address space of the
block device as seen by btrfs and the actual physical storage of the
ssd, and then adjusting data placement. However, since the introduction
of the Flash Translation Layer (FTL) which is a part of the internal
controller of an ssd, these attempts are futile. The use of good quality
FTL in consumer ssd products might have been limited in 2008, but this
situation has changed drastically soon after that time. Today, even the
flash memory in your automatic cat feeding machine or your grandma's
wheelchair has a full featured one.
Second, the behaviour as described above results in the filesystem being
filled up with badly fragmented free space extents because of relatively
small pieces of space that are freed up by deletes, but not selected
again as part of a 'cluster'. Since the algorithm prefers allocating a
new chunk over going back to tetris mode, the end result is a filesystem
in which all raw space is allocated, but which is composed of
underutilized chunks with a 'shotgun blast' pattern of fragmented free
space. Usually, the next problematic thing that happens is the
filesystem wanting to allocate new space for metadata, which causes the
filesystem to fail in spectacular ways.
Third, the default mount options you get for an ssd ('ssd' mode enabled,
'discard' not enabled), in combination with spreading out writes over
the full address space and ignoring freed up space leads to worst case
behaviour in providing information to the ssd itself, since it will
never learn that all the free space left behind is actually free. There
are two ways to let an ssd know previously written data does not have to
be preserved, which are sending explicit signals using discard or
fstrim, or by simply overwriting the space with new data. The worst
case behaviour is the btrfs ssd_spread mount option in combination with
not having discard enabled. It has a side effect of minimizing the reuse
of free space previously written in.
Fourth, the rotational flag in /sys/ does not reliably indicate if the
device is a locally attached ssd. For example, iSCSI or NBD displays as
non-rotational, while a loop device on an ssd shows up as rotational.
The combination of the second and third problem effectively means that
despite all the good intentions, the btrfs ssd mode reliably causes the
ssd hardware and the filesystem structures and performance to be choked
to death. The clickbait version of the title of this story would have
been "Btrfs ssd optimizations considered harmful for ssds".
The current nossd 'tetris' mode (even still without discard) allows a
pattern of overwriting much more previously used space, causing many
more implicit discards to happen because of the overwrite information
the ssd gets. The actual location in the physical address space, as seen
from the point of view of btrfs is irrelevant, because the actual writes
to the low level flash are reordered anyway thanks to the FTL.
Changes made in the code
1. Make ssd mode data allocation identical to tetris mode, like nossd.
2. Adjust and clean up filesystem mount messages so that we can easily
identify if a kernel has this patch applied or not, when providing
support to end users. Also, make better use of the *_and_info helpers to
only trigger messages on actual state changes.
Backporting notes
Notes for whoever wants to backport this patch to their 4.9 LTS kernel:
* First apply commit 951e7966 "btrfs: drop the nossd flag when
remounting with -o ssd", or fixup the differences manually.
* The rest of the conflicts are because of the fs_info refactoring. So,
for example, instead of using fs_info, it's root->fs_info in
extent-tree.c
Signed-off-by: Hans van Kranenburg <hans.van.kranenburg@mendix.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2017-07-28 14:31:28 +08:00
|
|
|
"enabling ssd optimizations");
|
2017-03-31 23:19:04 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt, NOSSD);
|
2008-01-18 23:54:22 +08:00
|
|
|
break;
|
2009-06-10 08:28:34 +08:00
|
|
|
case Opt_ssd_spread:
|
btrfs: Do not use data_alloc_cluster in ssd mode
This patch provides a band aid to improve the 'out of the box'
behaviour of btrfs for disks that are detected as being an ssd. In a
general purpose mixed workload scenario, the current ssd mode causes
overallocation of available raw disk space for data, while leaving
behind increasing amounts of unused fragmented free space. This
situation leads to early ENOSPC problems which are harming user
experience and adoption of btrfs as a general purpose filesystem.
This patch modifies the data extent allocation behaviour of the ssd mode
to make it behave identical to nossd mode. The metadata behaviour and
additional ssd_spread option stay untouched so far.
Recommendations for future development are to reconsider the current
oversimplified nossd / ssd distinction and the broken detection
mechanism based on the rotational attribute in sysfs and provide
experienced users with a more flexible way to choose allocator behaviour
for data and metadata, optimized for certain use cases, while keeping
sane 'out of the box' default settings. The internals of the current
btrfs code have more potential than what currently gets exposed to the
user to choose from.
The SSD story...
In the first year of btrfs development, around early 2008, btrfs
gained a mount option which enables specific functionality for
filesystems on solid state devices. The first occurance of this
functionality is in commit e18e4809, labeled "Add mount -o ssd, which
includes optimizations for seek free storage".
The effect on allocating free space for doing (data) writes is to
'cluster' writes together, writing them out in contiguous space, as
opposed to a 'tetris' way of putting all separate writes into any free
space fragment that fits (which is what the -o nossd behaviour does).
A somewhat simplified explanation of what happens is that, when for
example, the 'cluster' size is set to 2MiB, when we do some writes, the
data allocator will search for a free space block that is 2MiB big, and
put the writes in there. The ssd mode itself might allow a 2MiB cluster
to be composed of multiple free space extents with some existing data in
between, while the additional ssd_spread mount option kills off this
option and requires fully free space.
The idea behind this is (commit 536ac8ae): "The [...] clusters make it
more likely a given IO will completely overwrite the ssd block, so it
doesn't have to do an internal rwm cycle."; ssd block meaning nand erase
block. So, effectively this means applying a "locality based algorithm"
and trying to outsmart the actual ssd.
Since then, various changes have been made to the involved code, but the
basic idea is still present, and gets activated whenever the ssd mount
option is active. This also happens by default, when the rotational flag
as seen at /sys/block/<device>/queue/rotational is set to 0.
However, there's a number of problems with this approach.
First, what the optimization is trying to do is outsmart the ssd by
assuming there is a relation between the physical address space of the
block device as seen by btrfs and the actual physical storage of the
ssd, and then adjusting data placement. However, since the introduction
of the Flash Translation Layer (FTL) which is a part of the internal
controller of an ssd, these attempts are futile. The use of good quality
FTL in consumer ssd products might have been limited in 2008, but this
situation has changed drastically soon after that time. Today, even the
flash memory in your automatic cat feeding machine or your grandma's
wheelchair has a full featured one.
Second, the behaviour as described above results in the filesystem being
filled up with badly fragmented free space extents because of relatively
small pieces of space that are freed up by deletes, but not selected
again as part of a 'cluster'. Since the algorithm prefers allocating a
new chunk over going back to tetris mode, the end result is a filesystem
in which all raw space is allocated, but which is composed of
underutilized chunks with a 'shotgun blast' pattern of fragmented free
space. Usually, the next problematic thing that happens is the
filesystem wanting to allocate new space for metadata, which causes the
filesystem to fail in spectacular ways.
Third, the default mount options you get for an ssd ('ssd' mode enabled,
'discard' not enabled), in combination with spreading out writes over
the full address space and ignoring freed up space leads to worst case
behaviour in providing information to the ssd itself, since it will
never learn that all the free space left behind is actually free. There
are two ways to let an ssd know previously written data does not have to
be preserved, which are sending explicit signals using discard or
fstrim, or by simply overwriting the space with new data. The worst
case behaviour is the btrfs ssd_spread mount option in combination with
not having discard enabled. It has a side effect of minimizing the reuse
of free space previously written in.
Fourth, the rotational flag in /sys/ does not reliably indicate if the
device is a locally attached ssd. For example, iSCSI or NBD displays as
non-rotational, while a loop device on an ssd shows up as rotational.
The combination of the second and third problem effectively means that
despite all the good intentions, the btrfs ssd mode reliably causes the
ssd hardware and the filesystem structures and performance to be choked
to death. The clickbait version of the title of this story would have
been "Btrfs ssd optimizations considered harmful for ssds".
The current nossd 'tetris' mode (even still without discard) allows a
pattern of overwriting much more previously used space, causing many
more implicit discards to happen because of the overwrite information
the ssd gets. The actual location in the physical address space, as seen
from the point of view of btrfs is irrelevant, because the actual writes
to the low level flash are reordered anyway thanks to the FTL.
Changes made in the code
1. Make ssd mode data allocation identical to tetris mode, like nossd.
2. Adjust and clean up filesystem mount messages so that we can easily
identify if a kernel has this patch applied or not, when providing
support to end users. Also, make better use of the *_and_info helpers to
only trigger messages on actual state changes.
Backporting notes
Notes for whoever wants to backport this patch to their 4.9 LTS kernel:
* First apply commit 951e7966 "btrfs: drop the nossd flag when
remounting with -o ssd", or fixup the differences manually.
* The rest of the conflicts are because of the fs_info refactoring. So,
for example, instead of using fs_info, it's root->fs_info in
extent-tree.c
Signed-off-by: Hans van Kranenburg <hans.van.kranenburg@mendix.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2017-07-28 14:31:28 +08:00
|
|
|
btrfs_set_and_info(info, SSD,
|
|
|
|
"enabling ssd optimizations");
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, SSD_SPREAD,
|
btrfs: Do not use data_alloc_cluster in ssd mode
This patch provides a band aid to improve the 'out of the box'
behaviour of btrfs for disks that are detected as being an ssd. In a
general purpose mixed workload scenario, the current ssd mode causes
overallocation of available raw disk space for data, while leaving
behind increasing amounts of unused fragmented free space. This
situation leads to early ENOSPC problems which are harming user
experience and adoption of btrfs as a general purpose filesystem.
This patch modifies the data extent allocation behaviour of the ssd mode
to make it behave identical to nossd mode. The metadata behaviour and
additional ssd_spread option stay untouched so far.
Recommendations for future development are to reconsider the current
oversimplified nossd / ssd distinction and the broken detection
mechanism based on the rotational attribute in sysfs and provide
experienced users with a more flexible way to choose allocator behaviour
for data and metadata, optimized for certain use cases, while keeping
sane 'out of the box' default settings. The internals of the current
btrfs code have more potential than what currently gets exposed to the
user to choose from.
The SSD story...
In the first year of btrfs development, around early 2008, btrfs
gained a mount option which enables specific functionality for
filesystems on solid state devices. The first occurance of this
functionality is in commit e18e4809, labeled "Add mount -o ssd, which
includes optimizations for seek free storage".
The effect on allocating free space for doing (data) writes is to
'cluster' writes together, writing them out in contiguous space, as
opposed to a 'tetris' way of putting all separate writes into any free
space fragment that fits (which is what the -o nossd behaviour does).
A somewhat simplified explanation of what happens is that, when for
example, the 'cluster' size is set to 2MiB, when we do some writes, the
data allocator will search for a free space block that is 2MiB big, and
put the writes in there. The ssd mode itself might allow a 2MiB cluster
to be composed of multiple free space extents with some existing data in
between, while the additional ssd_spread mount option kills off this
option and requires fully free space.
The idea behind this is (commit 536ac8ae): "The [...] clusters make it
more likely a given IO will completely overwrite the ssd block, so it
doesn't have to do an internal rwm cycle."; ssd block meaning nand erase
block. So, effectively this means applying a "locality based algorithm"
and trying to outsmart the actual ssd.
Since then, various changes have been made to the involved code, but the
basic idea is still present, and gets activated whenever the ssd mount
option is active. This also happens by default, when the rotational flag
as seen at /sys/block/<device>/queue/rotational is set to 0.
However, there's a number of problems with this approach.
First, what the optimization is trying to do is outsmart the ssd by
assuming there is a relation between the physical address space of the
block device as seen by btrfs and the actual physical storage of the
ssd, and then adjusting data placement. However, since the introduction
of the Flash Translation Layer (FTL) which is a part of the internal
controller of an ssd, these attempts are futile. The use of good quality
FTL in consumer ssd products might have been limited in 2008, but this
situation has changed drastically soon after that time. Today, even the
flash memory in your automatic cat feeding machine or your grandma's
wheelchair has a full featured one.
Second, the behaviour as described above results in the filesystem being
filled up with badly fragmented free space extents because of relatively
small pieces of space that are freed up by deletes, but not selected
again as part of a 'cluster'. Since the algorithm prefers allocating a
new chunk over going back to tetris mode, the end result is a filesystem
in which all raw space is allocated, but which is composed of
underutilized chunks with a 'shotgun blast' pattern of fragmented free
space. Usually, the next problematic thing that happens is the
filesystem wanting to allocate new space for metadata, which causes the
filesystem to fail in spectacular ways.
Third, the default mount options you get for an ssd ('ssd' mode enabled,
'discard' not enabled), in combination with spreading out writes over
the full address space and ignoring freed up space leads to worst case
behaviour in providing information to the ssd itself, since it will
never learn that all the free space left behind is actually free. There
are two ways to let an ssd know previously written data does not have to
be preserved, which are sending explicit signals using discard or
fstrim, or by simply overwriting the space with new data. The worst
case behaviour is the btrfs ssd_spread mount option in combination with
not having discard enabled. It has a side effect of minimizing the reuse
of free space previously written in.
Fourth, the rotational flag in /sys/ does not reliably indicate if the
device is a locally attached ssd. For example, iSCSI or NBD displays as
non-rotational, while a loop device on an ssd shows up as rotational.
The combination of the second and third problem effectively means that
despite all the good intentions, the btrfs ssd mode reliably causes the
ssd hardware and the filesystem structures and performance to be choked
to death. The clickbait version of the title of this story would have
been "Btrfs ssd optimizations considered harmful for ssds".
The current nossd 'tetris' mode (even still without discard) allows a
pattern of overwriting much more previously used space, causing many
more implicit discards to happen because of the overwrite information
the ssd gets. The actual location in the physical address space, as seen
from the point of view of btrfs is irrelevant, because the actual writes
to the low level flash are reordered anyway thanks to the FTL.
Changes made in the code
1. Make ssd mode data allocation identical to tetris mode, like nossd.
2. Adjust and clean up filesystem mount messages so that we can easily
identify if a kernel has this patch applied or not, when providing
support to end users. Also, make better use of the *_and_info helpers to
only trigger messages on actual state changes.
Backporting notes
Notes for whoever wants to backport this patch to their 4.9 LTS kernel:
* First apply commit 951e7966 "btrfs: drop the nossd flag when
remounting with -o ssd", or fixup the differences manually.
* The rest of the conflicts are because of the fs_info refactoring. So,
for example, instead of using fs_info, it's root->fs_info in
extent-tree.c
Signed-off-by: Hans van Kranenburg <hans.van.kranenburg@mendix.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2017-07-28 14:31:28 +08:00
|
|
|
"using spread ssd allocation scheme");
|
2017-03-31 23:19:04 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt, NOSSD);
|
2009-06-10 08:28:34 +08:00
|
|
|
break;
|
2009-06-10 04:42:22 +08:00
|
|
|
case Opt_nossd:
|
btrfs: Do not use data_alloc_cluster in ssd mode
This patch provides a band aid to improve the 'out of the box'
behaviour of btrfs for disks that are detected as being an ssd. In a
general purpose mixed workload scenario, the current ssd mode causes
overallocation of available raw disk space for data, while leaving
behind increasing amounts of unused fragmented free space. This
situation leads to early ENOSPC problems which are harming user
experience and adoption of btrfs as a general purpose filesystem.
This patch modifies the data extent allocation behaviour of the ssd mode
to make it behave identical to nossd mode. The metadata behaviour and
additional ssd_spread option stay untouched so far.
Recommendations for future development are to reconsider the current
oversimplified nossd / ssd distinction and the broken detection
mechanism based on the rotational attribute in sysfs and provide
experienced users with a more flexible way to choose allocator behaviour
for data and metadata, optimized for certain use cases, while keeping
sane 'out of the box' default settings. The internals of the current
btrfs code have more potential than what currently gets exposed to the
user to choose from.
The SSD story...
In the first year of btrfs development, around early 2008, btrfs
gained a mount option which enables specific functionality for
filesystems on solid state devices. The first occurance of this
functionality is in commit e18e4809, labeled "Add mount -o ssd, which
includes optimizations for seek free storage".
The effect on allocating free space for doing (data) writes is to
'cluster' writes together, writing them out in contiguous space, as
opposed to a 'tetris' way of putting all separate writes into any free
space fragment that fits (which is what the -o nossd behaviour does).
A somewhat simplified explanation of what happens is that, when for
example, the 'cluster' size is set to 2MiB, when we do some writes, the
data allocator will search for a free space block that is 2MiB big, and
put the writes in there. The ssd mode itself might allow a 2MiB cluster
to be composed of multiple free space extents with some existing data in
between, while the additional ssd_spread mount option kills off this
option and requires fully free space.
The idea behind this is (commit 536ac8ae): "The [...] clusters make it
more likely a given IO will completely overwrite the ssd block, so it
doesn't have to do an internal rwm cycle."; ssd block meaning nand erase
block. So, effectively this means applying a "locality based algorithm"
and trying to outsmart the actual ssd.
Since then, various changes have been made to the involved code, but the
basic idea is still present, and gets activated whenever the ssd mount
option is active. This also happens by default, when the rotational flag
as seen at /sys/block/<device>/queue/rotational is set to 0.
However, there's a number of problems with this approach.
First, what the optimization is trying to do is outsmart the ssd by
assuming there is a relation between the physical address space of the
block device as seen by btrfs and the actual physical storage of the
ssd, and then adjusting data placement. However, since the introduction
of the Flash Translation Layer (FTL) which is a part of the internal
controller of an ssd, these attempts are futile. The use of good quality
FTL in consumer ssd products might have been limited in 2008, but this
situation has changed drastically soon after that time. Today, even the
flash memory in your automatic cat feeding machine or your grandma's
wheelchair has a full featured one.
Second, the behaviour as described above results in the filesystem being
filled up with badly fragmented free space extents because of relatively
small pieces of space that are freed up by deletes, but not selected
again as part of a 'cluster'. Since the algorithm prefers allocating a
new chunk over going back to tetris mode, the end result is a filesystem
in which all raw space is allocated, but which is composed of
underutilized chunks with a 'shotgun blast' pattern of fragmented free
space. Usually, the next problematic thing that happens is the
filesystem wanting to allocate new space for metadata, which causes the
filesystem to fail in spectacular ways.
Third, the default mount options you get for an ssd ('ssd' mode enabled,
'discard' not enabled), in combination with spreading out writes over
the full address space and ignoring freed up space leads to worst case
behaviour in providing information to the ssd itself, since it will
never learn that all the free space left behind is actually free. There
are two ways to let an ssd know previously written data does not have to
be preserved, which are sending explicit signals using discard or
fstrim, or by simply overwriting the space with new data. The worst
case behaviour is the btrfs ssd_spread mount option in combination with
not having discard enabled. It has a side effect of minimizing the reuse
of free space previously written in.
Fourth, the rotational flag in /sys/ does not reliably indicate if the
device is a locally attached ssd. For example, iSCSI or NBD displays as
non-rotational, while a loop device on an ssd shows up as rotational.
The combination of the second and third problem effectively means that
despite all the good intentions, the btrfs ssd mode reliably causes the
ssd hardware and the filesystem structures and performance to be choked
to death. The clickbait version of the title of this story would have
been "Btrfs ssd optimizations considered harmful for ssds".
The current nossd 'tetris' mode (even still without discard) allows a
pattern of overwriting much more previously used space, causing many
more implicit discards to happen because of the overwrite information
the ssd gets. The actual location in the physical address space, as seen
from the point of view of btrfs is irrelevant, because the actual writes
to the low level flash are reordered anyway thanks to the FTL.
Changes made in the code
1. Make ssd mode data allocation identical to tetris mode, like nossd.
2. Adjust and clean up filesystem mount messages so that we can easily
identify if a kernel has this patch applied or not, when providing
support to end users. Also, make better use of the *_and_info helpers to
only trigger messages on actual state changes.
Backporting notes
Notes for whoever wants to backport this patch to their 4.9 LTS kernel:
* First apply commit 951e7966 "btrfs: drop the nossd flag when
remounting with -o ssd", or fixup the differences manually.
* The rest of the conflicts are because of the fs_info refactoring. So,
for example, instead of using fs_info, it's root->fs_info in
extent-tree.c
Signed-off-by: Hans van Kranenburg <hans.van.kranenburg@mendix.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2017-07-28 14:31:28 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, NOSSD);
|
|
|
|
btrfs_clear_and_info(info, SSD,
|
|
|
|
"not using ssd optimizations");
|
2020-06-17 02:54:29 +08:00
|
|
|
fallthrough;
|
2018-03-09 02:48:48 +08:00
|
|
|
case Opt_nossd_spread:
|
btrfs: Do not use data_alloc_cluster in ssd mode
This patch provides a band aid to improve the 'out of the box'
behaviour of btrfs for disks that are detected as being an ssd. In a
general purpose mixed workload scenario, the current ssd mode causes
overallocation of available raw disk space for data, while leaving
behind increasing amounts of unused fragmented free space. This
situation leads to early ENOSPC problems which are harming user
experience and adoption of btrfs as a general purpose filesystem.
This patch modifies the data extent allocation behaviour of the ssd mode
to make it behave identical to nossd mode. The metadata behaviour and
additional ssd_spread option stay untouched so far.
Recommendations for future development are to reconsider the current
oversimplified nossd / ssd distinction and the broken detection
mechanism based on the rotational attribute in sysfs and provide
experienced users with a more flexible way to choose allocator behaviour
for data and metadata, optimized for certain use cases, while keeping
sane 'out of the box' default settings. The internals of the current
btrfs code have more potential than what currently gets exposed to the
user to choose from.
The SSD story...
In the first year of btrfs development, around early 2008, btrfs
gained a mount option which enables specific functionality for
filesystems on solid state devices. The first occurance of this
functionality is in commit e18e4809, labeled "Add mount -o ssd, which
includes optimizations for seek free storage".
The effect on allocating free space for doing (data) writes is to
'cluster' writes together, writing them out in contiguous space, as
opposed to a 'tetris' way of putting all separate writes into any free
space fragment that fits (which is what the -o nossd behaviour does).
A somewhat simplified explanation of what happens is that, when for
example, the 'cluster' size is set to 2MiB, when we do some writes, the
data allocator will search for a free space block that is 2MiB big, and
put the writes in there. The ssd mode itself might allow a 2MiB cluster
to be composed of multiple free space extents with some existing data in
between, while the additional ssd_spread mount option kills off this
option and requires fully free space.
The idea behind this is (commit 536ac8ae): "The [...] clusters make it
more likely a given IO will completely overwrite the ssd block, so it
doesn't have to do an internal rwm cycle."; ssd block meaning nand erase
block. So, effectively this means applying a "locality based algorithm"
and trying to outsmart the actual ssd.
Since then, various changes have been made to the involved code, but the
basic idea is still present, and gets activated whenever the ssd mount
option is active. This also happens by default, when the rotational flag
as seen at /sys/block/<device>/queue/rotational is set to 0.
However, there's a number of problems with this approach.
First, what the optimization is trying to do is outsmart the ssd by
assuming there is a relation between the physical address space of the
block device as seen by btrfs and the actual physical storage of the
ssd, and then adjusting data placement. However, since the introduction
of the Flash Translation Layer (FTL) which is a part of the internal
controller of an ssd, these attempts are futile. The use of good quality
FTL in consumer ssd products might have been limited in 2008, but this
situation has changed drastically soon after that time. Today, even the
flash memory in your automatic cat feeding machine or your grandma's
wheelchair has a full featured one.
Second, the behaviour as described above results in the filesystem being
filled up with badly fragmented free space extents because of relatively
small pieces of space that are freed up by deletes, but not selected
again as part of a 'cluster'. Since the algorithm prefers allocating a
new chunk over going back to tetris mode, the end result is a filesystem
in which all raw space is allocated, but which is composed of
underutilized chunks with a 'shotgun blast' pattern of fragmented free
space. Usually, the next problematic thing that happens is the
filesystem wanting to allocate new space for metadata, which causes the
filesystem to fail in spectacular ways.
Third, the default mount options you get for an ssd ('ssd' mode enabled,
'discard' not enabled), in combination with spreading out writes over
the full address space and ignoring freed up space leads to worst case
behaviour in providing information to the ssd itself, since it will
never learn that all the free space left behind is actually free. There
are two ways to let an ssd know previously written data does not have to
be preserved, which are sending explicit signals using discard or
fstrim, or by simply overwriting the space with new data. The worst
case behaviour is the btrfs ssd_spread mount option in combination with
not having discard enabled. It has a side effect of minimizing the reuse
of free space previously written in.
Fourth, the rotational flag in /sys/ does not reliably indicate if the
device is a locally attached ssd. For example, iSCSI or NBD displays as
non-rotational, while a loop device on an ssd shows up as rotational.
The combination of the second and third problem effectively means that
despite all the good intentions, the btrfs ssd mode reliably causes the
ssd hardware and the filesystem structures and performance to be choked
to death. The clickbait version of the title of this story would have
been "Btrfs ssd optimizations considered harmful for ssds".
The current nossd 'tetris' mode (even still without discard) allows a
pattern of overwriting much more previously used space, causing many
more implicit discards to happen because of the overwrite information
the ssd gets. The actual location in the physical address space, as seen
from the point of view of btrfs is irrelevant, because the actual writes
to the low level flash are reordered anyway thanks to the FTL.
Changes made in the code
1. Make ssd mode data allocation identical to tetris mode, like nossd.
2. Adjust and clean up filesystem mount messages so that we can easily
identify if a kernel has this patch applied or not, when providing
support to end users. Also, make better use of the *_and_info helpers to
only trigger messages on actual state changes.
Backporting notes
Notes for whoever wants to backport this patch to their 4.9 LTS kernel:
* First apply commit 951e7966 "btrfs: drop the nossd flag when
remounting with -o ssd", or fixup the differences manually.
* The rest of the conflicts are because of the fs_info refactoring. So,
for example, instead of using fs_info, it's root->fs_info in
extent-tree.c
Signed-off-by: Hans van Kranenburg <hans.van.kranenburg@mendix.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2017-07-28 14:31:28 +08:00
|
|
|
btrfs_clear_and_info(info, SSD_SPREAD,
|
|
|
|
"not using spread ssd allocation scheme");
|
2009-06-10 04:42:22 +08:00
|
|
|
break;
|
2014-01-06 09:58:25 +08:00
|
|
|
case Opt_barrier:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_clear_and_info(info, NOBARRIER,
|
2014-01-13 13:36:07 +08:00
|
|
|
"turning on barriers");
|
2014-01-06 09:58:25 +08:00
|
|
|
break;
|
2008-01-09 22:23:21 +08:00
|
|
|
case Opt_nobarrier:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, NOBARRIER,
|
2014-01-13 13:36:07 +08:00
|
|
|
"turning off barriers");
|
2008-01-09 22:23:21 +08:00
|
|
|
break;
|
2008-06-12 09:47:56 +08:00
|
|
|
case Opt_thread_pool:
|
2013-07-24 10:29:05 +08:00
|
|
|
ret = match_int(&args[0], &intarg);
|
|
|
|
if (ret) {
|
|
|
|
goto out;
|
2018-02-13 17:50:42 +08:00
|
|
|
} else if (intarg == 0) {
|
2013-07-24 10:29:05 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2018-02-13 17:50:42 +08:00
|
|
|
info->thread_pool_size = intarg;
|
2008-06-12 09:47:56 +08:00
|
|
|
break;
|
2008-01-30 05:03:38 +08:00
|
|
|
case Opt_max_inline:
|
2008-06-10 22:40:29 +08:00
|
|
|
num = match_strdup(&args[0]);
|
|
|
|
if (num) {
|
2010-02-28 18:59:11 +08:00
|
|
|
info->max_inline = memparse(num, NULL);
|
2008-06-10 22:40:29 +08:00
|
|
|
kfree(num);
|
|
|
|
|
2008-06-12 04:51:38 +08:00
|
|
|
if (info->max_inline) {
|
2014-02-13 23:13:16 +08:00
|
|
|
info->max_inline = min_t(u64,
|
2008-06-12 04:51:38 +08:00
|
|
|
info->max_inline,
|
2016-06-23 06:54:23 +08:00
|
|
|
info->sectorsize);
|
2008-06-12 04:51:38 +08:00
|
|
|
}
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "max_inline at %llu",
|
|
|
|
info->max_inline);
|
2013-07-24 10:29:05 +08:00
|
|
|
} else {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
2008-01-30 05:03:38 +08:00
|
|
|
}
|
|
|
|
break;
|
2014-01-06 09:58:30 +08:00
|
|
|
case Opt_acl:
|
2014-05-12 11:04:33 +08:00
|
|
|
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
|
2017-11-28 05:05:09 +08:00
|
|
|
info->sb->s_flags |= SB_POSIXACL;
|
2014-01-06 09:58:30 +08:00
|
|
|
break;
|
2014-05-12 11:04:33 +08:00
|
|
|
#else
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_err(info, "support for ACL not compiled in!");
|
2014-05-12 11:04:33 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
#endif
|
2008-07-25 00:16:36 +08:00
|
|
|
case Opt_noacl:
|
2017-11-28 05:05:09 +08:00
|
|
|
info->sb->s_flags &= ~SB_POSIXACL;
|
2008-07-25 00:16:36 +08:00
|
|
|
break;
|
2009-04-03 04:49:40 +08:00
|
|
|
case Opt_notreelog:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, NOTREELOG,
|
2014-01-13 13:36:07 +08:00
|
|
|
"disabling tree log");
|
2014-01-06 09:58:33 +08:00
|
|
|
break;
|
|
|
|
case Opt_treelog:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_clear_and_info(info, NOTREELOG,
|
2014-01-13 13:36:07 +08:00
|
|
|
"enabling tree log");
|
2009-04-03 04:49:40 +08:00
|
|
|
break;
|
2016-01-19 10:23:04 +08:00
|
|
|
case Opt_norecovery:
|
2016-01-19 10:23:03 +08:00
|
|
|
case Opt_nologreplay:
|
2020-06-04 15:18:06 +08:00
|
|
|
btrfs_warn(info,
|
|
|
|
"'nologreplay' is deprecated, use 'rescue=nologreplay' instead");
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, NOLOGREPLAY,
|
2016-01-19 10:23:03 +08:00
|
|
|
"disabling log replay at mount time");
|
|
|
|
break;
|
2009-04-03 04:59:01 +08:00
|
|
|
case Opt_flushoncommit:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, FLUSHONCOMMIT,
|
2014-01-13 13:36:07 +08:00
|
|
|
"turning on flush-on-commit");
|
2009-04-03 04:59:01 +08:00
|
|
|
break;
|
2014-01-06 09:58:29 +08:00
|
|
|
case Opt_noflushoncommit:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_clear_and_info(info, FLUSHONCOMMIT,
|
2014-01-13 13:36:07 +08:00
|
|
|
"turning off flush-on-commit");
|
2014-01-06 09:58:29 +08:00
|
|
|
break;
|
2009-04-22 05:40:57 +08:00
|
|
|
case Opt_ratio:
|
2013-07-24 10:29:05 +08:00
|
|
|
ret = match_int(&args[0], &intarg);
|
2018-02-13 17:50:44 +08:00
|
|
|
if (ret)
|
2013-07-24 10:29:05 +08:00
|
|
|
goto out;
|
2018-02-13 17:50:44 +08:00
|
|
|
info->metadata_ratio = intarg;
|
|
|
|
btrfs_info(info, "metadata ratio %u",
|
|
|
|
info->metadata_ratio);
|
2009-04-22 05:40:57 +08:00
|
|
|
break;
|
2009-10-14 21:24:59 +08:00
|
|
|
case Opt_discard:
|
2019-12-14 08:22:14 +08:00
|
|
|
case Opt_discard_mode:
|
|
|
|
if (token == Opt_discard ||
|
|
|
|
strcmp(args[0].from, "sync") == 0) {
|
|
|
|
btrfs_clear_opt(info->mount_opt, DISCARD_ASYNC);
|
|
|
|
btrfs_set_and_info(info, DISCARD_SYNC,
|
|
|
|
"turning on sync discard");
|
|
|
|
} else if (strcmp(args[0].from, "async") == 0) {
|
|
|
|
btrfs_clear_opt(info->mount_opt, DISCARD_SYNC);
|
|
|
|
btrfs_set_and_info(info, DISCARD_ASYNC,
|
|
|
|
"turning on async discard");
|
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-10-14 21:24:59 +08:00
|
|
|
break;
|
2014-01-06 09:58:27 +08:00
|
|
|
case Opt_nodiscard:
|
2019-12-14 08:22:11 +08:00
|
|
|
btrfs_clear_and_info(info, DISCARD_SYNC,
|
2014-01-13 13:36:07 +08:00
|
|
|
"turning off discard");
|
2019-12-14 08:22:14 +08:00
|
|
|
btrfs_clear_and_info(info, DISCARD_ASYNC,
|
|
|
|
"turning off async discard");
|
2014-01-06 09:58:27 +08:00
|
|
|
break;
|
2010-06-22 02:48:16 +08:00
|
|
|
case Opt_space_cache:
|
2015-09-30 11:50:38 +08:00
|
|
|
case Opt_space_cache_version:
|
|
|
|
if (token == Opt_space_cache ||
|
|
|
|
strcmp(args[0].from, "v1") == 0) {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt,
|
2015-09-30 11:50:38 +08:00
|
|
|
FREE_SPACE_TREE);
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, SPACE_CACHE,
|
2016-06-23 06:54:23 +08:00
|
|
|
"enabling disk space caching");
|
2015-09-30 11:50:38 +08:00
|
|
|
} else if (strcmp(args[0].from, "v2") == 0) {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt,
|
2015-09-30 11:50:38 +08:00
|
|
|
SPACE_CACHE);
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_set_and_info(info, FREE_SPACE_TREE,
|
2015-09-30 11:50:38 +08:00
|
|
|
"enabling free space tree");
|
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-11-19 21:40:41 +08:00
|
|
|
break;
|
2013-08-15 23:11:24 +08:00
|
|
|
case Opt_rescan_uuid_tree:
|
|
|
|
btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
|
|
|
|
break;
|
2011-10-04 02:07:49 +08:00
|
|
|
case Opt_no_space_cache:
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, SPACE_CACHE)) {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_clear_and_info(info, SPACE_CACHE,
|
|
|
|
"disabling disk space caching");
|
2015-09-30 11:50:38 +08:00
|
|
|
}
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, FREE_SPACE_TREE)) {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_clear_and_info(info, FREE_SPACE_TREE,
|
|
|
|
"disabling free space tree");
|
2015-09-30 11:50:38 +08:00
|
|
|
}
|
2011-10-04 02:07:49 +08:00
|
|
|
break;
|
2011-06-03 21:36:29 +08:00
|
|
|
case Opt_inode_cache:
|
btrfs: start deprecation of mount option inode_cache
Estimated time of removal of the functionality is 5.11, the option will
be still parsed but will have no effect.
Reasons for deprecation and removal:
- very poor naming choice of the mount option, it's supposed to cache
and reuse the inode _numbers_, but it sounds a some generic cache for
inodes
- the only known usecase where this option would make sense is on a
32bit architecture where inode numbers in one subvolume would be
exhausted due to 32bit inode::i_ino
- the cache is stored on disk, consumes space, needs to be loaded and
written back
- new inode number allocation is slower due to lookups into the cache
(compared to a simple increment which is the default)
- uses the free-space-cache code that is going to be deprecated as well
in the future
Known problems:
- since 2011, returning EEXIST when there's not enough space in a page
to store all checksums, see commit 4b9465cb9e38 ("Btrfs: add mount -o
inode_cache")
Remaining issues:
- if the option was enabled, new inodes created, the option disabled
again, the cache is still stored on the devices and there's currently
no way to remove it
Signed-off-by: David Sterba <dsterba@suse.com>
2020-06-18 20:54:56 +08:00
|
|
|
btrfs_warn(info,
|
|
|
|
"the 'inode_cache' option is deprecated and will have no effect from 5.11");
|
2014-02-05 22:26:17 +08:00
|
|
|
btrfs_set_pending_and_info(info, INODE_MAP_CACHE,
|
2014-01-13 13:36:07 +08:00
|
|
|
"enabling inode map caching");
|
2014-01-13 13:36:06 +08:00
|
|
|
break;
|
|
|
|
case Opt_noinode_cache:
|
2014-02-05 22:26:17 +08:00
|
|
|
btrfs_clear_pending_and_info(info, INODE_MAP_CACHE,
|
2014-01-13 13:36:07 +08:00
|
|
|
"disabling inode map caching");
|
2011-06-03 21:36:29 +08:00
|
|
|
break;
|
2010-09-22 02:21:34 +08:00
|
|
|
case Opt_clear_cache:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, CLEAR_CACHE,
|
2014-01-13 13:36:07 +08:00
|
|
|
"force clearing of disk cache");
|
2010-06-22 02:48:16 +08:00
|
|
|
break;
|
2010-10-30 03:46:43 +08:00
|
|
|
case Opt_user_subvol_rm_allowed:
|
|
|
|
btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
|
|
|
|
break;
|
2011-02-17 02:10:41 +08:00
|
|
|
case Opt_enospc_debug:
|
|
|
|
btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
|
|
|
|
break;
|
2014-01-06 09:58:28 +08:00
|
|
|
case Opt_noenospc_debug:
|
|
|
|
btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
|
|
|
|
break;
|
2011-05-25 03:35:30 +08:00
|
|
|
case Opt_defrag:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_set_and_info(info, AUTO_DEFRAG,
|
2014-01-13 13:36:07 +08:00
|
|
|
"enabling auto defrag");
|
2011-05-25 03:35:30 +08:00
|
|
|
break;
|
2014-01-06 09:58:26 +08:00
|
|
|
case Opt_nodefrag:
|
2016-06-10 09:38:35 +08:00
|
|
|
btrfs_clear_and_info(info, AUTO_DEFRAG,
|
2014-01-13 13:36:07 +08:00
|
|
|
"disabling auto defrag");
|
2014-01-06 09:58:26 +08:00
|
|
|
break;
|
2011-11-04 03:17:42 +08:00
|
|
|
case Opt_recovery:
|
2016-01-19 10:23:02 +08:00
|
|
|
case Opt_usebackuproot:
|
2020-06-04 15:18:06 +08:00
|
|
|
btrfs_warn(info,
|
|
|
|
"'%s' is deprecated, use 'rescue=usebackuproot' instead",
|
|
|
|
token == Opt_recovery ? "recovery" :
|
|
|
|
"usebackuproot");
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info,
|
2016-01-19 10:23:02 +08:00
|
|
|
"trying to use backup root at mount time");
|
|
|
|
btrfs_set_opt(info->mount_opt, USEBACKUPROOT);
|
2011-11-04 03:17:42 +08:00
|
|
|
break;
|
2012-01-17 04:04:48 +08:00
|
|
|
case Opt_skip_balance:
|
|
|
|
btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
|
|
|
|
break;
|
2011-11-09 20:44:05 +08:00
|
|
|
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
|
|
|
|
case Opt_check_integrity_including_extent_data:
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info,
|
2013-12-21 00:37:06 +08:00
|
|
|
"enabling check integrity including extent data");
|
2011-11-09 20:44:05 +08:00
|
|
|
btrfs_set_opt(info->mount_opt,
|
|
|
|
CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
|
|
|
|
btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
|
|
|
|
break;
|
|
|
|
case Opt_check_integrity:
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "enabling check integrity");
|
2011-11-09 20:44:05 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
|
|
|
|
break;
|
|
|
|
case Opt_check_integrity_print_mask:
|
2013-07-24 10:29:05 +08:00
|
|
|
ret = match_int(&args[0], &intarg);
|
2018-02-13 17:50:45 +08:00
|
|
|
if (ret)
|
2013-07-24 10:29:05 +08:00
|
|
|
goto out;
|
2018-02-13 17:50:45 +08:00
|
|
|
info->check_integrity_print_mask = intarg;
|
|
|
|
btrfs_info(info, "check_integrity_print_mask 0x%x",
|
|
|
|
info->check_integrity_print_mask);
|
2011-11-09 20:44:05 +08:00
|
|
|
break;
|
|
|
|
#else
|
|
|
|
case Opt_check_integrity_including_extent_data:
|
|
|
|
case Opt_check_integrity:
|
|
|
|
case Opt_check_integrity_print_mask:
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_err(info,
|
|
|
|
"support for check_integrity* not compiled in!");
|
2011-11-09 20:44:05 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
#endif
|
2011-10-04 11:22:31 +08:00
|
|
|
case Opt_fatal_errors:
|
|
|
|
if (strcmp(args[0].from, "panic") == 0)
|
|
|
|
btrfs_set_opt(info->mount_opt,
|
|
|
|
PANIC_ON_FATAL_ERROR);
|
|
|
|
else if (strcmp(args[0].from, "bug") == 0)
|
|
|
|
btrfs_clear_opt(info->mount_opt,
|
|
|
|
PANIC_ON_FATAL_ERROR);
|
|
|
|
else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
break;
|
2013-08-02 00:14:52 +08:00
|
|
|
case Opt_commit_interval:
|
|
|
|
intarg = 0;
|
|
|
|
ret = match_int(&args[0], &intarg);
|
2018-02-13 17:50:46 +08:00
|
|
|
if (ret)
|
2013-08-02 00:14:52 +08:00
|
|
|
goto out;
|
2018-02-13 17:50:46 +08:00
|
|
|
if (intarg == 0) {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info,
|
2018-02-13 17:50:46 +08:00
|
|
|
"using default commit interval %us",
|
2016-09-20 22:05:00 +08:00
|
|
|
BTRFS_DEFAULT_COMMIT_INTERVAL);
|
2018-02-13 17:50:46 +08:00
|
|
|
intarg = BTRFS_DEFAULT_COMMIT_INTERVAL;
|
|
|
|
} else if (intarg > 300) {
|
|
|
|
btrfs_warn(info, "excessive commit interval %d",
|
|
|
|
intarg);
|
2013-08-02 00:14:52 +08:00
|
|
|
}
|
2018-02-13 17:50:46 +08:00
|
|
|
info->commit_interval = intarg;
|
2013-08-02 00:14:52 +08:00
|
|
|
break;
|
2020-06-04 15:18:06 +08:00
|
|
|
case Opt_rescue:
|
|
|
|
ret = parse_rescue_options(info, args[0].from);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
break;
|
2015-09-24 02:54:14 +08:00
|
|
|
#ifdef CONFIG_BTRFS_DEBUG
|
|
|
|
case Opt_fragment_all:
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "fragmenting all space");
|
2015-09-24 02:54:14 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
|
|
|
|
btrfs_set_opt(info->mount_opt, FRAGMENT_METADATA);
|
|
|
|
break;
|
|
|
|
case Opt_fragment_metadata:
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "fragmenting metadata");
|
2015-09-24 02:54:14 +08:00
|
|
|
btrfs_set_opt(info->mount_opt,
|
|
|
|
FRAGMENT_METADATA);
|
|
|
|
break;
|
|
|
|
case Opt_fragment_data:
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "fragmenting data");
|
2015-09-24 02:54:14 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
|
|
|
|
break;
|
2017-09-30 03:43:48 +08:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_BTRFS_FS_REF_VERIFY
|
|
|
|
case Opt_ref_verify:
|
|
|
|
btrfs_info(info, "doing ref verification");
|
|
|
|
btrfs_set_opt(info->mount_opt, REF_VERIFY);
|
|
|
|
break;
|
2015-09-24 02:54:14 +08:00
|
|
|
#endif
|
2009-11-07 14:19:16 +08:00
|
|
|
case Opt_err:
|
2019-11-27 23:02:05 +08:00
|
|
|
btrfs_err(info, "unrecognized mount option '%s'", p);
|
2009-11-07 14:19:16 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2007-08-29 21:11:44 +08:00
|
|
|
default:
|
2007-12-18 09:14:01 +08:00
|
|
|
break;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
}
|
2016-01-19 10:23:03 +08:00
|
|
|
check:
|
|
|
|
/*
|
|
|
|
* Extra check for current option against current flag
|
|
|
|
*/
|
2017-11-28 05:05:09 +08:00
|
|
|
if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & SB_RDONLY)) {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_err(info,
|
2016-01-19 10:23:03 +08:00
|
|
|
"nologreplay must be used with ro mount option");
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2009-11-07 14:19:16 +08:00
|
|
|
out:
|
2016-06-23 06:54:23 +08:00
|
|
|
if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE) &&
|
2016-06-10 09:38:35 +08:00
|
|
|
!btrfs_test_opt(info, FREE_SPACE_TREE) &&
|
|
|
|
!btrfs_test_opt(info, CLEAR_CACHE)) {
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_err(info, "cannot disable free space tree");
|
2015-09-30 11:50:38 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
|
|
|
|
}
|
2016-06-10 09:38:35 +08:00
|
|
|
if (!ret && btrfs_test_opt(info, SPACE_CACHE))
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "disk space caching is enabled");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (!ret && btrfs_test_opt(info, FREE_SPACE_TREE))
|
2016-06-23 06:54:23 +08:00
|
|
|
btrfs_info(info, "using free space tree");
|
2009-11-07 14:19:16 +08:00
|
|
|
return ret;
|
2008-06-10 22:40:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse mount options that are required early in the mount process.
|
|
|
|
*
|
|
|
|
* All other options will be parsed on much later in the mount process and
|
|
|
|
* only when we need to allocate a new super block.
|
|
|
|
*/
|
2018-07-16 22:18:07 +08:00
|
|
|
static int btrfs_parse_device_options(const char *options, fmode_t flags,
|
|
|
|
void *holder)
|
2008-06-10 22:40:29 +08:00
|
|
|
{
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
2011-09-14 14:11:21 +08:00
|
|
|
char *device_name, *opts, *orig, *p;
|
2018-07-12 14:23:16 +08:00
|
|
|
struct btrfs_device *device = NULL;
|
2017-12-14 16:25:28 +08:00
|
|
|
int error = 0;
|
|
|
|
|
2018-06-19 23:50:25 +08:00
|
|
|
lockdep_assert_held(&uuid_mutex);
|
|
|
|
|
2017-12-14 16:25:28 +08:00
|
|
|
if (!options)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* strsep changes the string, duplicate it because btrfs_parse_options
|
|
|
|
* gets called later
|
|
|
|
*/
|
|
|
|
opts = kstrdup(options, GFP_KERNEL);
|
|
|
|
if (!opts)
|
|
|
|
return -ENOMEM;
|
|
|
|
orig = opts;
|
|
|
|
|
|
|
|
while ((p = strsep(&opts, ",")) != NULL) {
|
|
|
|
int token;
|
|
|
|
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
token = match_token(p, tokens, args);
|
|
|
|
if (token == Opt_device) {
|
|
|
|
device_name = match_strdup(&args[0]);
|
|
|
|
if (!device_name) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2018-07-12 14:23:16 +08:00
|
|
|
device = btrfs_scan_one_device(device_name, flags,
|
|
|
|
holder);
|
2017-12-14 16:25:28 +08:00
|
|
|
kfree(device_name);
|
2018-07-12 14:23:16 +08:00
|
|
|
if (IS_ERR(device)) {
|
|
|
|
error = PTR_ERR(device);
|
2017-12-14 16:25:28 +08:00
|
|
|
goto out;
|
2018-07-12 14:23:16 +08:00
|
|
|
}
|
2017-12-14 16:25:28 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(orig);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse mount options that are related to subvolume id
|
|
|
|
*
|
|
|
|
* The value is later passed to mount_subvol()
|
|
|
|
*/
|
2018-07-09 14:39:15 +08:00
|
|
|
static int btrfs_parse_subvol_options(const char *options, char **subvol_name,
|
|
|
|
u64 *subvol_objectid)
|
2017-12-14 16:25:28 +08:00
|
|
|
{
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
char *opts, *orig, *p;
|
2008-06-10 22:40:29 +08:00
|
|
|
int error = 0;
|
2018-02-15 01:11:37 +08:00
|
|
|
u64 subvolid;
|
2008-06-10 22:40:29 +08:00
|
|
|
|
|
|
|
if (!options)
|
2011-07-26 03:55:42 +08:00
|
|
|
return 0;
|
2008-06-10 22:40:29 +08:00
|
|
|
|
|
|
|
/*
|
2017-12-14 16:25:28 +08:00
|
|
|
* strsep changes the string, duplicate it because
|
2018-07-16 22:18:07 +08:00
|
|
|
* btrfs_parse_device_options gets called later
|
2008-06-10 22:40:29 +08:00
|
|
|
*/
|
|
|
|
opts = kstrdup(options, GFP_KERNEL);
|
|
|
|
if (!opts)
|
|
|
|
return -ENOMEM;
|
2010-12-27 16:43:13 +08:00
|
|
|
orig = opts;
|
2008-06-10 22:40:29 +08:00
|
|
|
|
|
|
|
while ((p = strsep(&opts, ",")) != NULL) {
|
|
|
|
int token;
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
token = match_token(p, tokens, args);
|
|
|
|
switch (token) {
|
|
|
|
case Opt_subvol:
|
2011-11-08 22:47:55 +08:00
|
|
|
kfree(*subvol_name);
|
2008-06-10 22:40:29 +08:00
|
|
|
*subvol_name = match_strdup(&args[0]);
|
2013-07-24 10:29:05 +08:00
|
|
|
if (!*subvol_name) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2008-06-10 22:40:29 +08:00
|
|
|
break;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
case Opt_subvolid:
|
2018-02-15 01:11:37 +08:00
|
|
|
error = match_u64(&args[0], &subvolid);
|
|
|
|
if (error)
|
2013-07-24 10:29:05 +08:00
|
|
|
goto out;
|
2018-02-15 01:11:37 +08:00
|
|
|
|
|
|
|
/* we want the original fs_tree */
|
|
|
|
if (subvolid == 0)
|
|
|
|
subvolid = BTRFS_FS_TREE_OBJECTID;
|
|
|
|
|
|
|
|
*subvol_objectid = subvolid;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
break;
|
2008-06-10 22:40:29 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-26 03:55:42 +08:00
|
|
|
out:
|
2010-12-27 16:43:13 +08:00
|
|
|
kfree(orig);
|
2008-06-10 22:40:29 +08:00
|
|
|
return error;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
2020-02-21 21:56:12 +08:00
|
|
|
char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 subvol_objectid)
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
{
|
2011-11-18 04:40:49 +08:00
|
|
|
struct btrfs_root *root = fs_info->tree_root;
|
2020-02-06 23:24:26 +08:00
|
|
|
struct btrfs_root *fs_root = NULL;
|
2015-05-18 17:16:30 +08:00
|
|
|
struct btrfs_root_ref *root_ref;
|
|
|
|
struct btrfs_inode_ref *inode_ref;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_path *path = NULL;
|
|
|
|
char *name = NULL, *ptr;
|
|
|
|
u64 dirid;
|
|
|
|
int len;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
path->leave_spinning = 1;
|
|
|
|
|
2017-06-22 08:26:54 +08:00
|
|
|
name = kmalloc(PATH_MAX, GFP_KERNEL);
|
2015-05-18 17:16:30 +08:00
|
|
|
if (!name) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
ptr = name + PATH_MAX - 1;
|
|
|
|
ptr[0] = '\0';
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
|
|
|
|
/*
|
2015-05-18 17:16:30 +08:00
|
|
|
* Walk up the subvolume trees in the tree of tree roots by root
|
|
|
|
* backrefs until we hit the top-level subvolume.
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
*/
|
2015-05-18 17:16:30 +08:00
|
|
|
while (subvol_objectid != BTRFS_FS_TREE_OBJECTID) {
|
|
|
|
key.objectid = subvol_objectid;
|
|
|
|
key.type = BTRFS_ROOT_BACKREF_KEY;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto err;
|
|
|
|
} else if (ret > 0) {
|
|
|
|
ret = btrfs_previous_item(root, path, subvol_objectid,
|
|
|
|
BTRFS_ROOT_BACKREF_KEY);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto err;
|
|
|
|
} else if (ret > 0) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
|
|
|
|
subvol_objectid = key.offset;
|
|
|
|
|
|
|
|
root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_root_ref);
|
|
|
|
len = btrfs_root_ref_name_len(path->nodes[0], root_ref);
|
|
|
|
ptr -= len + 1;
|
|
|
|
if (ptr < name) {
|
|
|
|
ret = -ENAMETOOLONG;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
read_extent_buffer(path->nodes[0], ptr + 1,
|
|
|
|
(unsigned long)(root_ref + 1), len);
|
|
|
|
ptr[0] = '/';
|
|
|
|
dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref);
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
2020-05-16 01:35:55 +08:00
|
|
|
fs_root = btrfs_get_fs_root(fs_info, subvol_objectid, true);
|
2015-05-18 17:16:30 +08:00
|
|
|
if (IS_ERR(fs_root)) {
|
|
|
|
ret = PTR_ERR(fs_root);
|
2020-02-06 23:24:26 +08:00
|
|
|
fs_root = NULL;
|
|
|
|
goto err;
|
|
|
|
}
|
2015-05-18 17:16:30 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk up the filesystem tree by inode refs until we hit the
|
|
|
|
* root directory.
|
|
|
|
*/
|
|
|
|
while (dirid != BTRFS_FIRST_FREE_OBJECTID) {
|
|
|
|
key.objectid = dirid;
|
|
|
|
key.type = BTRFS_INODE_REF_KEY;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, fs_root, &key, path, 0, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto err;
|
|
|
|
} else if (ret > 0) {
|
|
|
|
ret = btrfs_previous_item(fs_root, path, dirid,
|
|
|
|
BTRFS_INODE_REF_KEY);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto err;
|
|
|
|
} else if (ret > 0) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
|
|
|
|
dirid = key.offset;
|
|
|
|
|
|
|
|
inode_ref = btrfs_item_ptr(path->nodes[0],
|
|
|
|
path->slots[0],
|
|
|
|
struct btrfs_inode_ref);
|
|
|
|
len = btrfs_inode_ref_name_len(path->nodes[0],
|
|
|
|
inode_ref);
|
|
|
|
ptr -= len + 1;
|
|
|
|
if (ptr < name) {
|
|
|
|
ret = -ENAMETOOLONG;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
read_extent_buffer(path->nodes[0], ptr + 1,
|
|
|
|
(unsigned long)(inode_ref + 1), len);
|
|
|
|
ptr[0] = '/';
|
|
|
|
btrfs_release_path(path);
|
|
|
|
}
|
2020-01-24 22:33:01 +08:00
|
|
|
btrfs_put_root(fs_root);
|
2020-02-06 23:24:26 +08:00
|
|
|
fs_root = NULL;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
}
|
|
|
|
|
2015-05-18 17:16:30 +08:00
|
|
|
btrfs_free_path(path);
|
|
|
|
if (ptr == name + PATH_MAX - 1) {
|
|
|
|
name[0] = '/';
|
|
|
|
name[1] = '\0';
|
|
|
|
} else {
|
|
|
|
memmove(name, ptr, name + PATH_MAX - ptr);
|
|
|
|
}
|
|
|
|
return name;
|
|
|
|
|
|
|
|
err:
|
2020-01-24 22:33:01 +08:00
|
|
|
btrfs_put_root(fs_root);
|
2015-05-18 17:16:30 +08:00
|
|
|
btrfs_free_path(path);
|
|
|
|
kfree(name);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid)
|
|
|
|
{
|
|
|
|
struct btrfs_root *root = fs_info->tree_root;
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_key location;
|
|
|
|
u64 dir_id;
|
|
|
|
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
2015-05-18 17:16:30 +08:00
|
|
|
return -ENOMEM;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
path->leave_spinning = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the "default" dir item which points to the root item that we
|
|
|
|
* will mount by default if we haven't been given a specific subvolume
|
|
|
|
* to mount.
|
|
|
|
*/
|
2011-11-18 04:40:49 +08:00
|
|
|
dir_id = btrfs_super_root_dir(fs_info->super_copy);
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
|
2011-05-14 15:10:51 +08:00
|
|
|
if (IS_ERR(di)) {
|
|
|
|
btrfs_free_path(path);
|
2015-05-18 17:16:30 +08:00
|
|
|
return PTR_ERR(di);
|
2011-05-14 15:10:51 +08:00
|
|
|
}
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
if (!di) {
|
|
|
|
/*
|
|
|
|
* Ok the default dir item isn't there. This is weird since
|
|
|
|
* it's always been there, but don't freak out, just try and
|
2015-05-18 17:16:30 +08:00
|
|
|
* mount the top-level subvolume.
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
*/
|
|
|
|
btrfs_free_path(path);
|
2015-05-18 17:16:30 +08:00
|
|
|
*objectid = BTRFS_FS_TREE_OBJECTID;
|
|
|
|
return 0;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
|
|
|
|
btrfs_free_path(path);
|
2015-05-18 17:16:30 +08:00
|
|
|
*objectid = location.objectid;
|
|
|
|
return 0;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
}
|
|
|
|
|
2009-01-06 10:25:51 +08:00
|
|
|
static int btrfs_fill_super(struct super_block *sb,
|
2008-03-25 03:02:07 +08:00
|
|
|
struct btrfs_fs_devices *fs_devices,
|
2017-02-11 02:44:31 +08:00
|
|
|
void *data)
|
2007-03-29 23:56:46 +08:00
|
|
|
{
|
2009-01-06 10:25:51 +08:00
|
|
|
struct inode *inode;
|
2011-11-18 04:40:49 +08:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(sb);
|
2007-06-12 18:35:45 +08:00
|
|
|
int err;
|
2007-04-19 04:15:28 +08:00
|
|
|
|
2007-06-12 18:35:45 +08:00
|
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
|
|
|
sb->s_magic = BTRFS_SUPER_MAGIC;
|
|
|
|
sb->s_op = &btrfs_super_ops;
|
2010-12-20 23:56:06 +08:00
|
|
|
sb->s_d_op = &btrfs_dentry_operations;
|
2008-07-21 04:31:56 +08:00
|
|
|
sb->s_export_op = &btrfs_export_ops;
|
2007-11-17 00:45:54 +08:00
|
|
|
sb->s_xattr = btrfs_xattr_handlers;
|
2007-06-12 18:35:45 +08:00
|
|
|
sb->s_time_gran = 1;
|
2009-10-14 01:50:18 +08:00
|
|
|
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
|
2017-11-28 05:05:09 +08:00
|
|
|
sb->s_flags |= SB_POSIXACL;
|
2009-09-30 01:51:04 +08:00
|
|
|
#endif
|
2017-10-19 04:56:26 +08:00
|
|
|
sb->s_flags |= SB_I_VERSION;
|
2015-07-03 04:57:22 +08:00
|
|
|
sb->s_iflags |= SB_I_CGROUPWB;
|
2017-04-12 18:24:32 +08:00
|
|
|
|
|
|
|
err = super_setup_bdi(sb);
|
|
|
|
if (err) {
|
|
|
|
btrfs_err(fs_info, "super_setup_bdi failed");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-11-17 14:10:02 +08:00
|
|
|
err = open_ctree(sb, fs_devices, (char *)data);
|
|
|
|
if (err) {
|
2016-09-20 22:05:02 +08:00
|
|
|
btrfs_err(fs_info, "open_ctree failed");
|
2011-11-17 14:10:02 +08:00
|
|
|
return err;
|
2007-04-19 04:15:28 +08:00
|
|
|
}
|
|
|
|
|
2020-05-16 01:35:59 +08:00
|
|
|
inode = btrfs_iget(sb, BTRFS_FIRST_FREE_OBJECTID, fs_info->fs_root);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 22:45:14 +08:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
err = PTR_ERR(inode);
|
2007-06-12 18:35:45 +08:00
|
|
|
goto fail_close;
|
2007-03-30 03:15:27 +08:00
|
|
|
}
|
|
|
|
|
2012-01-09 11:15:13 +08:00
|
|
|
sb->s_root = d_make_root(inode);
|
|
|
|
if (!sb->s_root) {
|
2007-06-12 18:35:45 +08:00
|
|
|
err = -ENOMEM;
|
|
|
|
goto fail_close;
|
2007-03-30 03:15:27 +08:00
|
|
|
}
|
2007-08-30 03:47:34 +08:00
|
|
|
|
2011-05-27 00:01:56 +08:00
|
|
|
cleancache_init_fs(sb);
|
2017-11-28 05:05:09 +08:00
|
|
|
sb->s_flags |= SB_ACTIVE;
|
2007-04-11 04:58:11 +08:00
|
|
|
return 0;
|
2007-06-12 18:35:45 +08:00
|
|
|
|
|
|
|
fail_close:
|
2016-06-22 09:16:51 +08:00
|
|
|
close_ctree(fs_info);
|
2007-06-12 18:35:45 +08:00
|
|
|
return err;
|
2007-04-11 04:58:11 +08:00
|
|
|
}
|
|
|
|
|
2008-06-10 22:07:39 +08:00
|
|
|
int btrfs_sync_fs(struct super_block *sb, int wait)
|
2007-04-10 21:27:04 +08:00
|
|
|
{
|
|
|
|
struct btrfs_trans_handle *trans;
|
2011-11-18 04:40:49 +08:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(sb);
|
|
|
|
struct btrfs_root *root = fs_info->tree_root;
|
2007-04-11 04:58:11 +08:00
|
|
|
|
2016-06-10 05:27:55 +08:00
|
|
|
trace_btrfs_sync_fs(fs_info, wait);
|
Btrfs: add initial tracepoint support for btrfs
Tracepoints can provide insight into why btrfs hits bugs and be greatly
helpful for debugging, e.g
dd-7822 [000] 2121.641088: btrfs_inode_request: root = 5(FS_TREE), gen = 4, ino = 256, blocks = 8, disk_i_size = 0, last_trans = 8, logged_trans = 0
dd-7822 [000] 2121.641100: btrfs_inode_new: root = 5(FS_TREE), gen = 8, ino = 257, blocks = 0, disk_i_size = 0, last_trans = 0, logged_trans = 0
btrfs-transacti-7804 [001] 2146.935420: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29368320 (orig_level = 0), cow_buf = 29388800 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.935473: btrfs_cow_block: root = 1(ROOT_TREE), refs = 2, orig_buf = 29364224 (orig_level = 0), cow_buf = 29392896 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.972221: btrfs_transaction_commit: root = 1(ROOT_TREE), gen = 8
flush-btrfs-2-7821 [001] 2155.824210: btrfs_chunk_alloc: root = 3(CHUNK_TREE), offset = 1103101952, size = 1073741824, num_stripes = 1, sub_stripes = 0, type = DATA
flush-btrfs-2-7821 [001] 2155.824241: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29388800 (orig_level = 0), cow_buf = 29396992 (cow_level = 0)
flush-btrfs-2-7821 [001] 2155.824255: btrfs_cow_block: root = 4(DEV_TREE), refs = 2, orig_buf = 29372416 (orig_level = 0), cow_buf = 29401088 (cow_level = 0)
flush-btrfs-2-7821 [000] 2155.824329: btrfs_cow_block: root = 3(CHUNK_TREE), refs = 2, orig_buf = 20971520 (orig_level = 0), cow_buf = 20975616 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898019: btrfs_cow_block: root = 5(FS_TREE), refs = 2, orig_buf = 29384704 (orig_level = 0), cow_buf = 29405184 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898043: btrfs_cow_block: root = 7(CSUM_TREE), refs = 2, orig_buf = 29376512 (orig_level = 0), cow_buf = 29409280 (cow_level = 0)
Here is what I have added:
1) ordere_extent:
btrfs_ordered_extent_add
btrfs_ordered_extent_remove
btrfs_ordered_extent_start
btrfs_ordered_extent_put
These provide critical information to understand how ordered_extents are
updated.
2) extent_map:
btrfs_get_extent
extent_map is used in both read and write cases, and it is useful for tracking
how btrfs specific IO is running.
3) writepage:
__extent_writepage
btrfs_writepage_end_io_hook
Pages are cirtical resourses and produce a lot of corner cases during writeback,
so it is valuable to know how page is written to disk.
4) inode:
btrfs_inode_new
btrfs_inode_request
btrfs_inode_evict
These can show where and when a inode is created, when a inode is evicted.
5) sync:
btrfs_sync_file
btrfs_sync_fs
These show sync arguments.
6) transaction:
btrfs_transaction_commit
In transaction based filesystem, it will be useful to know the generation and
who does commit.
7) back reference and cow:
btrfs_delayed_tree_ref
btrfs_delayed_data_ref
btrfs_delayed_ref_head
btrfs_cow_block
Btrfs natively supports back references, these tracepoints are helpful on
understanding btrfs's COW mechanism.
8) chunk:
btrfs_chunk_alloc
btrfs_chunk_free
Chunk is a link between physical offset and logical offset, and stands for space
infomation in btrfs, and these are helpful on tracing space things.
9) reserved_extent:
btrfs_reserved_extent_alloc
btrfs_reserved_extent_free
These can show how btrfs uses its space.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-24 19:18:59 +08:00
|
|
|
|
2007-06-12 18:35:45 +08:00
|
|
|
if (!wait) {
|
2011-11-18 04:40:49 +08:00
|
|
|
filemap_flush(fs_info->btree_inode->i_mapping);
|
2007-06-12 18:35:45 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2008-11-07 11:02:51 +08:00
|
|
|
|
2017-06-24 00:48:21 +08:00
|
|
|
btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
|
2008-11-07 11:02:51 +08:00
|
|
|
|
Btrfs: fix uncompleted transaction
In some cases, we need commit the current transaction, but don't want
to start a new one if there is no running transaction, so we introduce
the function - btrfs_attach_transaction(), which can catch the current
transaction, and return -ENOENT if there is no running transaction.
But no running transaction doesn't mean the current transction completely,
because we removed the running transaction before it completes. In some
cases, it doesn't matter. But in some special cases, such as freeze fs, we
hope the transaction is fully on disk, it will introduce some bugs, for
example, we may feeze the fs and dump the data in the disk, if the transction
doesn't complete, we would dump inconsistent data. So we need fix the above
problem for those cases.
We fixes this problem by introducing a function:
btrfs_attach_transaction_barrier()
if we hope all the transaction is fully on the disk, even they are not
running, we can use this function.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2013-02-20 17:17:06 +08:00
|
|
|
trans = btrfs_attach_transaction_barrier(root);
|
2012-09-14 22:34:40 +08:00
|
|
|
if (IS_ERR(trans)) {
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
/* no transaction, don't bother */
|
2014-03-29 00:38:48 +08:00
|
|
|
if (PTR_ERR(trans) == -ENOENT) {
|
|
|
|
/*
|
|
|
|
* Exit unless we have some pending changes
|
|
|
|
* that need to go through commit
|
|
|
|
*/
|
|
|
|
if (fs_info->pending_changes == 0)
|
|
|
|
return 0;
|
2015-01-19 15:42:41 +08:00
|
|
|
/*
|
|
|
|
* A non-blocking test if the fs is frozen. We must not
|
|
|
|
* start a new transaction here otherwise a deadlock
|
|
|
|
* happens. The pending operations are delayed to the
|
|
|
|
* next commit after thawing.
|
|
|
|
*/
|
2017-10-10 18:48:05 +08:00
|
|
|
if (sb_start_write_trylock(sb))
|
|
|
|
sb_end_write(sb);
|
2015-01-19 15:42:41 +08:00
|
|
|
else
|
|
|
|
return 0;
|
2014-03-29 00:38:48 +08:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
|
|
|
}
|
2015-01-19 21:21:02 +08:00
|
|
|
if (IS_ERR(trans))
|
|
|
|
return PTR_ERR(trans);
|
2012-09-14 22:34:40 +08:00
|
|
|
}
|
2016-09-10 09:39:03 +08:00
|
|
|
return btrfs_commit_transaction(trans);
|
2007-04-02 22:50:19 +08:00
|
|
|
}
|
|
|
|
|
2011-12-09 10:32:45 +08:00
|
|
|
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
|
2009-04-03 04:46:06 +08:00
|
|
|
{
|
2011-11-18 04:40:49 +08:00
|
|
|
struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
|
2017-11-01 01:06:34 +08:00
|
|
|
const char *compress_type;
|
2009-04-03 04:46:06 +08:00
|
|
|
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, DEGRADED))
|
2009-04-03 04:46:06 +08:00
|
|
|
seq_puts(seq, ",degraded");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, NODATASUM))
|
2009-04-03 04:46:06 +08:00
|
|
|
seq_puts(seq, ",nodatasum");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, NODATACOW))
|
2009-04-03 04:46:06 +08:00
|
|
|
seq_puts(seq, ",nodatacow");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, NOBARRIER))
|
2009-04-03 04:46:06 +08:00
|
|
|
seq_puts(seq, ",nobarrier");
|
2013-08-09 05:45:48 +08:00
|
|
|
if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE)
|
2013-08-20 19:20:07 +08:00
|
|
|
seq_printf(seq, ",max_inline=%llu", info->max_inline);
|
2009-04-03 04:46:06 +08:00
|
|
|
if (info->thread_pool_size != min_t(unsigned long,
|
|
|
|
num_online_cpus() + 2, 8))
|
2018-02-13 17:50:42 +08:00
|
|
|
seq_printf(seq, ",thread_pool=%u", info->thread_pool_size);
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, COMPRESS)) {
|
2017-11-01 01:06:34 +08:00
|
|
|
compress_type = btrfs_compress_type2str(info->compress_type);
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, FORCE_COMPRESS))
|
2011-03-31 08:44:29 +08:00
|
|
|
seq_printf(seq, ",compress-force=%s", compress_type);
|
|
|
|
else
|
|
|
|
seq_printf(seq, ",compress=%s", compress_type);
|
2017-09-15 23:36:57 +08:00
|
|
|
if (info->compress_level)
|
2017-09-15 23:36:58 +08:00
|
|
|
seq_printf(seq, ":%d", info->compress_level);
|
2011-03-31 08:44:29 +08:00
|
|
|
}
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, NOSSD))
|
2009-06-10 21:51:32 +08:00
|
|
|
seq_puts(seq, ",nossd");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, SSD_SPREAD))
|
2009-06-10 08:28:34 +08:00
|
|
|
seq_puts(seq, ",ssd_spread");
|
2016-06-10 09:38:35 +08:00
|
|
|
else if (btrfs_test_opt(info, SSD))
|
2009-04-03 04:46:06 +08:00
|
|
|
seq_puts(seq, ",ssd");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, NOTREELOG))
|
2009-05-15 01:52:21 +08:00
|
|
|
seq_puts(seq, ",notreelog");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, NOLOGREPLAY))
|
2020-06-04 15:18:06 +08:00
|
|
|
seq_puts(seq, ",rescue=nologreplay");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, FLUSHONCOMMIT))
|
2009-05-15 01:52:21 +08:00
|
|
|
seq_puts(seq, ",flushoncommit");
|
2019-12-14 08:22:11 +08:00
|
|
|
if (btrfs_test_opt(info, DISCARD_SYNC))
|
2009-12-15 06:01:12 +08:00
|
|
|
seq_puts(seq, ",discard");
|
2019-12-14 08:22:14 +08:00
|
|
|
if (btrfs_test_opt(info, DISCARD_ASYNC))
|
|
|
|
seq_puts(seq, ",discard=async");
|
2017-11-28 05:05:09 +08:00
|
|
|
if (!(info->sb->s_flags & SB_POSIXACL))
|
2009-04-03 04:46:06 +08:00
|
|
|
seq_puts(seq, ",noacl");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, SPACE_CACHE))
|
2011-03-31 08:44:29 +08:00
|
|
|
seq_puts(seq, ",space_cache");
|
2016-06-10 09:38:35 +08:00
|
|
|
else if (btrfs_test_opt(info, FREE_SPACE_TREE))
|
2015-09-30 11:50:38 +08:00
|
|
|
seq_puts(seq, ",space_cache=v2");
|
2011-10-04 02:07:49 +08:00
|
|
|
else
|
2011-11-11 23:14:57 +08:00
|
|
|
seq_puts(seq, ",nospace_cache");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, RESCAN_UUID_TREE))
|
2013-08-15 23:11:24 +08:00
|
|
|
seq_puts(seq, ",rescan_uuid_tree");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, CLEAR_CACHE))
|
2011-03-31 08:44:29 +08:00
|
|
|
seq_puts(seq, ",clear_cache");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, USER_SUBVOL_RM_ALLOWED))
|
2011-03-31 08:44:29 +08:00
|
|
|
seq_puts(seq, ",user_subvol_rm_allowed");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, ENOSPC_DEBUG))
|
2011-06-28 23:10:37 +08:00
|
|
|
seq_puts(seq, ",enospc_debug");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, AUTO_DEFRAG))
|
2011-06-28 23:10:37 +08:00
|
|
|
seq_puts(seq, ",autodefrag");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, INODE_MAP_CACHE))
|
2011-06-28 23:10:37 +08:00
|
|
|
seq_puts(seq, ",inode_cache");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, SKIP_BALANCE))
|
2012-01-17 04:04:48 +08:00
|
|
|
seq_puts(seq, ",skip_balance");
|
2013-07-24 10:30:02 +08:00
|
|
|
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
|
2013-07-24 10:30:02 +08:00
|
|
|
seq_puts(seq, ",check_int_data");
|
2016-06-10 09:38:35 +08:00
|
|
|
else if (btrfs_test_opt(info, CHECK_INTEGRITY))
|
2013-07-24 10:30:02 +08:00
|
|
|
seq_puts(seq, ",check_int");
|
|
|
|
if (info->check_integrity_print_mask)
|
|
|
|
seq_printf(seq, ",check_int_print_mask=%d",
|
|
|
|
info->check_integrity_print_mask);
|
|
|
|
#endif
|
|
|
|
if (info->metadata_ratio)
|
2018-02-13 17:50:44 +08:00
|
|
|
seq_printf(seq, ",metadata_ratio=%u", info->metadata_ratio);
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, PANIC_ON_FATAL_ERROR))
|
2011-10-04 11:22:31 +08:00
|
|
|
seq_puts(seq, ",fatal_errors=panic");
|
2013-08-02 00:14:52 +08:00
|
|
|
if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
|
2018-02-13 17:50:46 +08:00
|
|
|
seq_printf(seq, ",commit=%u", info->commit_interval);
|
2015-09-24 02:54:14 +08:00
|
|
|
#ifdef CONFIG_BTRFS_DEBUG
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, FRAGMENT_DATA))
|
2015-09-24 02:54:14 +08:00
|
|
|
seq_puts(seq, ",fragment=data");
|
2016-06-10 09:38:35 +08:00
|
|
|
if (btrfs_test_opt(info, FRAGMENT_METADATA))
|
2015-09-24 02:54:14 +08:00
|
|
|
seq_puts(seq, ",fragment=metadata");
|
|
|
|
#endif
|
2017-09-30 03:43:48 +08:00
|
|
|
if (btrfs_test_opt(info, REF_VERIFY))
|
|
|
|
seq_puts(seq, ",ref_verify");
|
2015-05-18 17:16:31 +08:00
|
|
|
seq_printf(seq, ",subvolid=%llu",
|
|
|
|
BTRFS_I(d_inode(dentry))->root->root_key.objectid);
|
|
|
|
seq_puts(seq, ",subvol=");
|
|
|
|
seq_dentry(seq, dentry, " \t\n\\");
|
2009-04-03 04:46:06 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-07 23:43:44 +08:00
|
|
|
static int btrfs_test_super(struct super_block *s, void *data)
|
2007-08-29 21:11:44 +08:00
|
|
|
{
|
2011-11-18 04:40:49 +08:00
|
|
|
struct btrfs_fs_info *p = data;
|
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(s);
|
2007-08-29 21:11:44 +08:00
|
|
|
|
2011-11-18 04:40:49 +08:00
|
|
|
return fs_info->fs_devices == p->fs_devices;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
2010-11-20 03:59:15 +08:00
|
|
|
static int btrfs_set_super(struct super_block *s, void *data)
|
|
|
|
{
|
2011-11-17 14:29:09 +08:00
|
|
|
int err = set_anon_super(s, data);
|
|
|
|
if (!err)
|
|
|
|
s->s_fs_info = data;
|
|
|
|
return err;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
2011-09-29 19:11:33 +08:00
|
|
|
/*
|
|
|
|
* subvolumes are identified by ino 256
|
|
|
|
*/
|
|
|
|
static inline int is_subvolume_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-18 17:16:29 +08:00
|
|
|
static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid,
|
2019-03-29 14:03:17 +08:00
|
|
|
struct vfsmount *mnt)
|
2011-07-26 03:55:42 +08:00
|
|
|
{
|
|
|
|
struct dentry *root;
|
2015-05-18 17:16:28 +08:00
|
|
|
int ret;
|
2011-07-26 03:55:42 +08:00
|
|
|
|
2015-05-18 17:16:30 +08:00
|
|
|
if (!subvol_name) {
|
|
|
|
if (!subvol_objectid) {
|
|
|
|
ret = get_default_subvol_objectid(btrfs_sb(mnt->mnt_sb),
|
|
|
|
&subvol_objectid);
|
|
|
|
if (ret) {
|
|
|
|
root = ERR_PTR(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2020-02-21 21:56:12 +08:00
|
|
|
subvol_name = btrfs_get_subvol_name_from_objectid(
|
|
|
|
btrfs_sb(mnt->mnt_sb), subvol_objectid);
|
2015-05-18 17:16:30 +08:00
|
|
|
if (IS_ERR(subvol_name)) {
|
|
|
|
root = ERR_CAST(subvol_name);
|
|
|
|
subvol_name = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2011-11-17 10:43:59 +08:00
|
|
|
root = mount_subtree(mnt, subvol_name);
|
2015-05-18 17:16:28 +08:00
|
|
|
/* mount_subtree() drops our reference on the vfsmount. */
|
|
|
|
mnt = NULL;
|
2011-07-26 03:55:42 +08:00
|
|
|
|
2015-05-18 17:16:29 +08:00
|
|
|
if (!IS_ERR(root)) {
|
2011-11-17 10:43:59 +08:00
|
|
|
struct super_block *s = root->d_sb;
|
2016-09-20 22:05:02 +08:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(s);
|
2015-05-18 17:16:29 +08:00
|
|
|
struct inode *root_inode = d_inode(root);
|
|
|
|
u64 root_objectid = BTRFS_I(root_inode)->root->root_key.objectid;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
if (!is_subvolume_inode(root_inode)) {
|
2016-09-20 22:05:02 +08:00
|
|
|
btrfs_err(fs_info, "'%s' is not a valid subvolume",
|
2015-05-18 17:16:29 +08:00
|
|
|
subvol_name);
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
if (subvol_objectid && root_objectid != subvol_objectid) {
|
2015-05-18 17:16:30 +08:00
|
|
|
/*
|
|
|
|
* This will also catch a race condition where a
|
|
|
|
* subvolume which was passed by ID is renamed and
|
|
|
|
* another subvolume is renamed over the old location.
|
|
|
|
*/
|
2016-09-20 22:05:02 +08:00
|
|
|
btrfs_err(fs_info,
|
|
|
|
"subvol '%s' does not match subvolid %llu",
|
|
|
|
subvol_name, subvol_objectid);
|
2015-05-18 17:16:29 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
if (ret) {
|
|
|
|
dput(root);
|
|
|
|
root = ERR_PTR(ret);
|
|
|
|
deactivate_locked_super(s);
|
|
|
|
}
|
2011-09-29 19:11:33 +08:00
|
|
|
}
|
|
|
|
|
2015-05-18 17:16:28 +08:00
|
|
|
out:
|
|
|
|
mntput(mnt);
|
|
|
|
kfree(subvol_name);
|
2011-07-26 03:55:42 +08:00
|
|
|
return root;
|
|
|
|
}
|
2010-11-20 03:59:15 +08:00
|
|
|
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
/*
|
|
|
|
* Find a superblock for the given device / mount point.
|
|
|
|
*
|
|
|
|
* Note: This is based on mount_bdev from fs/super.c with a few additions
|
|
|
|
* for multiple device setup. Make sure to keep it in sync.
|
|
|
|
*/
|
2017-12-14 16:24:30 +08:00
|
|
|
static struct dentry *btrfs_mount_root(struct file_system_type *fs_type,
|
|
|
|
int flags, const char *device_name, void *data)
|
|
|
|
{
|
|
|
|
struct block_device *bdev = NULL;
|
|
|
|
struct super_block *s;
|
2018-07-12 14:23:16 +08:00
|
|
|
struct btrfs_device *device = NULL;
|
2017-12-14 16:24:30 +08:00
|
|
|
struct btrfs_fs_devices *fs_devices = NULL;
|
|
|
|
struct btrfs_fs_info *fs_info = NULL;
|
2018-12-14 02:41:47 +08:00
|
|
|
void *new_sec_opts = NULL;
|
2017-12-14 16:24:30 +08:00
|
|
|
fmode_t mode = FMODE_READ;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (!(flags & SB_RDONLY))
|
|
|
|
mode |= FMODE_WRITE;
|
|
|
|
|
|
|
|
if (data) {
|
2018-12-11 06:19:21 +08:00
|
|
|
error = security_sb_eat_lsm_opts(data, &new_sec_opts);
|
2017-12-14 16:24:30 +08:00
|
|
|
if (error)
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup a dummy root and fs_info for test/set super. This is because
|
|
|
|
* we don't actually fill this stuff out until open_ctree, but we need
|
2020-01-24 22:32:59 +08:00
|
|
|
* then open_ctree will properly initialize the file system specific
|
|
|
|
* settings later. btrfs_init_fs_info initializes the static elements
|
|
|
|
* of the fs_info (locks and such) to make cleanup easier if we find a
|
|
|
|
* superblock with our given fs_devices later on at sget() time.
|
2017-12-14 16:24:30 +08:00
|
|
|
*/
|
2018-02-16 11:59:47 +08:00
|
|
|
fs_info = kvzalloc(sizeof(struct btrfs_fs_info), GFP_KERNEL);
|
2017-12-14 16:24:30 +08:00
|
|
|
if (!fs_info) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto error_sec_opts;
|
|
|
|
}
|
2020-01-24 22:32:59 +08:00
|
|
|
btrfs_init_fs_info(fs_info);
|
2017-12-14 16:24:30 +08:00
|
|
|
|
|
|
|
fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);
|
|
|
|
fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);
|
|
|
|
if (!fs_info->super_copy || !fs_info->super_for_commit) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto error_fs_info;
|
|
|
|
}
|
|
|
|
|
2018-06-20 00:01:24 +08:00
|
|
|
mutex_lock(&uuid_mutex);
|
2018-07-16 22:18:07 +08:00
|
|
|
error = btrfs_parse_device_options(data, mode, fs_type);
|
2018-06-20 00:04:07 +08:00
|
|
|
if (error) {
|
|
|
|
mutex_unlock(&uuid_mutex);
|
2018-06-20 00:01:24 +08:00
|
|
|
goto error_fs_info;
|
2018-06-20 00:04:07 +08:00
|
|
|
}
|
2018-06-20 00:01:24 +08:00
|
|
|
|
2018-07-12 14:23:16 +08:00
|
|
|
device = btrfs_scan_one_device(device_name, mode, fs_type);
|
|
|
|
if (IS_ERR(device)) {
|
2018-06-20 00:04:07 +08:00
|
|
|
mutex_unlock(&uuid_mutex);
|
2018-07-12 14:23:16 +08:00
|
|
|
error = PTR_ERR(device);
|
2018-06-20 00:01:24 +08:00
|
|
|
goto error_fs_info;
|
2018-06-20 00:04:07 +08:00
|
|
|
}
|
2018-06-20 00:01:24 +08:00
|
|
|
|
2018-07-12 14:23:16 +08:00
|
|
|
fs_devices = device->fs_devices;
|
2018-06-20 00:01:24 +08:00
|
|
|
fs_info->fs_devices = fs_devices;
|
|
|
|
|
2017-12-14 16:24:30 +08:00
|
|
|
error = btrfs_open_devices(fs_devices, mode, fs_type);
|
2018-06-19 23:09:47 +08:00
|
|
|
mutex_unlock(&uuid_mutex);
|
2017-12-14 16:24:30 +08:00
|
|
|
if (error)
|
|
|
|
goto error_fs_info;
|
|
|
|
|
|
|
|
if (!(flags & SB_RDONLY) && fs_devices->rw_devices == 0) {
|
|
|
|
error = -EACCES;
|
|
|
|
goto error_close_devices;
|
|
|
|
}
|
|
|
|
|
|
|
|
bdev = fs_devices->latest_bdev;
|
|
|
|
s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | SB_NOSEC,
|
|
|
|
fs_info);
|
|
|
|
if (IS_ERR(s)) {
|
|
|
|
error = PTR_ERR(s);
|
|
|
|
goto error_close_devices;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->s_root) {
|
|
|
|
btrfs_close_devices(fs_devices);
|
2020-01-24 22:32:53 +08:00
|
|
|
btrfs_free_fs_info(fs_info);
|
2017-12-14 16:24:30 +08:00
|
|
|
if ((flags ^ s->s_flags) & SB_RDONLY)
|
|
|
|
error = -EBUSY;
|
|
|
|
} else {
|
|
|
|
snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
|
|
|
|
btrfs_sb(s)->bdev_holder = fs_type;
|
btrfs: detect fast implementation of crc32c on all architectures
Currently, there's only check for fast crc32c implementation on X86,
based on the CPU flags. This is used to decide if checksumming should be
offloaded to worker threads or can be calculated by the caller.
As there are more architectures that implement a faster version of
crc32c (ARM, SPARC, s390, MIPS, PowerPC), also there are specialized hw
cards.
The detection is based on driver name, all generic C implementations
contain 'generic', while the specialized versions do not. Alternatively
the priority could be used, but this is not currently provided by the
crypto API.
The flag is set per-filesystem at mount time and used for the offloading
decisions.
Signed-off-by: David Sterba <dsterba@suse.com>
2019-05-16 19:39:59 +08:00
|
|
|
if (!strstr(crc32c_impl(), "generic"))
|
|
|
|
set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
|
2017-12-14 16:24:30 +08:00
|
|
|
error = btrfs_fill_super(s, fs_devices, data);
|
|
|
|
}
|
2018-12-11 06:19:21 +08:00
|
|
|
if (!error)
|
2018-12-14 02:41:47 +08:00
|
|
|
error = security_sb_set_mnt_opts(s, new_sec_opts, 0, NULL);
|
2018-12-11 06:19:21 +08:00
|
|
|
security_free_mnt_opts(&new_sec_opts);
|
2017-12-14 16:24:30 +08:00
|
|
|
if (error) {
|
|
|
|
deactivate_locked_super(s);
|
2018-12-11 06:19:21 +08:00
|
|
|
return ERR_PTR(error);
|
2017-12-14 16:24:30 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return dget(s->s_root);
|
|
|
|
|
|
|
|
error_close_devices:
|
|
|
|
btrfs_close_devices(fs_devices);
|
|
|
|
error_fs_info:
|
2020-01-24 22:32:53 +08:00
|
|
|
btrfs_free_fs_info(fs_info);
|
2017-12-14 16:24:30 +08:00
|
|
|
error_sec_opts:
|
|
|
|
security_free_mnt_opts(&new_sec_opts);
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
|
2008-06-10 22:40:29 +08:00
|
|
|
/*
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
* Mount function which is called by VFS layer.
|
2008-06-10 22:40:29 +08:00
|
|
|
*
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
* In order to allow mounting a subvolume directly, btrfs uses mount_subtree()
|
|
|
|
* which needs vfsmount* of device's root (/). This means device's root has to
|
|
|
|
* be mounted internally in any case.
|
|
|
|
*
|
|
|
|
* Operation flow:
|
|
|
|
* 1. Parse subvol id related options for later use in mount_subvol().
|
|
|
|
*
|
|
|
|
* 2. Mount device's root (/) by calling vfs_kern_mount().
|
|
|
|
*
|
|
|
|
* NOTE: vfs_kern_mount() is used by VFS to call btrfs_mount() in the
|
|
|
|
* first place. In order to avoid calling btrfs_mount() again, we use
|
|
|
|
* different file_system_type which is not registered to VFS by
|
|
|
|
* register_filesystem() (btrfs_root_fs_type). As a result,
|
|
|
|
* btrfs_mount_root() is called. The return value will be used by
|
|
|
|
* mount_subtree() in mount_subvol().
|
|
|
|
*
|
|
|
|
* 3. Call mount_subvol() to get the dentry of subvolume. Since there is
|
|
|
|
* "btrfs subvolume set-default", mount_subvol() is called always.
|
2008-06-10 22:40:29 +08:00
|
|
|
*/
|
2010-07-26 20:21:33 +08:00
|
|
|
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
|
2011-04-19 20:29:38 +08:00
|
|
|
const char *device_name, void *data)
|
2007-08-29 21:11:44 +08:00
|
|
|
{
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
struct vfsmount *mnt_root;
|
|
|
|
struct dentry *root;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
char *subvol_name = NULL;
|
|
|
|
u64 subvol_objectid = 0;
|
2007-08-29 21:11:44 +08:00
|
|
|
int error = 0;
|
|
|
|
|
2018-07-09 14:39:15 +08:00
|
|
|
error = btrfs_parse_subvol_options(data, &subvol_name,
|
|
|
|
&subvol_objectid);
|
2011-11-09 01:15:05 +08:00
|
|
|
if (error) {
|
|
|
|
kfree(subvol_name);
|
2010-07-26 20:21:33 +08:00
|
|
|
return ERR_PTR(error);
|
2011-11-09 01:15:05 +08:00
|
|
|
}
|
2008-06-10 22:40:29 +08:00
|
|
|
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
/* mount device's root (/) */
|
|
|
|
mnt_root = vfs_kern_mount(&btrfs_root_fs_type, flags, device_name, data);
|
|
|
|
if (PTR_ERR_OR_ZERO(mnt_root) == -EBUSY) {
|
|
|
|
if (flags & SB_RDONLY) {
|
|
|
|
mnt_root = vfs_kern_mount(&btrfs_root_fs_type,
|
|
|
|
flags & ~SB_RDONLY, device_name, data);
|
|
|
|
} else {
|
|
|
|
mnt_root = vfs_kern_mount(&btrfs_root_fs_type,
|
|
|
|
flags | SB_RDONLY, device_name, data);
|
|
|
|
if (IS_ERR(mnt_root)) {
|
|
|
|
root = ERR_CAST(mnt_root);
|
2019-01-30 21:54:12 +08:00
|
|
|
kfree(subvol_name);
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2007-08-29 21:11:44 +08:00
|
|
|
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
down_write(&mnt_root->mnt_sb->s_umount);
|
|
|
|
error = btrfs_remount(mnt_root->mnt_sb, &flags, NULL);
|
|
|
|
up_write(&mnt_root->mnt_sb->s_umount);
|
|
|
|
if (error < 0) {
|
|
|
|
root = ERR_PTR(error);
|
|
|
|
mntput(mnt_root);
|
2019-01-30 21:54:12 +08:00
|
|
|
kfree(subvol_name);
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2014-09-23 13:40:08 +08:00
|
|
|
}
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
if (IS_ERR(mnt_root)) {
|
|
|
|
root = ERR_CAST(mnt_root);
|
2019-01-30 21:54:12 +08:00
|
|
|
kfree(subvol_name);
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
goto out;
|
2014-09-23 13:40:08 +08:00
|
|
|
}
|
2007-08-29 21:11:44 +08:00
|
|
|
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
/* mount_subvol() will free subvol_name and mnt_root */
|
2019-03-29 14:03:17 +08:00
|
|
|
root = mount_subvol(subvol_name, subvol_objectid, mnt_root);
|
2007-08-29 21:11:44 +08:00
|
|
|
|
btrfs: cleanup btrfs_mount() using btrfs_mount_root()
Cleanup btrfs_mount() by using btrfs_mount_root(). This avoids getting
btrfs_mount() called twice in mount path.
Old btrfs_mount() will do:
0. VFS layer calls vfs_kern_mount() with registered file_system_type
(for btrfs, btrfs_fs_type). btrfs_mount() is called on the way.
1. btrfs_parse_early_options() parses "subvolid=" mount option and set the
value to subvol_objectid. Otherwise, subvol_objectid has the initial
value of 0
2. check subvol_objectid is 5 or not. Assume this time id is not 5, then
btrfs_mount() returns by calling mount_subvol()
3. In mount_subvol(), original mount options are modified to contain
"subvolid=0" in setup_root_args(). Then, vfs_kern_mount() is called with
btrfs_fs_type and new options
4. btrfs_mount() is called again
5. btrfs_parse_early_options() parses "subvolid=0" and set 5 (instead of 0)
to subvol_objectid
6. check subvol_objectid is 5 or not. This time id is 5 and mount_subvol()
is not called. btrfs_mount() finishes mounting a root
7. (in mount_subvol()) with using a return vale of vfs_kern_mount(), it
calls mount_subtree()
8. return subvolume's dentry
Reusing the same file_system_type (and btrfs_mount()) for vfs_kern_mount()
is the cause of complication.
Instead, new btrfs_mount() will do:
1. parse subvol id related options for later use in mount_subvol()
2. mount device's root by calling vfs_kern_mount() with
btrfs_root_fs_type, which is not registered to VFS by
register_filesystem(). As a result, btrfs_mount_root() is called
3. return by calling mount_subvol()
The code of 2. is moved from the first part of mount_subvol().
The semantics of device holder changes from btrfs_fs_type to
btrfs_root_fs_type and has to be used in all contexts. Otherwise we'd
get wrong results when mount and dev scan would not check the same
thing. (this has been found indendently and the fix is folded into this
patch)
Signed-off-by: Tomohiro Misono <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ fold the btrfs_control_ioctl fixup, extend the comment ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-12-14 16:25:01 +08:00
|
|
|
out:
|
|
|
|
return root;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
2007-03-21 23:12:56 +08:00
|
|
|
|
2012-04-25 03:59:16 +08:00
|
|
|
static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
|
2018-02-13 17:50:42 +08:00
|
|
|
u32 new_pool_size, u32 old_pool_size)
|
2012-04-25 03:59:16 +08:00
|
|
|
{
|
|
|
|
if (new_pool_size == old_pool_size)
|
|
|
|
return;
|
|
|
|
|
|
|
|
fs_info->thread_pool_size = new_pool_size;
|
|
|
|
|
2013-12-21 00:37:06 +08:00
|
|
|
btrfs_info(fs_info, "resize thread pool %d -> %d",
|
2012-04-25 03:59:16 +08:00
|
|
|
old_pool_size, new_pool_size);
|
|
|
|
|
2014-02-28 10:46:06 +08:00
|
|
|
btrfs_workqueue_set_max(fs_info->workers, new_pool_size);
|
2014-02-28 10:46:07 +08:00
|
|
|
btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);
|
2014-02-28 10:46:12 +08:00
|
|
|
btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size);
|
2014-02-28 10:46:10 +08:00
|
|
|
btrfs_workqueue_set_max(fs_info->endio_workers, new_pool_size);
|
|
|
|
btrfs_workqueue_set_max(fs_info->endio_meta_workers, new_pool_size);
|
|
|
|
btrfs_workqueue_set_max(fs_info->endio_meta_write_workers,
|
|
|
|
new_pool_size);
|
|
|
|
btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size);
|
|
|
|
btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size);
|
2014-02-28 10:46:15 +08:00
|
|
|
btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size);
|
2014-02-28 10:46:13 +08:00
|
|
|
btrfs_workqueue_set_max(fs_info->readahead_workers, new_pool_size);
|
2014-02-28 10:46:17 +08:00
|
|
|
btrfs_workqueue_set_max(fs_info->scrub_wr_completion_workers,
|
|
|
|
new_pool_size);
|
2012-04-25 03:59:16 +08:00
|
|
|
}
|
|
|
|
|
2013-04-11 18:29:35 +08:00
|
|
|
static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
|
2013-02-21 14:32:52 +08:00
|
|
|
{
|
|
|
|
set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
|
2013-04-11 18:29:35 +08:00
|
|
|
}
|
2013-02-21 14:32:52 +08:00
|
|
|
|
2013-04-11 18:29:35 +08:00
|
|
|
static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
|
|
|
|
unsigned long old_opts, int flags)
|
|
|
|
{
|
2013-02-21 14:32:52 +08:00
|
|
|
if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
|
|
|
|
(!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
|
2017-11-28 05:05:09 +08:00
|
|
|
(flags & SB_RDONLY))) {
|
2013-02-21 14:32:52 +08:00
|
|
|
/* wait for any defraggers to finish */
|
|
|
|
wait_event(fs_info->transaction_wait,
|
|
|
|
(atomic_read(&fs_info->defrag_running) == 0));
|
2017-11-28 05:05:09 +08:00
|
|
|
if (flags & SB_RDONLY)
|
2013-02-21 14:32:52 +08:00
|
|
|
sync_filesystem(fs_info->sb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,
|
|
|
|
unsigned long old_opts)
|
|
|
|
{
|
|
|
|
/*
|
2016-04-04 22:31:22 +08:00
|
|
|
* We need to cleanup all defragable inodes if the autodefragment is
|
|
|
|
* close or the filesystem is read only.
|
2013-02-21 14:32:52 +08:00
|
|
|
*/
|
|
|
|
if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
|
2017-07-17 15:45:34 +08:00
|
|
|
(!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || sb_rdonly(fs_info->sb))) {
|
2013-02-21 14:32:52 +08:00
|
|
|
btrfs_cleanup_defrag_inodes(fs_info);
|
|
|
|
}
|
|
|
|
|
2019-12-14 08:22:14 +08:00
|
|
|
/* If we toggled discard async */
|
|
|
|
if (!btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) &&
|
|
|
|
btrfs_test_opt(fs_info, DISCARD_ASYNC))
|
|
|
|
btrfs_discard_resume(fs_info);
|
|
|
|
else if (btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) &&
|
|
|
|
!btrfs_test_opt(fs_info, DISCARD_ASYNC))
|
|
|
|
btrfs_discard_cleanup(fs_info);
|
|
|
|
|
2013-02-21 14:32:52 +08:00
|
|
|
clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
|
|
|
|
}
|
|
|
|
|
2008-11-13 03:34:12 +08:00
|
|
|
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
|
|
|
|
{
|
2011-11-18 04:40:49 +08:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(sb);
|
|
|
|
struct btrfs_root *root = fs_info->tree_root;
|
2012-03-02 00:24:58 +08:00
|
|
|
unsigned old_flags = sb->s_flags;
|
|
|
|
unsigned long old_opts = fs_info->mount_opt;
|
|
|
|
unsigned long old_compress_type = fs_info->compress_type;
|
|
|
|
u64 old_max_inline = fs_info->max_inline;
|
2018-02-13 17:50:42 +08:00
|
|
|
u32 old_thread_pool_size = fs_info->thread_pool_size;
|
2018-02-26 16:46:05 +08:00
|
|
|
u32 old_metadata_ratio = fs_info->metadata_ratio;
|
2008-11-13 03:34:12 +08:00
|
|
|
int ret;
|
|
|
|
|
2014-03-13 22:14:33 +08:00
|
|
|
sync_filesystem(sb);
|
2013-04-11 18:29:35 +08:00
|
|
|
btrfs_remount_prepare(fs_info);
|
2013-02-21 14:32:52 +08:00
|
|
|
|
2014-09-23 13:40:08 +08:00
|
|
|
if (data) {
|
2018-12-14 02:41:47 +08:00
|
|
|
void *new_sec_opts = NULL;
|
2014-09-23 13:40:08 +08:00
|
|
|
|
2018-12-11 06:19:21 +08:00
|
|
|
ret = security_sb_eat_lsm_opts(data, &new_sec_opts);
|
|
|
|
if (!ret)
|
2018-12-14 02:41:47 +08:00
|
|
|
ret = security_sb_remount(sb, new_sec_opts);
|
2018-12-11 06:19:21 +08:00
|
|
|
security_free_mnt_opts(&new_sec_opts);
|
2014-09-23 13:40:08 +08:00
|
|
|
if (ret)
|
|
|
|
goto restore;
|
|
|
|
}
|
|
|
|
|
2016-06-23 06:54:24 +08:00
|
|
|
ret = btrfs_parse_options(fs_info, data, *flags);
|
2018-05-09 21:08:23 +08:00
|
|
|
if (ret)
|
2012-03-02 00:24:58 +08:00
|
|
|
goto restore;
|
2009-02-12 22:37:35 +08:00
|
|
|
|
2013-04-11 18:29:35 +08:00
|
|
|
btrfs_remount_begin(fs_info, old_opts, *flags);
|
2012-04-25 03:59:16 +08:00
|
|
|
btrfs_resize_thread_pool(fs_info,
|
|
|
|
fs_info->thread_pool_size, old_thread_pool_size);
|
|
|
|
|
2017-11-28 05:05:09 +08:00
|
|
|
if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
|
2013-02-21 14:32:52 +08:00
|
|
|
goto out;
|
2008-11-13 03:34:12 +08:00
|
|
|
|
2017-11-28 05:05:09 +08:00
|
|
|
if (*flags & SB_RDONLY) {
|
2012-11-06 20:15:27 +08:00
|
|
|
/*
|
|
|
|
* this also happens on 'umount -rf' or on shutdown, when
|
|
|
|
* the filesystem is busy.
|
|
|
|
*/
|
Btrfs: reclaim the reserved metadata space at background
Before applying this patch, the task had to reclaim the metadata space
by itself if the metadata space was not enough. And When the task started
the space reclamation, all the other tasks which wanted to reserve the
metadata space were blocked. At some cases, they would be blocked for
a long time, it made the performance fluctuate wildly.
So we introduce the background metadata space reclamation, when the space
is about to be exhausted, we insert a reclaim work into the workqueue, the
worker of the workqueue helps us to reclaim the reserved space at the
background. By this way, the tasks needn't reclaim the space by themselves at
most cases, and even if the tasks have to reclaim the space or are blocked
for the space reclamation, they will get enough space more quickly.
Here is my test result(Tested by compilebench):
Memory: 2GB
CPU: 2Cores * 1CPU
Partition: 40GB(SSD)
Test command:
# compilebench -D <mnt> -m
Without this patch:
intial create total runs 30 avg 54.36 MB/s (user 0.52s sys 2.44s)
compile total runs 30 avg 123.72 MB/s (user 0.13s sys 1.17s)
read compiled tree total runs 3 avg 81.15 MB/s (user 0.74s sys 4.89s)
delete compiled tree total runs 30 avg 5.32 seconds (user 0.35s sys 4.37s)
With this patch:
intial create total runs 30 avg 59.80 MB/s (user 0.52s sys 2.53s)
compile total runs 30 avg 151.44 MB/s (user 0.13s sys 1.11s)
read compiled tree total runs 3 avg 83.25 MB/s (user 0.76s sys 4.91s)
delete compiled tree total runs 30 avg 5.29 seconds (user 0.34s sys 4.34s)
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-05-14 08:29:04 +08:00
|
|
|
cancel_work_sync(&fs_info->async_reclaim_work);
|
2013-10-11 23:14:58 +08:00
|
|
|
|
2019-12-14 08:22:14 +08:00
|
|
|
btrfs_discard_cleanup(fs_info);
|
|
|
|
|
2013-10-11 23:14:58 +08:00
|
|
|
/* wait for the uuid_scan task to finish */
|
|
|
|
down(&fs_info->uuid_tree_rescan_sem);
|
|
|
|
/* avoid complains from lockdep et al. */
|
|
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
|
|
|
2017-11-28 05:05:09 +08:00
|
|
|
sb->s_flags |= SB_RDONLY;
|
2008-11-13 03:34:12 +08:00
|
|
|
|
2015-06-15 21:41:18 +08:00
|
|
|
/*
|
2017-11-28 05:05:09 +08:00
|
|
|
* Setting SB_RDONLY will put the cleaner thread to
|
2015-06-15 21:41:18 +08:00
|
|
|
* sleep at the next loop if it's already active.
|
|
|
|
* If it's already asleep, we'll leave unused block
|
|
|
|
* groups on disk until we're mounted read-write again
|
|
|
|
* unless we clean them up here.
|
|
|
|
*/
|
|
|
|
btrfs_delete_unused_bgs(fs_info);
|
|
|
|
|
2012-11-06 20:15:27 +08:00
|
|
|
btrfs_dev_replace_suspend_for_unmount(fs_info);
|
|
|
|
btrfs_scrub_cancel(fs_info);
|
2013-05-15 15:48:17 +08:00
|
|
|
btrfs_pause_balance(fs_info);
|
2012-11-06 20:15:27 +08:00
|
|
|
|
2016-06-22 09:16:51 +08:00
|
|
|
ret = btrfs_commit_super(fs_info);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
goto restore;
|
2008-11-13 03:34:12 +08:00
|
|
|
} else {
|
2016-06-23 06:54:23 +08:00
|
|
|
if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
|
2013-09-13 23:41:20 +08:00
|
|
|
btrfs_err(fs_info,
|
2013-12-21 00:37:06 +08:00
|
|
|
"Remounting read-write after error is not allowed");
|
2013-09-13 23:41:20 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto restore;
|
|
|
|
}
|
2012-04-16 11:44:37 +08:00
|
|
|
if (fs_info->fs_devices->rw_devices == 0) {
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = -EACCES;
|
|
|
|
goto restore;
|
2012-04-16 11:44:37 +08:00
|
|
|
}
|
2008-11-18 10:11:30 +08:00
|
|
|
|
2017-12-18 17:08:59 +08:00
|
|
|
if (!btrfs_check_rw_degradable(fs_info, NULL)) {
|
2013-12-21 00:37:06 +08:00
|
|
|
btrfs_warn(fs_info,
|
2018-11-28 19:05:13 +08:00
|
|
|
"too many missing devices, writable remount is not allowed");
|
2012-10-31 01:16:16 +08:00
|
|
|
ret = -EACCES;
|
|
|
|
goto restore;
|
|
|
|
}
|
|
|
|
|
2012-04-16 11:44:37 +08:00
|
|
|
if (btrfs_super_log_root(fs_info->super_copy) != 0) {
|
2020-02-06 00:12:28 +08:00
|
|
|
btrfs_warn(fs_info,
|
|
|
|
"mount required to replay tree-log, cannot remount read-write");
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto restore;
|
2012-04-16 11:44:37 +08:00
|
|
|
}
|
2008-11-13 03:34:12 +08:00
|
|
|
|
2011-11-18 04:40:49 +08:00
|
|
|
ret = btrfs_cleanup_fs_roots(fs_info);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
goto restore;
|
2008-11-13 03:34:12 +08:00
|
|
|
|
2010-05-16 22:49:58 +08:00
|
|
|
/* recover relocation */
|
2014-06-26 11:08:16 +08:00
|
|
|
mutex_lock(&fs_info->cleaner_mutex);
|
2010-05-16 22:49:58 +08:00
|
|
|
ret = btrfs_recover_relocation(root);
|
2014-06-26 11:08:16 +08:00
|
|
|
mutex_unlock(&fs_info->cleaner_mutex);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
goto restore;
|
2008-11-13 03:34:12 +08:00
|
|
|
|
2012-06-23 02:24:13 +08:00
|
|
|
ret = btrfs_resume_balance_async(fs_info);
|
|
|
|
if (ret)
|
|
|
|
goto restore;
|
|
|
|
|
2012-11-06 20:15:27 +08:00
|
|
|
ret = btrfs_resume_dev_replace_async(fs_info);
|
|
|
|
if (ret) {
|
2013-12-21 00:37:06 +08:00
|
|
|
btrfs_warn(fs_info, "failed to resume dev_replace");
|
2012-11-06 20:15:27 +08:00
|
|
|
goto restore;
|
|
|
|
}
|
2013-09-21 10:33:20 +08:00
|
|
|
|
2017-07-04 19:49:06 +08:00
|
|
|
btrfs_qgroup_rescan_resume(fs_info);
|
|
|
|
|
2013-09-21 10:33:20 +08:00
|
|
|
if (!fs_info->uuid_root) {
|
2013-12-21 00:37:06 +08:00
|
|
|
btrfs_info(fs_info, "creating UUID tree");
|
2013-09-21 10:33:20 +08:00
|
|
|
ret = btrfs_create_uuid_tree(fs_info);
|
|
|
|
if (ret) {
|
2016-09-20 22:05:00 +08:00
|
|
|
btrfs_warn(fs_info,
|
|
|
|
"failed to create the UUID tree %d",
|
|
|
|
ret);
|
2013-09-21 10:33:20 +08:00
|
|
|
goto restore;
|
|
|
|
}
|
|
|
|
}
|
2017-11-28 05:05:09 +08:00
|
|
|
sb->s_flags &= ~SB_RDONLY;
|
2016-06-13 11:39:58 +08:00
|
|
|
|
2016-09-03 03:40:02 +08:00
|
|
|
set_bit(BTRFS_FS_OPEN, &fs_info->flags);
|
2008-11-13 03:34:12 +08:00
|
|
|
}
|
2013-02-21 14:32:52 +08:00
|
|
|
out:
|
2014-02-21 00:48:07 +08:00
|
|
|
wake_up_process(fs_info->transaction_kthread);
|
2013-02-21 14:32:52 +08:00
|
|
|
btrfs_remount_cleanup(fs_info, old_opts);
|
2008-11-13 03:34:12 +08:00
|
|
|
return 0;
|
2012-03-02 00:24:58 +08:00
|
|
|
|
|
|
|
restore:
|
2017-11-28 05:05:09 +08:00
|
|
|
/* We've hit an error - don't reset SB_RDONLY */
|
2017-07-17 15:45:34 +08:00
|
|
|
if (sb_rdonly(sb))
|
2017-11-28 05:05:09 +08:00
|
|
|
old_flags |= SB_RDONLY;
|
2012-03-02 00:24:58 +08:00
|
|
|
sb->s_flags = old_flags;
|
|
|
|
fs_info->mount_opt = old_opts;
|
|
|
|
fs_info->compress_type = old_compress_type;
|
|
|
|
fs_info->max_inline = old_max_inline;
|
2012-04-25 03:59:16 +08:00
|
|
|
btrfs_resize_thread_pool(fs_info,
|
|
|
|
old_thread_pool_size, fs_info->thread_pool_size);
|
2012-03-02 00:24:58 +08:00
|
|
|
fs_info->metadata_ratio = old_metadata_ratio;
|
2013-02-21 14:32:52 +08:00
|
|
|
btrfs_remount_cleanup(fs_info, old_opts);
|
2012-03-02 00:24:58 +08:00
|
|
|
return ret;
|
2008-11-13 03:34:12 +08:00
|
|
|
}
|
|
|
|
|
2011-04-12 16:43:21 +08:00
|
|
|
/* Used to sort the devices by max_avail(descending sort) */
|
2018-11-03 23:39:28 +08:00
|
|
|
static inline int btrfs_cmp_device_free_bytes(const void *dev_info1,
|
2011-04-12 16:43:21 +08:00
|
|
|
const void *dev_info2)
|
|
|
|
{
|
|
|
|
if (((struct btrfs_device_info *)dev_info1)->max_avail >
|
|
|
|
((struct btrfs_device_info *)dev_info2)->max_avail)
|
|
|
|
return -1;
|
|
|
|
else if (((struct btrfs_device_info *)dev_info1)->max_avail <
|
|
|
|
((struct btrfs_device_info *)dev_info2)->max_avail)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sort the devices by max_avail, in which max free extent size of each device
|
|
|
|
* is stored.(Descending Sort)
|
|
|
|
*/
|
|
|
|
static inline void btrfs_descending_sort_devices(
|
|
|
|
struct btrfs_device_info *devices,
|
|
|
|
size_t nr_devices)
|
|
|
|
{
|
|
|
|
sort(devices, nr_devices, sizeof(struct btrfs_device_info),
|
|
|
|
btrfs_cmp_device_free_bytes, NULL);
|
|
|
|
}
|
|
|
|
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
/*
|
|
|
|
* The helper to calc the free space on the devices that can be used to store
|
|
|
|
* file data.
|
|
|
|
*/
|
2018-11-03 23:39:28 +08:00
|
|
|
static inline int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 *free_bytes)
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
{
|
|
|
|
struct btrfs_device_info *devices_info;
|
|
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
|
|
struct btrfs_device *device;
|
|
|
|
u64 type;
|
|
|
|
u64 avail_space;
|
|
|
|
u64 min_stripe_size;
|
2019-07-03 20:32:59 +08:00
|
|
|
int num_stripes = 1;
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
int i = 0, nr_devices;
|
2019-06-19 02:00:11 +08:00
|
|
|
const struct btrfs_raid_attr *rattr;
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
|
2014-11-03 21:56:50 +08:00
|
|
|
/*
|
2016-05-20 09:18:45 +08:00
|
|
|
* We aren't under the device list lock, so this is racy-ish, but good
|
2014-11-03 21:56:50 +08:00
|
|
|
* enough for our purposes.
|
|
|
|
*/
|
2011-11-28 16:43:00 +08:00
|
|
|
nr_devices = fs_info->fs_devices->open_devices;
|
2014-11-03 21:56:50 +08:00
|
|
|
if (!nr_devices) {
|
|
|
|
smp_mb();
|
|
|
|
nr_devices = fs_info->fs_devices->open_devices;
|
|
|
|
ASSERT(nr_devices);
|
|
|
|
if (!nr_devices) {
|
|
|
|
*free_bytes = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
|
2013-10-31 13:02:18 +08:00
|
|
|
devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
|
2017-06-15 21:04:04 +08:00
|
|
|
GFP_KERNEL);
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
if (!devices_info)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2016-05-20 09:18:45 +08:00
|
|
|
/* calc min stripe number for data space allocation */
|
2017-05-17 23:38:35 +08:00
|
|
|
type = btrfs_data_alloc_profile(fs_info);
|
2019-06-19 02:00:11 +08:00
|
|
|
rattr = &btrfs_raid_array[btrfs_bg_flags_to_raid_index(type)];
|
|
|
|
|
2019-06-19 02:00:13 +08:00
|
|
|
if (type & BTRFS_BLOCK_GROUP_RAID0)
|
2011-12-15 09:12:02 +08:00
|
|
|
num_stripes = nr_devices;
|
2019-06-19 02:00:13 +08:00
|
|
|
else if (type & BTRFS_BLOCK_GROUP_RAID1)
|
2011-12-15 09:12:02 +08:00
|
|
|
num_stripes = 2;
|
2018-03-03 05:56:53 +08:00
|
|
|
else if (type & BTRFS_BLOCK_GROUP_RAID1C3)
|
|
|
|
num_stripes = 3;
|
2018-03-03 05:56:53 +08:00
|
|
|
else if (type & BTRFS_BLOCK_GROUP_RAID1C4)
|
|
|
|
num_stripes = 4;
|
2019-06-19 02:00:13 +08:00
|
|
|
else if (type & BTRFS_BLOCK_GROUP_RAID10)
|
2011-12-15 09:12:02 +08:00
|
|
|
num_stripes = 4;
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
|
2019-06-19 02:00:11 +08:00
|
|
|
/* Adjust for more than 1 stripe per device */
|
|
|
|
min_stripe_size = rattr->dev_stripes * BTRFS_STRIPE_LEN;
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
|
2014-11-03 21:56:50 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
|
2017-12-04 12:54:53 +08:00
|
|
|
if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA,
|
|
|
|
&device->dev_state) ||
|
2017-12-04 12:54:55 +08:00
|
|
|
!device->bdev ||
|
|
|
|
test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state))
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
continue;
|
|
|
|
|
2014-11-03 21:56:50 +08:00
|
|
|
if (i >= nr_devices)
|
|
|
|
break;
|
|
|
|
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
avail_space = device->total_bytes - device->bytes_used;
|
|
|
|
|
|
|
|
/* align with stripe_len */
|
2019-07-03 20:32:59 +08:00
|
|
|
avail_space = rounddown(avail_space, BTRFS_STRIPE_LEN);
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
|
|
|
|
/*
|
2016-05-20 09:18:45 +08:00
|
|
|
* In order to avoid overwriting the superblock on the drive,
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
* btrfs starts at an offset of at least 1MB when doing chunk
|
|
|
|
* allocation.
|
2019-07-03 20:32:59 +08:00
|
|
|
*
|
|
|
|
* This ensures we have at least min_stripe_size free space
|
|
|
|
* after excluding 1MB.
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
*/
|
2019-07-03 20:32:59 +08:00
|
|
|
if (avail_space <= SZ_1M + min_stripe_size)
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
continue;
|
|
|
|
|
2019-07-03 20:32:59 +08:00
|
|
|
avail_space -= SZ_1M;
|
|
|
|
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
devices_info[i].dev = device;
|
|
|
|
devices_info[i].max_avail = avail_space;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
2014-11-03 21:56:50 +08:00
|
|
|
rcu_read_unlock();
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
|
|
|
|
nr_devices = i;
|
|
|
|
|
|
|
|
btrfs_descending_sort_devices(devices_info, nr_devices);
|
|
|
|
|
|
|
|
i = nr_devices - 1;
|
|
|
|
avail_space = 0;
|
2019-07-03 20:32:59 +08:00
|
|
|
while (nr_devices >= rattr->devs_min) {
|
|
|
|
num_stripes = min(num_stripes, nr_devices);
|
2011-12-15 09:12:02 +08:00
|
|
|
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
if (devices_info[i].max_avail >= min_stripe_size) {
|
|
|
|
int j;
|
|
|
|
u64 alloc_size;
|
|
|
|
|
2011-12-15 09:12:02 +08:00
|
|
|
avail_space += devices_info[i].max_avail * num_stripes;
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
alloc_size = devices_info[i].max_avail;
|
2011-12-15 09:12:02 +08:00
|
|
|
for (j = i + 1 - num_stripes; j <= i; j++)
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
devices_info[j].max_avail -= alloc_size;
|
|
|
|
}
|
|
|
|
i--;
|
|
|
|
nr_devices--;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(devices_info);
|
|
|
|
*free_bytes = avail_space;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-01 22:21:33 +08:00
|
|
|
/*
|
|
|
|
* Calculate numbers for 'df', pessimistic in case of mixed raid profiles.
|
|
|
|
*
|
|
|
|
* If there's a redundant raid level at DATA block groups, use the respective
|
|
|
|
* multiplier to scale the sizes.
|
|
|
|
*
|
|
|
|
* Unused device space usage is based on simulating the chunk allocator
|
2017-06-15 07:30:06 +08:00
|
|
|
* algorithm that respects the device sizes and order of allocations. This is
|
|
|
|
* a close approximation of the actual use but there are other factors that may
|
|
|
|
* change the result (like a new metadata chunk).
|
2014-07-01 22:21:33 +08:00
|
|
|
*
|
2015-10-10 23:59:53 +08:00
|
|
|
* If metadata is exhausted, f_bavail will be 0.
|
2014-07-01 22:21:33 +08:00
|
|
|
*/
|
2007-04-20 09:01:03 +08:00
|
|
|
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|
|
|
{
|
2011-11-18 04:40:49 +08:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
|
|
|
|
struct btrfs_super_block *disk_super = fs_info->super_copy;
|
Btrfs: make df be a little bit more understandable
The way we report df usage is way confusing for everybody, including some other
utilities (bacula for one). So this patch makes df a little bit more
understandable. First we make used actually count the total amount of used
space in all space info's. This will give us a real view of how much disk space
is in use. Second, for blocks available, only count data space. This makes
things like bacula work because it says 0 when you can no longer write anymore
data to the disk. I think this is a nice compromise, since you will end up with
something like the following
[root@alpha ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root
148G 30G 111G 21% /
/dev/sda1 194M 116M 68M 64% /boot
tmpfs 985M 12K 985M 1% /dev/shm
/dev/mapper/VolGroup-LogVol02
145G 140G 0 100% /mnt/btrfs-test
Compare this with btrfsctl -i output
[root@alpha btrfs-progs-unstable]# ./btrfsctl -i /mnt/btrfs-test/
Metadata, DUP: total=4.62GB, used=2.46GB
System, DUP: total=8.00MB, used=24.00KB
Data: total=134.80GB, used=134.80GB
Metadata: total=8.00MB, used=0.00
System: total=4.00MB, used=0.00
operation complete
This way we show that there is no more data space to be used, but we have
another 5GB of space left for metadata. Thanks,
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-03-06 05:59:21 +08:00
|
|
|
struct btrfs_space_info *found;
|
|
|
|
u64 total_used = 0;
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
u64 total_free_data = 0;
|
2015-10-10 23:59:53 +08:00
|
|
|
u64 total_free_meta = 0;
|
2007-10-16 04:15:53 +08:00
|
|
|
int bits = dentry->d_sb->s_blocksize_bits;
|
2018-10-30 22:43:24 +08:00
|
|
|
__be32 *fsid = (__be32 *)fs_info->fs_devices->fsid;
|
2014-07-01 22:21:33 +08:00
|
|
|
unsigned factor = 1;
|
|
|
|
struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
int ret;
|
2015-10-10 23:59:53 +08:00
|
|
|
u64 thresh = 0;
|
2016-03-31 04:53:38 +08:00
|
|
|
int mixed = 0;
|
2007-04-20 09:01:03 +08:00
|
|
|
|
Btrfs: make df be a little bit more understandable
The way we report df usage is way confusing for everybody, including some other
utilities (bacula for one). So this patch makes df a little bit more
understandable. First we make used actually count the total amount of used
space in all space info's. This will give us a real view of how much disk space
is in use. Second, for blocks available, only count data space. This makes
things like bacula work because it says 0 when you can no longer write anymore
data to the disk. I think this is a nice compromise, since you will end up with
something like the following
[root@alpha ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root
148G 30G 111G 21% /
/dev/sda1 194M 116M 68M 64% /boot
tmpfs 985M 12K 985M 1% /dev/shm
/dev/mapper/VolGroup-LogVol02
145G 140G 0 100% /mnt/btrfs-test
Compare this with btrfsctl -i output
[root@alpha btrfs-progs-unstable]# ./btrfsctl -i /mnt/btrfs-test/
Metadata, DUP: total=4.62GB, used=2.46GB
System, DUP: total=8.00MB, used=24.00KB
Data: total=134.80GB, used=134.80GB
Metadata: total=8.00MB, used=0.00
System: total=4.00MB, used=0.00
operation complete
This way we show that there is no more data space to be used, but we have
another 5GB of space left for metadata. Thanks,
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-03-06 05:59:21 +08:00
|
|
|
rcu_read_lock();
|
2019-10-24 23:44:54 +08:00
|
|
|
list_for_each_entry_rcu(found, &fs_info->space_info, list) {
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
|
2014-07-01 22:21:33 +08:00
|
|
|
int i;
|
|
|
|
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
total_free_data += found->disk_total - found->disk_used;
|
|
|
|
total_free_data -=
|
|
|
|
btrfs_account_ro_block_groups_free_space(found);
|
2014-07-01 22:21:33 +08:00
|
|
|
|
|
|
|
for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
|
2018-07-14 02:46:30 +08:00
|
|
|
if (!list_empty(&found->block_groups[i]))
|
|
|
|
factor = btrfs_bg_type_to_factor(
|
|
|
|
btrfs_raid_array[i].bg_flag);
|
2014-07-01 22:21:33 +08:00
|
|
|
}
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
}
|
2016-03-31 04:53:38 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Metadata in mixed block goup profiles are accounted in data
|
|
|
|
*/
|
|
|
|
if (!mixed && found->flags & BTRFS_BLOCK_GROUP_METADATA) {
|
|
|
|
if (found->flags & BTRFS_BLOCK_GROUP_DATA)
|
|
|
|
mixed = 1;
|
|
|
|
else
|
|
|
|
total_free_meta += found->disk_total -
|
|
|
|
found->disk_used;
|
|
|
|
}
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
|
2010-05-16 22:46:24 +08:00
|
|
|
total_used += found->disk_used;
|
2010-10-15 02:52:27 +08:00
|
|
|
}
|
2014-07-01 22:21:33 +08:00
|
|
|
|
Btrfs: make df be a little bit more understandable
The way we report df usage is way confusing for everybody, including some other
utilities (bacula for one). So this patch makes df a little bit more
understandable. First we make used actually count the total amount of used
space in all space info's. This will give us a real view of how much disk space
is in use. Second, for blocks available, only count data space. This makes
things like bacula work because it says 0 when you can no longer write anymore
data to the disk. I think this is a nice compromise, since you will end up with
something like the following
[root@alpha ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root
148G 30G 111G 21% /
/dev/sda1 194M 116M 68M 64% /boot
tmpfs 985M 12K 985M 1% /dev/shm
/dev/mapper/VolGroup-LogVol02
145G 140G 0 100% /mnt/btrfs-test
Compare this with btrfsctl -i output
[root@alpha btrfs-progs-unstable]# ./btrfsctl -i /mnt/btrfs-test/
Metadata, DUP: total=4.62GB, used=2.46GB
System, DUP: total=8.00MB, used=24.00KB
Data: total=134.80GB, used=134.80GB
Metadata: total=8.00MB, used=0.00
System: total=4.00MB, used=0.00
operation complete
This way we show that there is no more data space to be used, but we have
another 5GB of space left for metadata. Thanks,
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-03-06 05:59:21 +08:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2014-07-01 22:21:33 +08:00
|
|
|
buf->f_blocks = div_u64(btrfs_super_total_bytes(disk_super), factor);
|
|
|
|
buf->f_blocks >>= bits;
|
|
|
|
buf->f_bfree = buf->f_blocks - (div_u64(total_used, factor) >> bits);
|
|
|
|
|
|
|
|
/* Account global block reserve as used, it's in logical size already */
|
|
|
|
spin_lock(&block_rsv->lock);
|
2016-03-31 06:18:14 +08:00
|
|
|
/* Mixed block groups accounting is not byte-accurate, avoid overflow */
|
|
|
|
if (buf->f_bfree >= block_rsv->size >> bits)
|
|
|
|
buf->f_bfree -= block_rsv->size >> bits;
|
|
|
|
else
|
|
|
|
buf->f_bfree = 0;
|
2014-07-01 22:21:33 +08:00
|
|
|
spin_unlock(&block_rsv->lock);
|
|
|
|
|
2014-11-14 22:05:06 +08:00
|
|
|
buf->f_bavail = div_u64(total_free_data, factor);
|
2016-06-22 09:16:51 +08:00
|
|
|
ret = btrfs_calc_avail_data_space(fs_info, &total_free_data);
|
2014-11-03 21:56:50 +08:00
|
|
|
if (ret)
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
return ret;
|
2014-07-01 22:21:33 +08:00
|
|
|
buf->f_bavail += div_u64(total_free_data, factor);
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 18:07:31 +08:00
|
|
|
buf->f_bavail = buf->f_bavail >> bits;
|
2009-01-06 10:25:51 +08:00
|
|
|
|
2015-10-10 23:59:53 +08:00
|
|
|
/*
|
|
|
|
* We calculate the remaining metadata space minus global reserve. If
|
|
|
|
* this is (supposedly) smaller than zero, there's no space. But this
|
|
|
|
* does not hold in practice, the exhausted state happens where's still
|
|
|
|
* some positive delta. So we apply some guesswork and compare the
|
|
|
|
* delta to a 4M threshold. (Practically observed delta was ~2M.)
|
|
|
|
*
|
|
|
|
* We probably cannot calculate the exact threshold value because this
|
|
|
|
* depends on the internal reservations requested by various
|
|
|
|
* operations, so some operations that consume a few metadata will
|
|
|
|
* succeed even if the Avail is zero. But this is better than the other
|
|
|
|
* way around.
|
|
|
|
*/
|
2017-10-16 21:48:40 +08:00
|
|
|
thresh = SZ_4M;
|
2015-10-10 23:59:53 +08:00
|
|
|
|
2020-01-31 22:31:05 +08:00
|
|
|
/*
|
|
|
|
* We only want to claim there's no available space if we can no longer
|
|
|
|
* allocate chunks for our metadata profile and our global reserve will
|
|
|
|
* not fit in the free metadata space. If we aren't ->full then we
|
|
|
|
* still can allocate chunks and thus are fine using the currently
|
|
|
|
* calculated f_bavail.
|
|
|
|
*/
|
|
|
|
if (!mixed && block_rsv->space_info->full &&
|
|
|
|
total_free_meta - thresh < block_rsv->size)
|
2015-10-10 23:59:53 +08:00
|
|
|
buf->f_bavail = 0;
|
|
|
|
|
2014-07-01 22:21:33 +08:00
|
|
|
buf->f_type = BTRFS_SUPER_MAGIC;
|
|
|
|
buf->f_bsize = dentry->d_sb->s_blocksize;
|
|
|
|
buf->f_namelen = BTRFS_NAME_LEN;
|
|
|
|
|
2008-08-18 19:01:52 +08:00
|
|
|
/* We treat it as constant endianness (it doesn't matter _which_)
|
2009-01-06 10:25:51 +08:00
|
|
|
because we want the fsid to come out the same whether mounted
|
2008-08-18 19:01:52 +08:00
|
|
|
on a big-endian or little-endian host */
|
|
|
|
buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
|
|
|
|
buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
|
2008-08-18 20:10:20 +08:00
|
|
|
/* Mask in the root object ID too, to disambiguate subvols */
|
2018-08-06 13:25:24 +08:00
|
|
|
buf->f_fsid.val[0] ^=
|
|
|
|
BTRFS_I(d_inode(dentry))->root->root_key.objectid >> 32;
|
|
|
|
buf->f_fsid.val[1] ^=
|
|
|
|
BTRFS_I(d_inode(dentry))->root->root_key.objectid;
|
2008-08-18 20:10:20 +08:00
|
|
|
|
2007-04-20 09:01:03 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2007-04-24 23:52:22 +08:00
|
|
|
|
2011-11-17 14:22:46 +08:00
|
|
|
static void btrfs_kill_super(struct super_block *sb)
|
|
|
|
{
|
2011-11-18 04:40:49 +08:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(sb);
|
2011-11-17 14:22:46 +08:00
|
|
|
kill_anon_super(sb);
|
2020-01-24 22:32:53 +08:00
|
|
|
btrfs_free_fs_info(fs_info);
|
2011-11-17 14:22:46 +08:00
|
|
|
}
|
|
|
|
|
2007-03-21 23:12:56 +08:00
|
|
|
static struct file_system_type btrfs_fs_type = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "btrfs",
|
2010-07-26 20:21:33 +08:00
|
|
|
.mount = btrfs_mount,
|
2011-11-17 14:22:46 +08:00
|
|
|
.kill_sb = btrfs_kill_super,
|
2014-09-23 13:40:08 +08:00
|
|
|
.fs_flags = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA,
|
2007-03-21 23:12:56 +08:00
|
|
|
};
|
2017-12-14 16:24:30 +08:00
|
|
|
|
|
|
|
static struct file_system_type btrfs_root_fs_type = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "btrfs",
|
|
|
|
.mount = btrfs_mount_root,
|
|
|
|
.kill_sb = btrfs_kill_super,
|
|
|
|
.fs_flags = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA,
|
|
|
|
};
|
|
|
|
|
2013-03-03 11:39:14 +08:00
|
|
|
MODULE_ALIAS_FS("btrfs");
|
2008-03-25 03:02:04 +08:00
|
|
|
|
2015-03-24 23:35:49 +08:00
|
|
|
static int btrfs_control_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* The control file's private_data is used to hold the
|
|
|
|
* transaction when it is started and is used to keep
|
|
|
|
* track of whether a transaction is already in progress.
|
|
|
|
*/
|
|
|
|
file->private_data = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08:00
|
|
|
/*
|
2020-02-04 12:51:56 +08:00
|
|
|
* Used by /dev/btrfs-control for devices ioctls.
|
2008-09-30 03:18:18 +08:00
|
|
|
*/
|
2008-03-25 03:02:07 +08:00
|
|
|
static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
|
|
|
{
|
|
|
|
struct btrfs_ioctl_vol_args *vol;
|
2018-07-12 14:23:16 +08:00
|
|
|
struct btrfs_device *device = NULL;
|
2009-01-17 00:59:08 +08:00
|
|
|
int ret = -ENOTTY;
|
2008-03-25 03:02:07 +08:00
|
|
|
|
2009-01-06 05:57:23 +08:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
2009-04-08 15:06:54 +08:00
|
|
|
vol = memdup_user((void __user *)arg, sizeof(*vol));
|
|
|
|
if (IS_ERR(vol))
|
|
|
|
return PTR_ERR(vol);
|
2018-11-14 19:35:24 +08:00
|
|
|
vol->name[BTRFS_PATH_NAME_MAX] = '\0';
|
2009-01-17 00:59:08 +08:00
|
|
|
|
2008-03-25 03:02:07 +08:00
|
|
|
switch (cmd) {
|
|
|
|
case BTRFS_IOC_SCAN_DEV:
|
2018-06-19 22:37:36 +08:00
|
|
|
mutex_lock(&uuid_mutex);
|
2018-07-12 14:23:16 +08:00
|
|
|
device = btrfs_scan_one_device(vol->name, FMODE_READ,
|
|
|
|
&btrfs_root_fs_type);
|
|
|
|
ret = PTR_ERR_OR_ZERO(device);
|
2018-06-19 22:37:36 +08:00
|
|
|
mutex_unlock(&uuid_mutex);
|
2008-03-25 03:02:07 +08:00
|
|
|
break;
|
2019-01-04 13:31:54 +08:00
|
|
|
case BTRFS_IOC_FORGET_DEV:
|
|
|
|
ret = btrfs_forget_devices(vol->name);
|
|
|
|
break;
|
2012-06-22 04:03:58 +08:00
|
|
|
case BTRFS_IOC_DEVICES_READY:
|
2018-06-19 22:37:36 +08:00
|
|
|
mutex_lock(&uuid_mutex);
|
2018-07-12 14:23:16 +08:00
|
|
|
device = btrfs_scan_one_device(vol->name, FMODE_READ,
|
|
|
|
&btrfs_root_fs_type);
|
|
|
|
if (IS_ERR(device)) {
|
2018-06-19 22:37:36 +08:00
|
|
|
mutex_unlock(&uuid_mutex);
|
2018-07-12 14:23:16 +08:00
|
|
|
ret = PTR_ERR(device);
|
2012-06-22 04:03:58 +08:00
|
|
|
break;
|
2018-06-19 22:37:36 +08:00
|
|
|
}
|
2018-07-12 14:23:16 +08:00
|
|
|
ret = !(device->fs_devices->num_devices ==
|
|
|
|
device->fs_devices->total_devices);
|
2018-06-19 22:37:36 +08:00
|
|
|
mutex_unlock(&uuid_mutex);
|
2012-06-22 04:03:58 +08:00
|
|
|
break;
|
2016-02-17 22:24:14 +08:00
|
|
|
case BTRFS_IOC_GET_SUPPORTED_FEATURES:
|
2016-02-17 22:26:27 +08:00
|
|
|
ret = btrfs_ioctl_get_supported_features((void __user*)arg);
|
2016-02-17 22:24:14 +08:00
|
|
|
break;
|
2008-03-25 03:02:07 +08:00
|
|
|
}
|
2009-04-08 15:06:54 +08:00
|
|
|
|
2008-03-25 03:02:07 +08:00
|
|
|
kfree(vol);
|
2008-06-10 10:17:11 +08:00
|
|
|
return ret;
|
2008-03-25 03:02:07 +08:00
|
|
|
}
|
|
|
|
|
2009-01-10 22:09:52 +08:00
|
|
|
static int btrfs_freeze(struct super_block *sb)
|
2008-01-23 01:46:56 +08:00
|
|
|
{
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
struct btrfs_trans_handle *trans;
|
2016-06-23 06:54:23 +08:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(sb);
|
|
|
|
struct btrfs_root *root = fs_info->tree_root;
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
|
2017-06-16 01:10:03 +08:00
|
|
|
set_bit(BTRFS_FS_FROZEN, &fs_info->flags);
|
btrfs: fix fsfreeze hang caused by delayed iputs deal
When running fstests generic/068, sometimes we got below deadlock:
xfs_io D ffff8800331dbb20 0 6697 6693 0x00000080
ffff8800331dbb20 ffff88007acfc140 ffff880034d895c0 ffff8800331dc000
ffff880032d243e8 fffffffeffffffff ffff880032d24400 0000000000000001
ffff8800331dbb38 ffffffff816a9045 ffff880034d895c0 ffff8800331dbba8
Call Trace:
[<ffffffff816a9045>] schedule+0x35/0x80
[<ffffffff816abab2>] rwsem_down_read_failed+0xf2/0x140
[<ffffffff8118f5e1>] ? __filemap_fdatawrite_range+0xd1/0x100
[<ffffffff8134f978>] call_rwsem_down_read_failed+0x18/0x30
[<ffffffffa06631fc>] ? btrfs_alloc_block_rsv+0x2c/0xb0 [btrfs]
[<ffffffff810d32b5>] percpu_down_read+0x35/0x50
[<ffffffff81217dfc>] __sb_start_write+0x2c/0x40
[<ffffffffa067f5d5>] start_transaction+0x2a5/0x4d0 [btrfs]
[<ffffffffa067f857>] btrfs_join_transaction+0x17/0x20 [btrfs]
[<ffffffffa068ba34>] btrfs_evict_inode+0x3c4/0x5d0 [btrfs]
[<ffffffff81230a1a>] evict+0xba/0x1a0
[<ffffffff812316b6>] iput+0x196/0x200
[<ffffffffa06851d0>] btrfs_run_delayed_iputs+0x70/0xc0 [btrfs]
[<ffffffffa067f1d8>] btrfs_commit_transaction+0x928/0xa80 [btrfs]
[<ffffffffa0646df0>] btrfs_freeze+0x30/0x40 [btrfs]
[<ffffffff81218040>] freeze_super+0xf0/0x190
[<ffffffff81229275>] do_vfs_ioctl+0x4a5/0x5c0
[<ffffffff81003176>] ? do_audit_syscall_entry+0x66/0x70
[<ffffffff810038cf>] ? syscall_trace_enter_phase1+0x11f/0x140
[<ffffffff81229409>] SyS_ioctl+0x79/0x90
[<ffffffff81003c12>] do_syscall_64+0x62/0x110
[<ffffffff816acbe1>] entry_SYSCALL64_slow_path+0x25/0x25
>From this warning, freeze_super() already holds SB_FREEZE_FS, but
btrfs_freeze() will call btrfs_commit_transaction() again, if
btrfs_commit_transaction() finds that it has delayed iputs to handle,
it'll start_transaction(), which will try to get SB_FREEZE_FS lock
again, then deadlock occurs.
The root cause is that in btrfs, sync_filesystem(sb) does not make
sure all metadata is updated. There still maybe some codes adding
delayed iputs, see below sample race window:
CPU1 | CPU2
|-> freeze_super() |
|-> sync_filesystem(sb); |
| |-> cleaner_kthread()
| | |-> btrfs_delete_unused_bgs()
| | |-> btrfs_remove_chunk()
| | |-> btrfs_remove_block_group()
| | |-> btrfs_add_delayed_iput()
| |
|-> sb->s_writers.frozen = SB_FREEZE_FS; |
|-> sb_wait_write(sb, SB_FREEZE_FS); |
| acquire SB_FREEZE_FS lock. |
| |
|-> btrfs_freeze() |
|-> btrfs_commit_transaction() |
|-> btrfs_run_delayed_iputs() |
| will handle delayed iputs, |
| that means start_transaction() |
| will be called, which will try |
| to get SB_FREEZE_FS lock. |
To fix this issue, introduce a "int fs_frozen" to record internally whether
fs has been frozen. If fs has been frozen, we can not handle delayed iputs.
Signed-off-by: Wang Xiaoguang <wangxg.fnst@cn.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ add comment to btrfs_freeze ]
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-01 13:28:08 +08:00
|
|
|
/*
|
|
|
|
* We don't need a barrier here, we'll wait for any transaction that
|
|
|
|
* could be in progress on other threads (and do delayed iputs that
|
|
|
|
* we want to avoid on a frozen filesystem), or do the commit
|
|
|
|
* ourselves.
|
|
|
|
*/
|
Btrfs: fix uncompleted transaction
In some cases, we need commit the current transaction, but don't want
to start a new one if there is no running transaction, so we introduce
the function - btrfs_attach_transaction(), which can catch the current
transaction, and return -ENOENT if there is no running transaction.
But no running transaction doesn't mean the current transction completely,
because we removed the running transaction before it completes. In some
cases, it doesn't matter. But in some special cases, such as freeze fs, we
hope the transaction is fully on disk, it will introduce some bugs, for
example, we may feeze the fs and dump the data in the disk, if the transction
doesn't complete, we would dump inconsistent data. So we need fix the above
problem for those cases.
We fixes this problem by introducing a function:
btrfs_attach_transaction_barrier()
if we hope all the transaction is fully on the disk, even they are not
running, we can use this function.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2013-02-20 17:17:06 +08:00
|
|
|
trans = btrfs_attach_transaction_barrier(root);
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
/* no transaction, don't bother */
|
|
|
|
if (PTR_ERR(trans) == -ENOENT)
|
|
|
|
return 0;
|
|
|
|
return PTR_ERR(trans);
|
|
|
|
}
|
2016-09-10 09:39:03 +08:00
|
|
|
return btrfs_commit_transaction(trans);
|
2008-01-23 01:46:56 +08:00
|
|
|
}
|
|
|
|
|
btrfs: fix fsfreeze hang caused by delayed iputs deal
When running fstests generic/068, sometimes we got below deadlock:
xfs_io D ffff8800331dbb20 0 6697 6693 0x00000080
ffff8800331dbb20 ffff88007acfc140 ffff880034d895c0 ffff8800331dc000
ffff880032d243e8 fffffffeffffffff ffff880032d24400 0000000000000001
ffff8800331dbb38 ffffffff816a9045 ffff880034d895c0 ffff8800331dbba8
Call Trace:
[<ffffffff816a9045>] schedule+0x35/0x80
[<ffffffff816abab2>] rwsem_down_read_failed+0xf2/0x140
[<ffffffff8118f5e1>] ? __filemap_fdatawrite_range+0xd1/0x100
[<ffffffff8134f978>] call_rwsem_down_read_failed+0x18/0x30
[<ffffffffa06631fc>] ? btrfs_alloc_block_rsv+0x2c/0xb0 [btrfs]
[<ffffffff810d32b5>] percpu_down_read+0x35/0x50
[<ffffffff81217dfc>] __sb_start_write+0x2c/0x40
[<ffffffffa067f5d5>] start_transaction+0x2a5/0x4d0 [btrfs]
[<ffffffffa067f857>] btrfs_join_transaction+0x17/0x20 [btrfs]
[<ffffffffa068ba34>] btrfs_evict_inode+0x3c4/0x5d0 [btrfs]
[<ffffffff81230a1a>] evict+0xba/0x1a0
[<ffffffff812316b6>] iput+0x196/0x200
[<ffffffffa06851d0>] btrfs_run_delayed_iputs+0x70/0xc0 [btrfs]
[<ffffffffa067f1d8>] btrfs_commit_transaction+0x928/0xa80 [btrfs]
[<ffffffffa0646df0>] btrfs_freeze+0x30/0x40 [btrfs]
[<ffffffff81218040>] freeze_super+0xf0/0x190
[<ffffffff81229275>] do_vfs_ioctl+0x4a5/0x5c0
[<ffffffff81003176>] ? do_audit_syscall_entry+0x66/0x70
[<ffffffff810038cf>] ? syscall_trace_enter_phase1+0x11f/0x140
[<ffffffff81229409>] SyS_ioctl+0x79/0x90
[<ffffffff81003c12>] do_syscall_64+0x62/0x110
[<ffffffff816acbe1>] entry_SYSCALL64_slow_path+0x25/0x25
>From this warning, freeze_super() already holds SB_FREEZE_FS, but
btrfs_freeze() will call btrfs_commit_transaction() again, if
btrfs_commit_transaction() finds that it has delayed iputs to handle,
it'll start_transaction(), which will try to get SB_FREEZE_FS lock
again, then deadlock occurs.
The root cause is that in btrfs, sync_filesystem(sb) does not make
sure all metadata is updated. There still maybe some codes adding
delayed iputs, see below sample race window:
CPU1 | CPU2
|-> freeze_super() |
|-> sync_filesystem(sb); |
| |-> cleaner_kthread()
| | |-> btrfs_delete_unused_bgs()
| | |-> btrfs_remove_chunk()
| | |-> btrfs_remove_block_group()
| | |-> btrfs_add_delayed_iput()
| |
|-> sb->s_writers.frozen = SB_FREEZE_FS; |
|-> sb_wait_write(sb, SB_FREEZE_FS); |
| acquire SB_FREEZE_FS lock. |
| |
|-> btrfs_freeze() |
|-> btrfs_commit_transaction() |
|-> btrfs_run_delayed_iputs() |
| will handle delayed iputs, |
| that means start_transaction() |
| will be called, which will try |
| to get SB_FREEZE_FS lock. |
To fix this issue, introduce a "int fs_frozen" to record internally whether
fs has been frozen. If fs has been frozen, we can not handle delayed iputs.
Signed-off-by: Wang Xiaoguang <wangxg.fnst@cn.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ add comment to btrfs_freeze ]
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-01 13:28:08 +08:00
|
|
|
static int btrfs_unfreeze(struct super_block *sb)
|
|
|
|
{
|
2017-06-16 01:10:03 +08:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(sb);
|
|
|
|
|
|
|
|
clear_bit(BTRFS_FS_FROZEN, &fs_info->flags);
|
btrfs: fix fsfreeze hang caused by delayed iputs deal
When running fstests generic/068, sometimes we got below deadlock:
xfs_io D ffff8800331dbb20 0 6697 6693 0x00000080
ffff8800331dbb20 ffff88007acfc140 ffff880034d895c0 ffff8800331dc000
ffff880032d243e8 fffffffeffffffff ffff880032d24400 0000000000000001
ffff8800331dbb38 ffffffff816a9045 ffff880034d895c0 ffff8800331dbba8
Call Trace:
[<ffffffff816a9045>] schedule+0x35/0x80
[<ffffffff816abab2>] rwsem_down_read_failed+0xf2/0x140
[<ffffffff8118f5e1>] ? __filemap_fdatawrite_range+0xd1/0x100
[<ffffffff8134f978>] call_rwsem_down_read_failed+0x18/0x30
[<ffffffffa06631fc>] ? btrfs_alloc_block_rsv+0x2c/0xb0 [btrfs]
[<ffffffff810d32b5>] percpu_down_read+0x35/0x50
[<ffffffff81217dfc>] __sb_start_write+0x2c/0x40
[<ffffffffa067f5d5>] start_transaction+0x2a5/0x4d0 [btrfs]
[<ffffffffa067f857>] btrfs_join_transaction+0x17/0x20 [btrfs]
[<ffffffffa068ba34>] btrfs_evict_inode+0x3c4/0x5d0 [btrfs]
[<ffffffff81230a1a>] evict+0xba/0x1a0
[<ffffffff812316b6>] iput+0x196/0x200
[<ffffffffa06851d0>] btrfs_run_delayed_iputs+0x70/0xc0 [btrfs]
[<ffffffffa067f1d8>] btrfs_commit_transaction+0x928/0xa80 [btrfs]
[<ffffffffa0646df0>] btrfs_freeze+0x30/0x40 [btrfs]
[<ffffffff81218040>] freeze_super+0xf0/0x190
[<ffffffff81229275>] do_vfs_ioctl+0x4a5/0x5c0
[<ffffffff81003176>] ? do_audit_syscall_entry+0x66/0x70
[<ffffffff810038cf>] ? syscall_trace_enter_phase1+0x11f/0x140
[<ffffffff81229409>] SyS_ioctl+0x79/0x90
[<ffffffff81003c12>] do_syscall_64+0x62/0x110
[<ffffffff816acbe1>] entry_SYSCALL64_slow_path+0x25/0x25
>From this warning, freeze_super() already holds SB_FREEZE_FS, but
btrfs_freeze() will call btrfs_commit_transaction() again, if
btrfs_commit_transaction() finds that it has delayed iputs to handle,
it'll start_transaction(), which will try to get SB_FREEZE_FS lock
again, then deadlock occurs.
The root cause is that in btrfs, sync_filesystem(sb) does not make
sure all metadata is updated. There still maybe some codes adding
delayed iputs, see below sample race window:
CPU1 | CPU2
|-> freeze_super() |
|-> sync_filesystem(sb); |
| |-> cleaner_kthread()
| | |-> btrfs_delete_unused_bgs()
| | |-> btrfs_remove_chunk()
| | |-> btrfs_remove_block_group()
| | |-> btrfs_add_delayed_iput()
| |
|-> sb->s_writers.frozen = SB_FREEZE_FS; |
|-> sb_wait_write(sb, SB_FREEZE_FS); |
| acquire SB_FREEZE_FS lock. |
| |
|-> btrfs_freeze() |
|-> btrfs_commit_transaction() |
|-> btrfs_run_delayed_iputs() |
| will handle delayed iputs, |
| that means start_transaction() |
| will be called, which will try |
| to get SB_FREEZE_FS lock. |
To fix this issue, introduce a "int fs_frozen" to record internally whether
fs has been frozen. If fs has been frozen, we can not handle delayed iputs.
Signed-off-by: Wang Xiaoguang <wangxg.fnst@cn.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ add comment to btrfs_freeze ]
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-01 13:28:08 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-06 02:13:12 +08:00
|
|
|
static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
|
|
|
|
struct btrfs_fs_devices *cur_devices;
|
|
|
|
struct btrfs_device *dev, *first_dev = NULL;
|
|
|
|
struct list_head *head;
|
|
|
|
|
2018-03-16 10:27:02 +08:00
|
|
|
/*
|
|
|
|
* Lightweight locking of the devices. We should not need
|
|
|
|
* device_list_mutex here as we only read the device data and the list
|
|
|
|
* is protected by RCU. Even if a device is deleted during the list
|
|
|
|
* traversals, we'll get valid data, the freeing callback will wait at
|
2018-11-28 19:05:13 +08:00
|
|
|
* least until the rcu_read_unlock.
|
2018-03-16 10:27:02 +08:00
|
|
|
*/
|
|
|
|
rcu_read_lock();
|
2012-06-06 02:13:12 +08:00
|
|
|
cur_devices = fs_info->fs_devices;
|
|
|
|
while (cur_devices) {
|
|
|
|
head = &cur_devices->devices;
|
2018-03-16 10:27:02 +08:00
|
|
|
list_for_each_entry_rcu(dev, head, dev_list) {
|
2017-12-04 12:54:54 +08:00
|
|
|
if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
|
2012-08-02 22:22:20 +08:00
|
|
|
continue;
|
2014-06-30 17:12:48 +08:00
|
|
|
if (!dev->name)
|
|
|
|
continue;
|
2012-06-06 02:13:12 +08:00
|
|
|
if (!first_dev || dev->devid < first_dev->devid)
|
|
|
|
first_dev = dev;
|
|
|
|
}
|
|
|
|
cur_devices = cur_devices->seed;
|
|
|
|
}
|
|
|
|
|
2018-08-02 15:19:07 +08:00
|
|
|
if (first_dev)
|
|
|
|
seq_escape(m, rcu_str_deref(first_dev->name), " \t\n\\");
|
|
|
|
else
|
2012-06-06 02:13:12 +08:00
|
|
|
WARN_ON(1);
|
2018-03-16 10:27:02 +08:00
|
|
|
rcu_read_unlock();
|
2012-06-06 02:13:12 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-22 08:01:09 +08:00
|
|
|
static const struct super_operations btrfs_super_ops = {
|
2009-09-22 04:00:26 +08:00
|
|
|
.drop_inode = btrfs_drop_inode,
|
2010-06-07 23:35:40 +08:00
|
|
|
.evict_inode = btrfs_evict_inode,
|
2007-03-23 00:13:20 +08:00
|
|
|
.put_super = btrfs_put_super,
|
2007-03-23 22:01:08 +08:00
|
|
|
.sync_fs = btrfs_sync_fs,
|
2009-04-03 04:46:06 +08:00
|
|
|
.show_options = btrfs_show_options,
|
2012-06-06 02:13:12 +08:00
|
|
|
.show_devname = btrfs_show_devname,
|
2007-04-02 22:50:19 +08:00
|
|
|
.alloc_inode = btrfs_alloc_inode,
|
|
|
|
.destroy_inode = btrfs_destroy_inode,
|
2019-04-11 03:14:41 +08:00
|
|
|
.free_inode = btrfs_free_inode,
|
2007-04-20 09:01:03 +08:00
|
|
|
.statfs = btrfs_statfs,
|
2008-11-13 03:34:12 +08:00
|
|
|
.remount_fs = btrfs_remount,
|
2009-01-10 22:09:52 +08:00
|
|
|
.freeze_fs = btrfs_freeze,
|
btrfs: fix fsfreeze hang caused by delayed iputs deal
When running fstests generic/068, sometimes we got below deadlock:
xfs_io D ffff8800331dbb20 0 6697 6693 0x00000080
ffff8800331dbb20 ffff88007acfc140 ffff880034d895c0 ffff8800331dc000
ffff880032d243e8 fffffffeffffffff ffff880032d24400 0000000000000001
ffff8800331dbb38 ffffffff816a9045 ffff880034d895c0 ffff8800331dbba8
Call Trace:
[<ffffffff816a9045>] schedule+0x35/0x80
[<ffffffff816abab2>] rwsem_down_read_failed+0xf2/0x140
[<ffffffff8118f5e1>] ? __filemap_fdatawrite_range+0xd1/0x100
[<ffffffff8134f978>] call_rwsem_down_read_failed+0x18/0x30
[<ffffffffa06631fc>] ? btrfs_alloc_block_rsv+0x2c/0xb0 [btrfs]
[<ffffffff810d32b5>] percpu_down_read+0x35/0x50
[<ffffffff81217dfc>] __sb_start_write+0x2c/0x40
[<ffffffffa067f5d5>] start_transaction+0x2a5/0x4d0 [btrfs]
[<ffffffffa067f857>] btrfs_join_transaction+0x17/0x20 [btrfs]
[<ffffffffa068ba34>] btrfs_evict_inode+0x3c4/0x5d0 [btrfs]
[<ffffffff81230a1a>] evict+0xba/0x1a0
[<ffffffff812316b6>] iput+0x196/0x200
[<ffffffffa06851d0>] btrfs_run_delayed_iputs+0x70/0xc0 [btrfs]
[<ffffffffa067f1d8>] btrfs_commit_transaction+0x928/0xa80 [btrfs]
[<ffffffffa0646df0>] btrfs_freeze+0x30/0x40 [btrfs]
[<ffffffff81218040>] freeze_super+0xf0/0x190
[<ffffffff81229275>] do_vfs_ioctl+0x4a5/0x5c0
[<ffffffff81003176>] ? do_audit_syscall_entry+0x66/0x70
[<ffffffff810038cf>] ? syscall_trace_enter_phase1+0x11f/0x140
[<ffffffff81229409>] SyS_ioctl+0x79/0x90
[<ffffffff81003c12>] do_syscall_64+0x62/0x110
[<ffffffff816acbe1>] entry_SYSCALL64_slow_path+0x25/0x25
>From this warning, freeze_super() already holds SB_FREEZE_FS, but
btrfs_freeze() will call btrfs_commit_transaction() again, if
btrfs_commit_transaction() finds that it has delayed iputs to handle,
it'll start_transaction(), which will try to get SB_FREEZE_FS lock
again, then deadlock occurs.
The root cause is that in btrfs, sync_filesystem(sb) does not make
sure all metadata is updated. There still maybe some codes adding
delayed iputs, see below sample race window:
CPU1 | CPU2
|-> freeze_super() |
|-> sync_filesystem(sb); |
| |-> cleaner_kthread()
| | |-> btrfs_delete_unused_bgs()
| | |-> btrfs_remove_chunk()
| | |-> btrfs_remove_block_group()
| | |-> btrfs_add_delayed_iput()
| |
|-> sb->s_writers.frozen = SB_FREEZE_FS; |
|-> sb_wait_write(sb, SB_FREEZE_FS); |
| acquire SB_FREEZE_FS lock. |
| |
|-> btrfs_freeze() |
|-> btrfs_commit_transaction() |
|-> btrfs_run_delayed_iputs() |
| will handle delayed iputs, |
| that means start_transaction() |
| will be called, which will try |
| to get SB_FREEZE_FS lock. |
To fix this issue, introduce a "int fs_frozen" to record internally whether
fs has been frozen. If fs has been frozen, we can not handle delayed iputs.
Signed-off-by: Wang Xiaoguang <wangxg.fnst@cn.fujitsu.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ add comment to btrfs_freeze ]
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-01 13:28:08 +08:00
|
|
|
.unfreeze_fs = btrfs_unfreeze,
|
2007-03-23 00:13:20 +08:00
|
|
|
};
|
2008-03-25 03:02:04 +08:00
|
|
|
|
|
|
|
static const struct file_operations btrfs_ctl_fops = {
|
2015-03-24 23:35:49 +08:00
|
|
|
.open = btrfs_control_open,
|
2008-03-25 03:02:04 +08:00
|
|
|
.unlocked_ioctl = btrfs_control_ioctl,
|
2018-09-12 03:59:08 +08:00
|
|
|
.compat_ioctl = compat_ptr_ioctl,
|
2008-03-25 03:02:04 +08:00
|
|
|
.owner = THIS_MODULE,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-16 00:52:59 +08:00
|
|
|
.llseek = noop_llseek,
|
2008-03-25 03:02:04 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct miscdevice btrfs_misc = {
|
driver core: add devname module aliases to allow module on-demand auto-loading
This adds:
alias: devname:<name>
to some common kernel modules, which will allow the on-demand loading
of the kernel module when the device node is accessed.
Ideally all these modules would be compiled-in, but distros seems too
much in love with their modularization that we need to cover the common
cases with this new facility. It will allow us to remove a bunch of pretty
useless init scripts and modprobes from init scripts.
The static device node aliases will be carried in the module itself. The
program depmod will extract this information to a file in the module directory:
$ cat /lib/modules/2.6.34-00650-g537b60d-dirty/modules.devname
# Device nodes to trigger on-demand module loading.
microcode cpu/microcode c10:184
fuse fuse c10:229
ppp_generic ppp c108:0
tun net/tun c10:200
dm_mod mapper/control c10:235
Udev will pick up the depmod created file on startup and create all the
static device nodes which the kernel modules specify, so that these modules
get automatically loaded when the device node is accessed:
$ /sbin/udevd --debug
...
static_dev_create_from_modules: mknod '/dev/cpu/microcode' c10:184
static_dev_create_from_modules: mknod '/dev/fuse' c10:229
static_dev_create_from_modules: mknod '/dev/ppp' c108:0
static_dev_create_from_modules: mknod '/dev/net/tun' c10:200
static_dev_create_from_modules: mknod '/dev/mapper/control' c10:235
udev_rules_apply_static_dev_perms: chmod '/dev/net/tun' 0666
udev_rules_apply_static_dev_perms: chmod '/dev/fuse' 0666
A few device nodes are switched to statically allocated numbers, to allow
the static nodes to work. This might also useful for systems which still run
a plain static /dev, which is completely unsafe to use with any dynamic minor
numbers.
Note:
The devname aliases must be limited to the *common* and *single*instance*
device nodes, like the misc devices, and never be used for conceptually limited
systems like the loop devices, which should rather get fixed properly and get a
control node for losetup to talk to, instead of creating a random number of
device nodes in advance, regardless if they are ever used.
This facility is to hide the mess distros are creating with too modualized
kernels, and just to hide that these modules are not compiled-in, and not to
paper-over broken concepts. Thanks! :)
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Cc: David S. Miller <davem@davemloft.net>
Cc: Miklos Szeredi <miklos@szeredi.hu>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Alasdair G Kergon <agk@redhat.com>
Cc: Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
Cc: Ian Kent <raven@themaw.net>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-05-21 00:07:20 +08:00
|
|
|
.minor = BTRFS_MINOR,
|
2008-03-25 03:02:04 +08:00
|
|
|
.name = "btrfs-control",
|
|
|
|
.fops = &btrfs_ctl_fops
|
|
|
|
};
|
|
|
|
|
driver core: add devname module aliases to allow module on-demand auto-loading
This adds:
alias: devname:<name>
to some common kernel modules, which will allow the on-demand loading
of the kernel module when the device node is accessed.
Ideally all these modules would be compiled-in, but distros seems too
much in love with their modularization that we need to cover the common
cases with this new facility. It will allow us to remove a bunch of pretty
useless init scripts and modprobes from init scripts.
The static device node aliases will be carried in the module itself. The
program depmod will extract this information to a file in the module directory:
$ cat /lib/modules/2.6.34-00650-g537b60d-dirty/modules.devname
# Device nodes to trigger on-demand module loading.
microcode cpu/microcode c10:184
fuse fuse c10:229
ppp_generic ppp c108:0
tun net/tun c10:200
dm_mod mapper/control c10:235
Udev will pick up the depmod created file on startup and create all the
static device nodes which the kernel modules specify, so that these modules
get automatically loaded when the device node is accessed:
$ /sbin/udevd --debug
...
static_dev_create_from_modules: mknod '/dev/cpu/microcode' c10:184
static_dev_create_from_modules: mknod '/dev/fuse' c10:229
static_dev_create_from_modules: mknod '/dev/ppp' c108:0
static_dev_create_from_modules: mknod '/dev/net/tun' c10:200
static_dev_create_from_modules: mknod '/dev/mapper/control' c10:235
udev_rules_apply_static_dev_perms: chmod '/dev/net/tun' 0666
udev_rules_apply_static_dev_perms: chmod '/dev/fuse' 0666
A few device nodes are switched to statically allocated numbers, to allow
the static nodes to work. This might also useful for systems which still run
a plain static /dev, which is completely unsafe to use with any dynamic minor
numbers.
Note:
The devname aliases must be limited to the *common* and *single*instance*
device nodes, like the misc devices, and never be used for conceptually limited
systems like the loop devices, which should rather get fixed properly and get a
control node for losetup to talk to, instead of creating a random number of
device nodes in advance, regardless if they are ever used.
This facility is to hide the mess distros are creating with too modualized
kernels, and just to hide that these modules are not compiled-in, and not to
paper-over broken concepts. Thanks! :)
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Cc: David S. Miller <davem@davemloft.net>
Cc: Miklos Szeredi <miklos@szeredi.hu>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Alasdair G Kergon <agk@redhat.com>
Cc: Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
Cc: Ian Kent <raven@themaw.net>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-05-21 00:07:20 +08:00
|
|
|
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
|
|
|
|
MODULE_ALIAS("devname:btrfs-control");
|
|
|
|
|
2017-11-03 07:21:50 +08:00
|
|
|
static int __init btrfs_interface_init(void)
|
2008-03-25 03:02:04 +08:00
|
|
|
{
|
|
|
|
return misc_register(&btrfs_misc);
|
|
|
|
}
|
|
|
|
|
2018-02-20 00:24:18 +08:00
|
|
|
static __cold void btrfs_interface_exit(void)
|
2008-03-25 03:02:04 +08:00
|
|
|
{
|
2015-07-31 06:59:57 +08:00
|
|
|
misc_deregister(&btrfs_misc);
|
2008-03-25 03:02:04 +08:00
|
|
|
}
|
|
|
|
|
2017-11-03 07:21:50 +08:00
|
|
|
static void __init btrfs_print_mod_info(void)
|
2013-05-01 00:51:59 +08:00
|
|
|
{
|
2018-06-21 01:03:33 +08:00
|
|
|
static const char options[] = ""
|
2013-05-01 00:51:59 +08:00
|
|
|
#ifdef CONFIG_BTRFS_DEBUG
|
|
|
|
", debug=on"
|
|
|
|
#endif
|
2013-09-03 21:25:27 +08:00
|
|
|
#ifdef CONFIG_BTRFS_ASSERT
|
|
|
|
", assert=on"
|
|
|
|
#endif
|
2013-05-01 00:51:59 +08:00
|
|
|
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
|
|
|
|
", integrity-checker=on"
|
2017-09-30 03:43:48 +08:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_BTRFS_FS_REF_VERIFY
|
|
|
|
", ref-verify=on"
|
2013-05-01 00:51:59 +08:00
|
|
|
#endif
|
2018-06-21 01:03:33 +08:00
|
|
|
;
|
|
|
|
pr_info("Btrfs loaded, crc32c=%s%s\n", crc32c_impl(), options);
|
2013-05-01 00:51:59 +08:00
|
|
|
}
|
|
|
|
|
2007-03-21 23:12:56 +08:00
|
|
|
static int __init init_btrfs_fs(void)
|
|
|
|
{
|
2007-04-02 22:50:19 +08:00
|
|
|
int err;
|
2007-08-30 03:47:34 +08:00
|
|
|
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 19:47:46 +08:00
|
|
|
btrfs_props_init();
|
|
|
|
|
2007-08-30 03:47:34 +08:00
|
|
|
err = btrfs_init_sysfs();
|
|
|
|
if (err)
|
btrfs: Remove custom crc32c init code
The custom crc32 init code was introduced in
14a958e678cd ("Btrfs: fix btrfs boot when compiled as built-in") to
enable using btrfs as a built-in. However, later as pointed out by
60efa5eb2e88 ("Btrfs: use late_initcall instead of module_init") this
wasn't enough and finally btrfs was switched to late_initcall which
comes after the generic crc32c implementation is initiliased. The
latter commit superseeded the former. Now that we don't have to
maintain our own code let's just remove it and switch to using the
generic implementation.
Despite touching a lot of files the patch is really simple. Here is the gist of
the changes:
1. Select LIBCRC32C rather than the low-level modules.
2. s/btrfs_crc32c/crc32c/g
3. replace hash.h with linux/crc32c.h
4. Move the btrfs namehash funcs to ctree.h and change the tree accordingly.
I've tested this with btrfs being both a module and a built-in and xfstest
doesn't complain.
Does seem to fix the longstanding problem of not automatically selectiong
the crc32c module when btrfs is used. Possibly there is a workaround in
dracut.
The modinfo confirms that now all the module dependencies are there:
before:
depends: zstd_compress,zstd_decompress,raid6_pq,xor,zlib_deflate
after:
depends: libcrc32c,zstd_compress,zstd_decompress,raid6_pq,xor,zlib_deflate
Signed-off-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ add more info to changelog from mails ]
Signed-off-by: David Sterba <dsterba@suse.com>
2018-01-08 17:45:05 +08:00
|
|
|
return err;
|
2007-08-30 03:47:34 +08:00
|
|
|
|
2012-03-01 21:56:26 +08:00
|
|
|
btrfs_init_compress();
|
2008-01-25 05:13:08 +08:00
|
|
|
|
2010-12-17 14:21:50 +08:00
|
|
|
err = btrfs_init_cachep();
|
|
|
|
if (err)
|
|
|
|
goto free_compress;
|
|
|
|
|
2008-01-25 05:13:08 +08:00
|
|
|
err = extent_io_init();
|
2007-11-19 23:22:33 +08:00
|
|
|
if (err)
|
|
|
|
goto free_cachep;
|
|
|
|
|
2019-09-23 22:05:18 +08:00
|
|
|
err = extent_state_cache_init();
|
2008-01-25 05:13:08 +08:00
|
|
|
if (err)
|
|
|
|
goto free_extent_io;
|
|
|
|
|
2019-09-23 22:05:18 +08:00
|
|
|
err = extent_map_init();
|
|
|
|
if (err)
|
|
|
|
goto free_extent_state_cache;
|
|
|
|
|
2012-09-06 18:01:51 +08:00
|
|
|
err = ordered_data_init();
|
2007-11-19 23:22:33 +08:00
|
|
|
if (err)
|
|
|
|
goto free_extent_map;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-30 02:49:59 +08:00
|
|
|
|
2012-09-06 18:01:51 +08:00
|
|
|
err = btrfs_delayed_inode_init();
|
|
|
|
if (err)
|
|
|
|
goto free_ordered_data;
|
|
|
|
|
2012-11-26 17:24:43 +08:00
|
|
|
err = btrfs_auto_defrag_init();
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
if (err)
|
|
|
|
goto free_delayed_inode;
|
|
|
|
|
2012-11-21 10:21:28 +08:00
|
|
|
err = btrfs_delayed_ref_init();
|
2012-11-26 17:24:43 +08:00
|
|
|
if (err)
|
|
|
|
goto free_auto_defrag;
|
|
|
|
|
2013-08-09 13:25:36 +08:00
|
|
|
err = btrfs_prelim_ref_init();
|
|
|
|
if (err)
|
2014-07-30 06:58:37 +08:00
|
|
|
goto free_delayed_ref;
|
2013-08-09 13:25:36 +08:00
|
|
|
|
2014-07-30 06:55:42 +08:00
|
|
|
err = btrfs_end_io_wq_init();
|
2012-11-21 10:21:28 +08:00
|
|
|
if (err)
|
2014-07-30 06:58:37 +08:00
|
|
|
goto free_prelim_ref;
|
2012-11-21 10:21:28 +08:00
|
|
|
|
2014-07-30 06:55:42 +08:00
|
|
|
err = btrfs_interface_init();
|
|
|
|
if (err)
|
|
|
|
goto free_end_io_wq;
|
|
|
|
|
2012-03-24 00:14:20 +08:00
|
|
|
btrfs_init_lockdep();
|
|
|
|
|
2016-03-10 12:49:14 +08:00
|
|
|
btrfs_print_mod_info();
|
2013-08-15 03:05:12 +08:00
|
|
|
|
|
|
|
err = btrfs_run_sanity_tests();
|
|
|
|
if (err)
|
|
|
|
goto unregister_ioctl;
|
|
|
|
|
|
|
|
err = register_filesystem(&btrfs_fs_type);
|
|
|
|
if (err)
|
|
|
|
goto unregister_ioctl;
|
2013-03-15 21:47:08 +08:00
|
|
|
|
2007-11-19 23:22:33 +08:00
|
|
|
return 0;
|
|
|
|
|
2008-03-25 03:02:04 +08:00
|
|
|
unregister_ioctl:
|
|
|
|
btrfs_interface_exit();
|
2014-07-30 06:55:42 +08:00
|
|
|
free_end_io_wq:
|
|
|
|
btrfs_end_io_wq_exit();
|
2013-08-09 13:25:36 +08:00
|
|
|
free_prelim_ref:
|
|
|
|
btrfs_prelim_ref_exit();
|
2012-11-21 10:21:28 +08:00
|
|
|
free_delayed_ref:
|
|
|
|
btrfs_delayed_ref_exit();
|
2012-11-26 17:24:43 +08:00
|
|
|
free_auto_defrag:
|
|
|
|
btrfs_auto_defrag_exit();
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
free_delayed_inode:
|
|
|
|
btrfs_delayed_inode_exit();
|
2012-09-06 18:01:51 +08:00
|
|
|
free_ordered_data:
|
|
|
|
ordered_data_exit();
|
2007-11-19 23:22:33 +08:00
|
|
|
free_extent_map:
|
|
|
|
extent_map_exit();
|
2019-09-23 22:05:18 +08:00
|
|
|
free_extent_state_cache:
|
|
|
|
extent_state_cache_exit();
|
2008-01-25 05:13:08 +08:00
|
|
|
free_extent_io:
|
|
|
|
extent_io_exit();
|
2007-11-19 23:22:33 +08:00
|
|
|
free_cachep:
|
|
|
|
btrfs_destroy_cachep();
|
2010-12-17 14:21:50 +08:00
|
|
|
free_compress:
|
|
|
|
btrfs_exit_compress();
|
2007-11-19 23:22:33 +08:00
|
|
|
btrfs_exit_sysfs();
|
btrfs: Remove custom crc32c init code
The custom crc32 init code was introduced in
14a958e678cd ("Btrfs: fix btrfs boot when compiled as built-in") to
enable using btrfs as a built-in. However, later as pointed out by
60efa5eb2e88 ("Btrfs: use late_initcall instead of module_init") this
wasn't enough and finally btrfs was switched to late_initcall which
comes after the generic crc32c implementation is initiliased. The
latter commit superseeded the former. Now that we don't have to
maintain our own code let's just remove it and switch to using the
generic implementation.
Despite touching a lot of files the patch is really simple. Here is the gist of
the changes:
1. Select LIBCRC32C rather than the low-level modules.
2. s/btrfs_crc32c/crc32c/g
3. replace hash.h with linux/crc32c.h
4. Move the btrfs namehash funcs to ctree.h and change the tree accordingly.
I've tested this with btrfs being both a module and a built-in and xfstest
doesn't complain.
Does seem to fix the longstanding problem of not automatically selectiong
the crc32c module when btrfs is used. Possibly there is a workaround in
dracut.
The modinfo confirms that now all the module dependencies are there:
before:
depends: zstd_compress,zstd_decompress,raid6_pq,xor,zlib_deflate
after:
depends: libcrc32c,zstd_compress,zstd_decompress,raid6_pq,xor,zlib_deflate
Signed-off-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ add more info to changelog from mails ]
Signed-off-by: David Sterba <dsterba@suse.com>
2018-01-08 17:45:05 +08:00
|
|
|
|
2007-11-19 23:22:33 +08:00
|
|
|
return err;
|
2007-03-21 23:12:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_btrfs_fs(void)
|
|
|
|
{
|
2007-06-12 18:35:45 +08:00
|
|
|
btrfs_destroy_cachep();
|
2012-11-21 10:21:28 +08:00
|
|
|
btrfs_delayed_ref_exit();
|
2012-11-26 17:24:43 +08:00
|
|
|
btrfs_auto_defrag_exit();
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
btrfs_delayed_inode_exit();
|
2013-08-09 13:25:36 +08:00
|
|
|
btrfs_prelim_ref_exit();
|
2012-09-06 18:01:51 +08:00
|
|
|
ordered_data_exit();
|
2007-08-28 04:49:44 +08:00
|
|
|
extent_map_exit();
|
2019-09-23 22:05:18 +08:00
|
|
|
extent_state_cache_exit();
|
2008-01-25 05:13:08 +08:00
|
|
|
extent_io_exit();
|
2008-03-25 03:02:04 +08:00
|
|
|
btrfs_interface_exit();
|
2014-10-16 05:19:59 +08:00
|
|
|
btrfs_end_io_wq_exit();
|
2007-03-21 23:12:56 +08:00
|
|
|
unregister_filesystem(&btrfs_fs_type);
|
2007-08-30 03:47:34 +08:00
|
|
|
btrfs_exit_sysfs();
|
2008-03-25 03:02:07 +08:00
|
|
|
btrfs_cleanup_fs_uuids();
|
2010-12-17 14:21:50 +08:00
|
|
|
btrfs_exit_compress();
|
2007-03-21 23:12:56 +08:00
|
|
|
}
|
|
|
|
|
2014-02-02 05:27:56 +08:00
|
|
|
late_initcall(init_btrfs_fs);
|
2007-03-21 23:12:56 +08:00
|
|
|
module_exit(exit_btrfs_fs)
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
2019-06-03 22:58:57 +08:00
|
|
|
MODULE_SOFTDEP("pre: crc32c");
|
2019-10-07 17:11:01 +08:00
|
|
|
MODULE_SOFTDEP("pre: xxhash64");
|
2019-10-07 17:11:02 +08:00
|
|
|
MODULE_SOFTDEP("pre: sha256");
|
2019-10-07 17:11:02 +08:00
|
|
|
MODULE_SOFTDEP("pre: blake2b-256");
|