2007-06-12 13:07:21 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
|
*/
|
|
|
|
|
|
2007-08-29 13:11:44 +00:00
|
|
|
#include <linux/blkdev.h>
|
2007-03-21 15:12:56 +00:00
|
|
|
#include <linux/module.h>
|
2007-03-22 16:13:20 +00:00
|
|
|
#include <linux/buffer_head.h>
|
2007-03-21 15:12:56 +00:00
|
|
|
#include <linux/fs.h>
|
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
|
#include <linux/time.h>
|
|
|
|
|
#include <linux/init.h>
|
2009-04-02 20:46:06 +00:00
|
|
|
#include <linux/seq_file.h>
|
2007-03-21 15:12:56 +00:00
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/backing-dev.h>
|
2007-08-29 13:11:44 +00:00
|
|
|
#include <linux/mount.h>
|
2007-03-26 20:00:06 +00:00
|
|
|
#include <linux/mpage.h>
|
2007-03-29 15:56:46 +00:00
|
|
|
#include <linux/swap.h>
|
|
|
|
|
#include <linux/writeback.h>
|
2007-04-20 01:01:03 +00:00
|
|
|
#include <linux/statfs.h>
|
2007-06-08 19:33:54 +00:00
|
|
|
#include <linux/compat.h>
|
2007-08-29 13:11:44 +00:00
|
|
|
#include <linux/parser.h>
|
2007-12-18 01:14:04 +00:00
|
|
|
#include <linux/ctype.h>
|
2007-12-18 21:15:09 +00:00
|
|
|
#include <linux/namei.h>
|
2008-03-24 19:02:04 +00:00
|
|
|
#include <linux/miscdevice.h>
|
2009-01-15 21:51:03 +00: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 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-05-26 16:01:56 +00:00
|
|
|
#include <linux/cleancache.h>
|
2011-11-30 15:45:38 +00:00
|
|
|
#include <linux/ratelimit.h>
|
2008-11-20 15:22:27 +00:00
|
|
|
#include "compat.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 10:12:22 +00:00
|
|
|
#include "delayed-inode.h"
|
2007-03-21 15:12:56 +00:00
|
|
|
#include "ctree.h"
|
2007-03-22 16:13:20 +00:00
|
|
|
#include "disk-io.h"
|
2007-03-23 14:01:08 +00:00
|
|
|
#include "transaction.h"
|
2007-04-02 14:50:19 +00:00
|
|
|
#include "btrfs_inode.h"
|
2007-04-10 13:27:04 +00:00
|
|
|
#include "ioctl.h"
|
2007-05-24 17:35:57 +00:00
|
|
|
#include "print-tree.h"
|
2007-11-16 16:45:54 +00:00
|
|
|
#include "xattr.h"
|
2008-03-24 19:02:07 +00:00
|
|
|
#include "volumes.h"
|
2008-07-23 16:12:13 +00:00
|
|
|
#include "version.h"
|
2008-07-20 20:31:56 +00: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-29 18:49:59 +00:00
|
|
|
#include "compression.h"
|
2007-03-21 15:12:56 +00:00
|
|
|
|
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 11:18:59 +00:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
|
#include <trace/events/btrfs.h>
|
|
|
|
|
|
2009-09-22 00:01:09 +00:00
|
|
|
static const struct super_operations btrfs_super_ops;
|
2011-07-25 19:55:42 +00:00
|
|
|
static struct file_system_type btrfs_fs_type;
|
2007-03-29 15:56:46 +00:00
|
|
|
|
2011-01-06 11:30:25 +00:00
|
|
|
static const char *btrfs_decode_error(struct btrfs_fs_info *fs_info, int errno,
|
|
|
|
|
char nbuf[16])
|
|
|
|
|
{
|
|
|
|
|
char *errstr = NULL;
|
|
|
|
|
|
|
|
|
|
switch (errno) {
|
|
|
|
|
case -EIO:
|
|
|
|
|
errstr = "IO failure";
|
|
|
|
|
break;
|
|
|
|
|
case -ENOMEM:
|
|
|
|
|
errstr = "Out of memory";
|
|
|
|
|
break;
|
|
|
|
|
case -EROFS:
|
|
|
|
|
errstr = "Readonly filesystem";
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
if (nbuf) {
|
|
|
|
|
if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
|
|
|
|
|
errstr = nbuf;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return errstr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __save_error_info(struct btrfs_fs_info *fs_info)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* today we only save the error info into ram. Long term we'll
|
|
|
|
|
* also send it down to the disk
|
|
|
|
|
*/
|
|
|
|
|
fs_info->fs_state = BTRFS_SUPER_FLAG_ERROR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* NOTE:
|
|
|
|
|
* We move write_super stuff at umount in order to avoid deadlock
|
|
|
|
|
* for umount hold all lock.
|
|
|
|
|
*/
|
|
|
|
|
static void save_error_info(struct btrfs_fs_info *fs_info)
|
|
|
|
|
{
|
|
|
|
|
__save_error_info(fs_info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* btrfs handle error by forcing the filesystem readonly */
|
|
|
|
|
static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
|
|
|
|
|
{
|
|
|
|
|
struct super_block *sb = fs_info->sb;
|
|
|
|
|
|
|
|
|
|
if (sb->s_flags & MS_RDONLY)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
|
|
|
|
|
sb->s_flags |= MS_RDONLY;
|
|
|
|
|
printk(KERN_INFO "btrfs is forced readonly\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* __btrfs_std_error decodes expected errors from the caller and
|
|
|
|
|
* invokes the approciate error response.
|
|
|
|
|
*/
|
|
|
|
|
void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
|
|
|
|
|
unsigned int line, int errno)
|
|
|
|
|
{
|
|
|
|
|
struct super_block *sb = fs_info->sb;
|
|
|
|
|
char nbuf[16];
|
|
|
|
|
const char *errstr;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Special case: if the error is EROFS, and we're already
|
|
|
|
|
* under MS_RDONLY, then it is safe here.
|
|
|
|
|
*/
|
|
|
|
|
if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
errstr = btrfs_decode_error(fs_info, errno, nbuf);
|
|
|
|
|
printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n",
|
|
|
|
|
sb->s_id, function, line, errstr);
|
|
|
|
|
save_error_info(fs_info);
|
|
|
|
|
|
|
|
|
|
btrfs_handle_error(fs_info);
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
static void btrfs_put_super(struct super_block *sb)
|
2007-04-17 17:26:50 +00:00
|
|
|
{
|
2007-06-12 10:35:45 +00:00
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
2007-04-17 17:26:50 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2007-06-12 10:35:45 +00:00
|
|
|
ret = close_ctree(root);
|
2011-11-17 06:00:31 +00:00
|
|
|
free_fs_info(root->fs_info);
|
2007-06-12 10:35:45 +00:00
|
|
|
sb->s_fs_info = NULL;
|
2010-10-29 19:14:37 +00:00
|
|
|
|
|
|
|
|
(void)ret; /* FIXME: need to fix VFS to return error? */
|
2007-03-29 15:56:46 +00:00
|
|
|
}
|
|
|
|
|
|
2007-08-29 13:11:44 +00:00
|
|
|
enum {
|
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-04 17:38:27 +00:00
|
|
|
Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
|
2010-03-19 18:07:23 +00:00
|
|
|
Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
|
|
|
|
|
Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
|
2010-12-17 06:21:50 +00:00
|
|
|
Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
|
|
|
|
|
Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
|
2011-02-16 18:10:41 +00:00
|
|
|
Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
|
2011-06-03 13:36:29 +00:00
|
|
|
Opt_enospc_debug, Opt_subvolrootid, Opt_defrag,
|
2011-11-03 19:17:42 +00:00
|
|
|
Opt_inode_cache, Opt_no_space_cache, Opt_recovery, Opt_err,
|
2007-08-29 13:11:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static match_table_t tokens = {
|
2008-05-13 17:46:40 +00:00
|
|
|
{Opt_degraded, "degraded"},
|
2007-08-29 13:11:44 +00:00
|
|
|
{Opt_subvol, "subvol=%s"},
|
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-04 17:38:27 +00:00
|
|
|
{Opt_subvolid, "subvolid=%d"},
|
2008-06-10 14:40:46 +00:00
|
|
|
{Opt_device, "device=%s"},
|
2007-12-14 20:30:32 +00:00
|
|
|
{Opt_nodatasum, "nodatasum"},
|
2007-12-18 01:14:01 +00:00
|
|
|
{Opt_nodatacow, "nodatacow"},
|
2008-01-09 14:23:21 +00:00
|
|
|
{Opt_nobarrier, "nobarrier"},
|
2008-01-29 21:03:38 +00:00
|
|
|
{Opt_max_inline, "max_inline=%s"},
|
2008-01-02 15:01:11 +00:00
|
|
|
{Opt_alloc_start, "alloc_start=%s"},
|
2008-06-12 01:47:56 +00:00
|
|
|
{Opt_thread_pool, "thread_pool=%d"},
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 18:49:59 +00:00
|
|
|
{Opt_compress, "compress"},
|
2010-12-17 06:21:50 +00:00
|
|
|
{Opt_compress_type, "compress=%s"},
|
2010-01-28 21:18:15 +00:00
|
|
|
{Opt_compress_force, "compress-force"},
|
2010-12-17 06:21:50 +00:00
|
|
|
{Opt_compress_force_type, "compress-force=%s"},
|
2008-01-18 15:54:22 +00:00
|
|
|
{Opt_ssd, "ssd"},
|
2009-06-10 00:28:34 +00:00
|
|
|
{Opt_ssd_spread, "ssd_spread"},
|
2009-06-09 20:42:22 +00:00
|
|
|
{Opt_nossd, "nossd"},
|
2008-07-24 16:16:36 +00:00
|
|
|
{Opt_noacl, "noacl"},
|
2009-04-02 20:49:40 +00:00
|
|
|
{Opt_notreelog, "notreelog"},
|
2009-04-02 20:59:01 +00:00
|
|
|
{Opt_flushoncommit, "flushoncommit"},
|
2009-04-21 21:40:57 +00:00
|
|
|
{Opt_ratio, "metadata_ratio=%d"},
|
2009-10-14 13:24:59 +00:00
|
|
|
{Opt_discard, "discard"},
|
2010-06-21 18:48:16 +00:00
|
|
|
{Opt_space_cache, "space_cache"},
|
2010-09-21 18:21:34 +00:00
|
|
|
{Opt_clear_cache, "clear_cache"},
|
2010-10-29 19:46:43 +00:00
|
|
|
{Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
|
2011-02-16 18:10:41 +00:00
|
|
|
{Opt_enospc_debug, "enospc_debug"},
|
2011-04-06 07:33:51 +00:00
|
|
|
{Opt_subvolrootid, "subvolrootid=%d"},
|
2011-05-24 19:35:30 +00:00
|
|
|
{Opt_defrag, "autodefrag"},
|
2011-06-03 13:36:29 +00:00
|
|
|
{Opt_inode_cache, "inode_cache"},
|
2011-11-11 15:14:57 +00:00
|
|
|
{Opt_no_space_cache, "nospace_cache"},
|
2011-11-03 19:17:42 +00:00
|
|
|
{Opt_recovery, "recovery"},
|
2008-07-24 16:16:36 +00:00
|
|
|
{Opt_err, NULL},
|
2007-08-29 13:11:44 +00:00
|
|
|
};
|
|
|
|
|
|
2008-06-10 14:40:29 +00:00
|
|
|
/*
|
|
|
|
|
* Regular mount options parser. Everything that is needed only when
|
|
|
|
|
* reading in a new superblock is parsed here.
|
|
|
|
|
*/
|
|
|
|
|
int btrfs_parse_options(struct btrfs_root *root, char *options)
|
2007-08-29 13:11:44 +00:00
|
|
|
{
|
2008-06-10 14:40:29 +00:00
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
2007-08-29 13:11:44 +00:00
|
|
|
substring_t args[MAX_OPT_ARGS];
|
2011-10-03 18:07:49 +00:00
|
|
|
char *p, *num, *orig = NULL;
|
|
|
|
|
u64 cache_gen;
|
2008-06-12 01:47:56 +00:00
|
|
|
int intarg;
|
2009-11-07 06:19:16 +00:00
|
|
|
int ret = 0;
|
2010-12-17 06:21:50 +00:00
|
|
|
char *compress_type;
|
|
|
|
|
bool compress_force = false;
|
2007-12-14 20:30:32 +00:00
|
|
|
|
2011-04-13 13:41:04 +00:00
|
|
|
cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
|
2011-10-03 18:07:49 +00:00
|
|
|
if (cache_gen)
|
|
|
|
|
btrfs_set_opt(info->mount_opt, SPACE_CACHE);
|
|
|
|
|
|
2007-08-29 13:11:44 +00:00
|
|
|
if (!options)
|
2011-10-03 18:07:49 +00:00
|
|
|
goto out;
|
2007-08-29 13:11:44 +00:00
|
|
|
|
2007-12-18 01:14:01 +00:00
|
|
|
/*
|
|
|
|
|
* strsep changes the string, duplicate it because parse_options
|
|
|
|
|
* gets called twice
|
|
|
|
|
*/
|
|
|
|
|
options = kstrdup(options, GFP_NOFS);
|
|
|
|
|
if (!options)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2010-02-25 20:38:35 +00:00
|
|
|
orig = options;
|
2007-12-18 01:14:01 +00:00
|
|
|
|
2008-06-10 14:40:29 +00:00
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
2007-08-29 13:11:44 +00:00
|
|
|
int token;
|
|
|
|
|
if (!*p)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
token = match_token(p, tokens, args);
|
|
|
|
|
switch (token) {
|
2008-05-13 17:46:40 +00:00
|
|
|
case Opt_degraded:
|
2008-06-10 14:40:29 +00:00
|
|
|
printk(KERN_INFO "btrfs: allowing degraded mounts\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, DEGRADED);
|
2008-05-13 17:46:40 +00:00
|
|
|
break;
|
2007-08-29 13:11:44 +00:00
|
|
|
case Opt_subvol:
|
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-04 17:38:27 +00:00
|
|
|
case Opt_subvolid:
|
2011-04-06 07:33:51 +00:00
|
|
|
case Opt_subvolrootid:
|
2008-06-10 14:40:46 +00:00
|
|
|
case Opt_device:
|
2008-06-10 14:40:29 +00:00
|
|
|
/*
|
2008-06-10 14:40:46 +00:00
|
|
|
* These are parsed by btrfs_parse_early_options
|
2008-06-10 14:40:29 +00:00
|
|
|
* and can be happily ignored here.
|
|
|
|
|
*/
|
2007-12-14 20:30:32 +00:00
|
|
|
break;
|
|
|
|
|
case Opt_nodatasum:
|
2009-06-11 13:30:13 +00:00
|
|
|
printk(KERN_INFO "btrfs: setting nodatasum\n");
|
2008-06-10 14:40:29 +00:00
|
|
|
btrfs_set_opt(info->mount_opt, NODATASUM);
|
2007-12-18 01:14:01 +00:00
|
|
|
break;
|
|
|
|
|
case Opt_nodatacow:
|
2008-06-10 14:40:29 +00:00
|
|
|
printk(KERN_INFO "btrfs: setting nodatacow\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, NODATACOW);
|
|
|
|
|
btrfs_set_opt(info->mount_opt, NODATASUM);
|
2007-08-29 13:11:44 +00:00
|
|
|
break;
|
2010-01-28 21:18:15 +00:00
|
|
|
case Opt_compress_force:
|
2010-12-17 06:21:50 +00:00
|
|
|
case Opt_compress_force_type:
|
|
|
|
|
compress_force = true;
|
|
|
|
|
case Opt_compress:
|
|
|
|
|
case Opt_compress_type:
|
|
|
|
|
if (token == Opt_compress ||
|
|
|
|
|
token == Opt_compress_force ||
|
|
|
|
|
strcmp(args[0].from, "zlib") == 0) {
|
|
|
|
|
compress_type = "zlib";
|
|
|
|
|
info->compress_type = BTRFS_COMPRESS_ZLIB;
|
2010-10-25 07:12:26 +00:00
|
|
|
} else if (strcmp(args[0].from, "lzo") == 0) {
|
|
|
|
|
compress_type = "lzo";
|
|
|
|
|
info->compress_type = BTRFS_COMPRESS_LZO;
|
2010-12-17 06:21:50 +00:00
|
|
|
} else {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2010-01-28 21:18:15 +00:00
|
|
|
btrfs_set_opt(info->mount_opt, COMPRESS);
|
2010-12-17 06:21:50 +00:00
|
|
|
if (compress_force) {
|
|
|
|
|
btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
|
|
|
|
|
pr_info("btrfs: force %s compression\n",
|
|
|
|
|
compress_type);
|
|
|
|
|
} else
|
|
|
|
|
pr_info("btrfs: use %s compression\n",
|
|
|
|
|
compress_type);
|
2010-01-28 21:18:15 +00:00
|
|
|
break;
|
2008-01-18 15:54:22 +00:00
|
|
|
case Opt_ssd:
|
2008-06-10 14:40:29 +00:00
|
|
|
printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, SSD);
|
2008-01-18 15:54:22 +00:00
|
|
|
break;
|
2009-06-10 00:28:34 +00:00
|
|
|
case Opt_ssd_spread:
|
|
|
|
|
printk(KERN_INFO "btrfs: use spread ssd "
|
|
|
|
|
"allocation scheme\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, SSD);
|
|
|
|
|
btrfs_set_opt(info->mount_opt, SSD_SPREAD);
|
|
|
|
|
break;
|
2009-06-09 20:42:22 +00:00
|
|
|
case Opt_nossd:
|
2009-06-10 00:28:34 +00:00
|
|
|
printk(KERN_INFO "btrfs: not using ssd allocation "
|
|
|
|
|
"scheme\n");
|
2009-06-10 13:51:32 +00:00
|
|
|
btrfs_set_opt(info->mount_opt, NOSSD);
|
2009-06-09 20:42:22 +00:00
|
|
|
btrfs_clear_opt(info->mount_opt, SSD);
|
2009-06-10 00:28:34 +00:00
|
|
|
btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
|
2009-06-09 20:42:22 +00:00
|
|
|
break;
|
2008-01-09 14:23:21 +00:00
|
|
|
case Opt_nobarrier:
|
2008-06-10 14:40:29 +00:00
|
|
|
printk(KERN_INFO "btrfs: turning off barriers\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, NOBARRIER);
|
2008-01-09 14:23:21 +00:00
|
|
|
break;
|
2008-06-12 01:47:56 +00:00
|
|
|
case Opt_thread_pool:
|
|
|
|
|
intarg = 0;
|
|
|
|
|
match_int(&args[0], &intarg);
|
|
|
|
|
if (intarg) {
|
|
|
|
|
info->thread_pool_size = intarg;
|
|
|
|
|
printk(KERN_INFO "btrfs: thread pool %d\n",
|
|
|
|
|
info->thread_pool_size);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2008-01-29 21:03:38 +00:00
|
|
|
case Opt_max_inline:
|
2008-06-10 14:40:29 +00:00
|
|
|
num = match_strdup(&args[0]);
|
|
|
|
|
if (num) {
|
2010-02-28 10:59:11 +00:00
|
|
|
info->max_inline = memparse(num, NULL);
|
2008-06-10 14:40:29 +00:00
|
|
|
kfree(num);
|
|
|
|
|
|
2008-06-11 20:51:38 +00:00
|
|
|
if (info->max_inline) {
|
|
|
|
|
info->max_inline = max_t(u64,
|
|
|
|
|
info->max_inline,
|
|
|
|
|
root->sectorsize);
|
|
|
|
|
}
|
2008-06-10 14:40:29 +00:00
|
|
|
printk(KERN_INFO "btrfs: max_inline at %llu\n",
|
2009-04-21 19:38:29 +00:00
|
|
|
(unsigned long long)info->max_inline);
|
2008-01-29 21:03:38 +00:00
|
|
|
}
|
|
|
|
|
break;
|
2008-01-02 15:01:11 +00:00
|
|
|
case Opt_alloc_start:
|
2008-06-10 14:40:29 +00:00
|
|
|
num = match_strdup(&args[0]);
|
|
|
|
|
if (num) {
|
2010-02-28 10:59:11 +00:00
|
|
|
info->alloc_start = memparse(num, NULL);
|
2008-06-10 14:40:29 +00:00
|
|
|
kfree(num);
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"btrfs: allocations start at %llu\n",
|
2009-04-21 19:38:29 +00:00
|
|
|
(unsigned long long)info->alloc_start);
|
2008-01-02 15:01:11 +00:00
|
|
|
}
|
|
|
|
|
break;
|
2008-07-24 16:16:36 +00:00
|
|
|
case Opt_noacl:
|
|
|
|
|
root->fs_info->sb->s_flags &= ~MS_POSIXACL;
|
|
|
|
|
break;
|
2009-04-02 20:49:40 +00:00
|
|
|
case Opt_notreelog:
|
|
|
|
|
printk(KERN_INFO "btrfs: disabling tree log\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, NOTREELOG);
|
|
|
|
|
break;
|
2009-04-02 20:59:01 +00:00
|
|
|
case Opt_flushoncommit:
|
|
|
|
|
printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
|
|
|
|
|
break;
|
2009-04-21 21:40:57 +00:00
|
|
|
case Opt_ratio:
|
|
|
|
|
intarg = 0;
|
|
|
|
|
match_int(&args[0], &intarg);
|
|
|
|
|
if (intarg) {
|
|
|
|
|
info->metadata_ratio = intarg;
|
|
|
|
|
printk(KERN_INFO "btrfs: metadata ratio %d\n",
|
|
|
|
|
info->metadata_ratio);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2009-10-14 13:24:59 +00:00
|
|
|
case Opt_discard:
|
|
|
|
|
btrfs_set_opt(info->mount_opt, DISCARD);
|
|
|
|
|
break;
|
2010-06-21 18:48:16 +00:00
|
|
|
case Opt_space_cache:
|
|
|
|
|
btrfs_set_opt(info->mount_opt, SPACE_CACHE);
|
2010-11-19 13:40:41 +00:00
|
|
|
break;
|
2011-10-03 18:07:49 +00:00
|
|
|
case Opt_no_space_cache:
|
|
|
|
|
printk(KERN_INFO "btrfs: disabling disk space caching\n");
|
|
|
|
|
btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
|
|
|
|
|
break;
|
2011-06-03 13:36:29 +00:00
|
|
|
case Opt_inode_cache:
|
|
|
|
|
printk(KERN_INFO "btrfs: enabling inode map caching\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
|
|
|
|
|
break;
|
2010-09-21 18:21:34 +00:00
|
|
|
case Opt_clear_cache:
|
|
|
|
|
printk(KERN_INFO "btrfs: force clearing of disk cache\n");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
|
2010-06-21 18:48:16 +00:00
|
|
|
break;
|
2010-10-29 19:46:43 +00:00
|
|
|
case Opt_user_subvol_rm_allowed:
|
|
|
|
|
btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
|
|
|
|
|
break;
|
2011-02-16 18:10:41 +00:00
|
|
|
case Opt_enospc_debug:
|
|
|
|
|
btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
|
|
|
|
|
break;
|
2011-05-24 19:35:30 +00:00
|
|
|
case Opt_defrag:
|
|
|
|
|
printk(KERN_INFO "btrfs: enabling auto defrag");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
|
|
|
|
|
break;
|
2011-11-03 19:17:42 +00:00
|
|
|
case Opt_recovery:
|
|
|
|
|
printk(KERN_INFO "btrfs: enabling auto recovery");
|
|
|
|
|
btrfs_set_opt(info->mount_opt, RECOVERY);
|
|
|
|
|
break;
|
2009-11-07 06:19:16 +00:00
|
|
|
case Opt_err:
|
|
|
|
|
printk(KERN_INFO "btrfs: unrecognized mount option "
|
|
|
|
|
"'%s'\n", p);
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
2007-08-29 13:11:44 +00:00
|
|
|
default:
|
2007-12-18 01:14:01 +00:00
|
|
|
break;
|
2007-08-29 13:11:44 +00:00
|
|
|
}
|
|
|
|
|
}
|
2009-11-07 06:19:16 +00:00
|
|
|
out:
|
2011-10-03 18:07:49 +00:00
|
|
|
if (!ret && btrfs_test_opt(root, SPACE_CACHE))
|
|
|
|
|
printk(KERN_INFO "btrfs: disk space caching is enabled\n");
|
2010-02-25 20:38:35 +00:00
|
|
|
kfree(orig);
|
2009-11-07 06:19:16 +00:00
|
|
|
return ret;
|
2008-06-10 14:40:29 +00: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.
|
|
|
|
|
*/
|
2008-12-02 11:36:09 +00:00
|
|
|
static int btrfs_parse_early_options(const char *options, fmode_t flags,
|
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-04 17:38:27 +00:00
|
|
|
void *holder, char **subvol_name, u64 *subvol_objectid,
|
2011-04-06 07:33:51 +00:00
|
|
|
u64 *subvol_rootid, struct btrfs_fs_devices **fs_devices)
|
2008-06-10 14:40:29 +00:00
|
|
|
{
|
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
2011-09-14 06:11:21 +00:00
|
|
|
char *device_name, *opts, *orig, *p;
|
2008-06-10 14:40:29 +00:00
|
|
|
int error = 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-04 17:38:27 +00:00
|
|
|
int intarg;
|
2008-06-10 14:40:29 +00:00
|
|
|
|
|
|
|
|
if (!options)
|
2011-07-25 19:55:42 +00:00
|
|
|
return 0;
|
2008-06-10 14:40:29 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* strsep changes the string, duplicate it because parse_options
|
|
|
|
|
* gets called twice
|
|
|
|
|
*/
|
|
|
|
|
opts = kstrdup(options, GFP_KERNEL);
|
|
|
|
|
if (!opts)
|
|
|
|
|
return -ENOMEM;
|
2010-12-27 08:43:13 +00:00
|
|
|
orig = opts;
|
2008-06-10 14:40:29 +00: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 14:47:55 +00:00
|
|
|
kfree(*subvol_name);
|
2008-06-10 14:40:29 +00:00
|
|
|
*subvol_name = match_strdup(&args[0]);
|
|
|
|
|
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-04 17:38:27 +00:00
|
|
|
case Opt_subvolid:
|
|
|
|
|
intarg = 0;
|
2009-12-14 19:18:38 +00:00
|
|
|
error = match_int(&args[0], &intarg);
|
|
|
|
|
if (!error) {
|
|
|
|
|
/* we want the original fs_tree */
|
|
|
|
|
if (!intarg)
|
|
|
|
|
*subvol_objectid =
|
|
|
|
|
BTRFS_FS_TREE_OBJECTID;
|
|
|
|
|
else
|
|
|
|
|
*subvol_objectid = intarg;
|
|
|
|
|
}
|
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-04 17:38:27 +00:00
|
|
|
break;
|
2011-04-06 07:33:51 +00:00
|
|
|
case Opt_subvolrootid:
|
|
|
|
|
intarg = 0;
|
|
|
|
|
error = match_int(&args[0], &intarg);
|
|
|
|
|
if (!error) {
|
|
|
|
|
/* we want the original fs_tree */
|
|
|
|
|
if (!intarg)
|
|
|
|
|
*subvol_rootid =
|
|
|
|
|
BTRFS_FS_TREE_OBJECTID;
|
|
|
|
|
else
|
|
|
|
|
*subvol_rootid = intarg;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2008-06-10 14:40:46 +00:00
|
|
|
case Opt_device:
|
2011-09-14 06:11:21 +00:00
|
|
|
device_name = match_strdup(&args[0]);
|
|
|
|
|
if (!device_name) {
|
|
|
|
|
error = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
error = btrfs_scan_one_device(device_name,
|
2008-06-10 14:40:46 +00:00
|
|
|
flags, holder, fs_devices);
|
2011-09-14 06:11:21 +00:00
|
|
|
kfree(device_name);
|
2008-06-10 14:40:46 +00:00
|
|
|
if (error)
|
2011-07-25 19:55:42 +00:00
|
|
|
goto out;
|
2008-06-10 14:40:46 +00:00
|
|
|
break;
|
2008-06-10 14:40:29 +00:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-25 19:55:42 +00:00
|
|
|
out:
|
2010-12-27 08:43:13 +00:00
|
|
|
kfree(orig);
|
2008-06-10 14:40:29 +00:00
|
|
|
return error;
|
2007-08-29 13:11:44 +00: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-04 17:38:27 +00:00
|
|
|
static struct dentry *get_default_root(struct super_block *sb,
|
|
|
|
|
u64 subvol_objectid)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = sb->s_fs_info;
|
|
|
|
|
struct btrfs_root *new_root;
|
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
|
struct btrfs_path *path;
|
|
|
|
|
struct btrfs_key location;
|
|
|
|
|
struct inode *inode;
|
|
|
|
|
u64 dir_id;
|
|
|
|
|
int new = 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We have a specific subvol we want to mount, just setup location and
|
|
|
|
|
* go look up the root.
|
|
|
|
|
*/
|
|
|
|
|
if (subvol_objectid) {
|
|
|
|
|
location.objectid = subvol_objectid;
|
|
|
|
|
location.type = BTRFS_ROOT_ITEM_KEY;
|
|
|
|
|
location.offset = (u64)-1;
|
|
|
|
|
goto find_root;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
if (!path)
|
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
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-04-13 13:41:04 +00:00
|
|
|
dir_id = btrfs_super_root_dir(root->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-04 17:38:27 +00:00
|
|
|
di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
|
2011-05-14 07:10:51 +00:00
|
|
|
if (IS_ERR(di)) {
|
|
|
|
|
btrfs_free_path(path);
|
2010-05-29 09:40:57 +00:00
|
|
|
return ERR_CAST(di);
|
2011-05-14 07:10:51 +00: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-04 17:38:27 +00: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
|
|
|
|
|
* mount to root most subvolume.
|
|
|
|
|
*/
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
dir_id = BTRFS_FIRST_FREE_OBJECTID;
|
|
|
|
|
new_root = root->fs_info->fs_root;
|
|
|
|
|
goto setup_root;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
|
|
|
|
|
find_root:
|
|
|
|
|
new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
|
|
|
|
|
if (IS_ERR(new_root))
|
2010-10-29 19:14:23 +00:00
|
|
|
return ERR_CAST(new_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-04 17:38:27 +00:00
|
|
|
|
|
|
|
|
if (btrfs_root_refs(&new_root->root_item) == 0)
|
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
|
|
|
|
|
dir_id = btrfs_root_dirid(&new_root->root_item);
|
|
|
|
|
setup_root:
|
|
|
|
|
location.objectid = dir_id;
|
|
|
|
|
location.type = BTRFS_INODE_ITEM_KEY;
|
|
|
|
|
location.offset = 0;
|
|
|
|
|
|
|
|
|
|
inode = btrfs_iget(sb, &location, new_root, &new);
|
2010-05-29 09:42:19 +00:00
|
|
|
if (IS_ERR(inode))
|
|
|
|
|
return ERR_CAST(inode);
|
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-04 17:38:27 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If we're just mounting the root most subvol put the inode and return
|
|
|
|
|
* a reference to the dentry. We will have already gotten a reference
|
|
|
|
|
* to the inode in btrfs_fill_super so we're good to go.
|
|
|
|
|
*/
|
|
|
|
|
if (!new && sb->s_root->d_inode == inode) {
|
|
|
|
|
iput(inode);
|
|
|
|
|
return dget(sb->s_root);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-25 19:40:35 +00:00
|
|
|
return d_obtain_alias(inode);
|
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-04 17:38:27 +00:00
|
|
|
}
|
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
static int btrfs_fill_super(struct super_block *sb,
|
2008-03-24 19:02:07 +00:00
|
|
|
struct btrfs_fs_devices *fs_devices,
|
2009-01-06 02:25:51 +00:00
|
|
|
void *data, int silent)
|
2007-03-29 15:56:46 +00:00
|
|
|
{
|
2009-01-06 02:25:51 +00:00
|
|
|
struct inode *inode;
|
|
|
|
|
struct dentry *root_dentry;
|
2007-06-12 10:35:45 +00:00
|
|
|
struct btrfs_root *tree_root;
|
2011-11-17 06:00:31 +00:00
|
|
|
struct btrfs_fs_info *fs_info;
|
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 14:45:14 +00:00
|
|
|
struct btrfs_key key;
|
2007-06-12 10:35:45 +00:00
|
|
|
int err;
|
2007-04-18 20:15:28 +00:00
|
|
|
|
2007-06-12 10:35:45 +00:00
|
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
|
|
|
|
sb->s_magic = BTRFS_SUPER_MAGIC;
|
|
|
|
|
sb->s_op = &btrfs_super_ops;
|
2010-12-20 15:56:06 +00:00
|
|
|
sb->s_d_op = &btrfs_dentry_operations;
|
2008-07-20 20:31:56 +00:00
|
|
|
sb->s_export_op = &btrfs_export_ops;
|
2007-11-16 16:45:54 +00:00
|
|
|
sb->s_xattr = btrfs_xattr_handlers;
|
2007-06-12 10:35:45 +00:00
|
|
|
sb->s_time_gran = 1;
|
2009-10-13 17:50:18 +00:00
|
|
|
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
|
2008-07-24 16:16:36 +00:00
|
|
|
sb->s_flags |= MS_POSIXACL;
|
2009-09-29 17:51:04 +00:00
|
|
|
#endif
|
2007-04-18 20:15:28 +00:00
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
tree_root = open_ctree(sb, fs_devices, (char *)data);
|
2007-04-16 13:22:45 +00:00
|
|
|
|
2008-04-01 15:21:34 +00:00
|
|
|
if (IS_ERR(tree_root)) {
|
2007-06-12 10:35:45 +00:00
|
|
|
printk("btrfs: open_ctree failed\n");
|
2008-04-01 15:21:34 +00:00
|
|
|
return PTR_ERR(tree_root);
|
2007-04-18 20:15:28 +00:00
|
|
|
}
|
2011-11-17 06:00:31 +00:00
|
|
|
fs_info = tree_root->fs_info;
|
2007-06-12 10:35:45 +00:00
|
|
|
sb->s_fs_info = tree_root;
|
2007-04-18 20:15:28 +00:00
|
|
|
|
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 14:45:14 +00:00
|
|
|
key.objectid = BTRFS_FIRST_FREE_OBJECTID;
|
|
|
|
|
key.type = BTRFS_INODE_ITEM_KEY;
|
|
|
|
|
key.offset = 0;
|
2011-11-17 06:00:31 +00:00
|
|
|
inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
|
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 14:45:14 +00:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
|
err = PTR_ERR(inode);
|
2007-06-12 10:35:45 +00:00
|
|
|
goto fail_close;
|
2007-03-29 19:15:27 +00:00
|
|
|
}
|
|
|
|
|
|
2007-06-12 10:35:45 +00:00
|
|
|
root_dentry = d_alloc_root(inode);
|
|
|
|
|
if (!root_dentry) {
|
|
|
|
|
iput(inode);
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
|
goto fail_close;
|
2007-03-29 19:15:27 +00:00
|
|
|
}
|
2007-08-29 19:47:34 +00:00
|
|
|
|
2007-06-12 10:35:45 +00:00
|
|
|
sb->s_root = root_dentry;
|
2008-02-20 21:11:05 +00:00
|
|
|
|
|
|
|
|
save_mount_options(sb, data);
|
2011-05-26 16:01:56 +00:00
|
|
|
cleancache_init_fs(sb);
|
2007-04-10 20:58:11 +00:00
|
|
|
return 0;
|
2007-06-12 10:35:45 +00:00
|
|
|
|
|
|
|
|
fail_close:
|
|
|
|
|
close_ctree(tree_root);
|
2011-11-17 06:00:31 +00:00
|
|
|
free_fs_info(fs_info);
|
2007-06-12 10:35:45 +00:00
|
|
|
return err;
|
2007-04-10 20:58:11 +00:00
|
|
|
}
|
|
|
|
|
|
2008-06-10 14:07:39 +00:00
|
|
|
int btrfs_sync_fs(struct super_block *sb, int wait)
|
2007-04-10 13:27:04 +00:00
|
|
|
{
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
2009-04-02 20:59:01 +00:00
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
2007-04-10 13:27:04 +00:00
|
|
|
int ret;
|
2007-04-10 20:58:11 +00:00
|
|
|
|
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 11:18:59 +00:00
|
|
|
trace_btrfs_sync_fs(wait);
|
|
|
|
|
|
2007-06-12 10:35:45 +00:00
|
|
|
if (!wait) {
|
|
|
|
|
filemap_flush(root->fs_info->btree_inode->i_mapping);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2008-11-07 03:02:51 +00:00
|
|
|
|
2009-11-12 09:36:34 +00:00
|
|
|
btrfs_start_delalloc_inodes(root, 0);
|
|
|
|
|
btrfs_wait_ordered_extents(root, 0, 0);
|
2008-11-07 03:02:51 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2011-01-20 06:19:37 +00:00
|
|
|
if (IS_ERR(trans))
|
|
|
|
|
return PTR_ERR(trans);
|
2007-04-10 13:27:04 +00:00
|
|
|
ret = btrfs_commit_transaction(trans, root);
|
2007-06-22 18:16:25 +00:00
|
|
|
return ret;
|
2007-04-02 14:50:19 +00:00
|
|
|
}
|
|
|
|
|
|
2011-12-09 02:32:45 +00:00
|
|
|
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
|
2009-04-02 20:46:06 +00:00
|
|
|
{
|
2011-12-09 02:32:45 +00:00
|
|
|
struct btrfs_root *root = btrfs_sb(dentry->d_sb);
|
2009-04-02 20:46:06 +00:00
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
2011-03-31 00:44:29 +00:00
|
|
|
char *compress_type;
|
2009-04-02 20:46:06 +00:00
|
|
|
|
|
|
|
|
if (btrfs_test_opt(root, DEGRADED))
|
|
|
|
|
seq_puts(seq, ",degraded");
|
|
|
|
|
if (btrfs_test_opt(root, NODATASUM))
|
|
|
|
|
seq_puts(seq, ",nodatasum");
|
|
|
|
|
if (btrfs_test_opt(root, NODATACOW))
|
|
|
|
|
seq_puts(seq, ",nodatacow");
|
|
|
|
|
if (btrfs_test_opt(root, NOBARRIER))
|
|
|
|
|
seq_puts(seq, ",nobarrier");
|
|
|
|
|
if (info->max_inline != 8192 * 1024)
|
2009-04-21 19:38:29 +00:00
|
|
|
seq_printf(seq, ",max_inline=%llu",
|
|
|
|
|
(unsigned long long)info->max_inline);
|
2009-04-02 20:46:06 +00:00
|
|
|
if (info->alloc_start != 0)
|
2009-04-21 19:38:29 +00:00
|
|
|
seq_printf(seq, ",alloc_start=%llu",
|
|
|
|
|
(unsigned long long)info->alloc_start);
|
2009-04-02 20:46:06 +00:00
|
|
|
if (info->thread_pool_size != min_t(unsigned long,
|
|
|
|
|
num_online_cpus() + 2, 8))
|
|
|
|
|
seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
|
2011-03-31 00:44:29 +00:00
|
|
|
if (btrfs_test_opt(root, COMPRESS)) {
|
|
|
|
|
if (info->compress_type == BTRFS_COMPRESS_ZLIB)
|
|
|
|
|
compress_type = "zlib";
|
|
|
|
|
else
|
|
|
|
|
compress_type = "lzo";
|
|
|
|
|
if (btrfs_test_opt(root, FORCE_COMPRESS))
|
|
|
|
|
seq_printf(seq, ",compress-force=%s", compress_type);
|
|
|
|
|
else
|
|
|
|
|
seq_printf(seq, ",compress=%s", compress_type);
|
|
|
|
|
}
|
2009-06-10 13:51:32 +00:00
|
|
|
if (btrfs_test_opt(root, NOSSD))
|
|
|
|
|
seq_puts(seq, ",nossd");
|
2009-06-10 00:28:34 +00:00
|
|
|
if (btrfs_test_opt(root, SSD_SPREAD))
|
|
|
|
|
seq_puts(seq, ",ssd_spread");
|
|
|
|
|
else if (btrfs_test_opt(root, SSD))
|
2009-04-02 20:46:06 +00:00
|
|
|
seq_puts(seq, ",ssd");
|
2009-04-02 20:49:40 +00:00
|
|
|
if (btrfs_test_opt(root, NOTREELOG))
|
2009-05-14 17:52:21 +00:00
|
|
|
seq_puts(seq, ",notreelog");
|
2009-04-02 20:59:01 +00:00
|
|
|
if (btrfs_test_opt(root, FLUSHONCOMMIT))
|
2009-05-14 17:52:21 +00:00
|
|
|
seq_puts(seq, ",flushoncommit");
|
2009-12-14 22:01:12 +00:00
|
|
|
if (btrfs_test_opt(root, DISCARD))
|
|
|
|
|
seq_puts(seq, ",discard");
|
2009-04-02 20:46:06 +00:00
|
|
|
if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
|
|
|
|
|
seq_puts(seq, ",noacl");
|
2011-03-31 00:44:29 +00:00
|
|
|
if (btrfs_test_opt(root, SPACE_CACHE))
|
|
|
|
|
seq_puts(seq, ",space_cache");
|
2011-10-03 18:07:49 +00:00
|
|
|
else
|
2011-11-11 15:14:57 +00:00
|
|
|
seq_puts(seq, ",nospace_cache");
|
2011-03-31 00:44:29 +00:00
|
|
|
if (btrfs_test_opt(root, CLEAR_CACHE))
|
|
|
|
|
seq_puts(seq, ",clear_cache");
|
|
|
|
|
if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
|
|
|
|
|
seq_puts(seq, ",user_subvol_rm_allowed");
|
2011-06-28 15:10:37 +00:00
|
|
|
if (btrfs_test_opt(root, ENOSPC_DEBUG))
|
|
|
|
|
seq_puts(seq, ",enospc_debug");
|
|
|
|
|
if (btrfs_test_opt(root, AUTO_DEFRAG))
|
|
|
|
|
seq_puts(seq, ",autodefrag");
|
|
|
|
|
if (btrfs_test_opt(root, INODE_MAP_CACHE))
|
|
|
|
|
seq_puts(seq, ",inode_cache");
|
2009-04-02 20:46:06 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-07 15:43:44 +00:00
|
|
|
static int btrfs_test_super(struct super_block *s, void *data)
|
2007-08-29 13:11:44 +00:00
|
|
|
{
|
2010-11-19 19:59:15 +00:00
|
|
|
struct btrfs_root *test_root = data;
|
2008-05-07 15:43:44 +00:00
|
|
|
struct btrfs_root *root = btrfs_sb(s);
|
2007-08-29 13:11:44 +00:00
|
|
|
|
2010-11-22 02:21:38 +00:00
|
|
|
/*
|
|
|
|
|
* If this super block is going away, return false as it
|
|
|
|
|
* can't match as an existing super block.
|
|
|
|
|
*/
|
|
|
|
|
if (!atomic_read(&s->s_active))
|
|
|
|
|
return 0;
|
2010-11-19 19:59:15 +00:00
|
|
|
return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
|
2007-08-29 13:11:44 +00:00
|
|
|
}
|
|
|
|
|
|
2010-11-19 19:59:15 +00:00
|
|
|
static int btrfs_set_super(struct super_block *s, void *data)
|
|
|
|
|
{
|
|
|
|
|
s->s_fs_info = data;
|
|
|
|
|
|
|
|
|
|
return set_anon_super(s, data);
|
2007-08-29 13:11:44 +00:00
|
|
|
}
|
|
|
|
|
|
2011-09-29 11:11:33 +00: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;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-25 19:55:42 +00:00
|
|
|
/*
|
|
|
|
|
* This will strip out the subvol=%s argument for an argument string and add
|
|
|
|
|
* subvolid=0 to make sure we get the actual tree root for path walking to the
|
|
|
|
|
* subvol we want.
|
|
|
|
|
*/
|
|
|
|
|
static char *setup_root_args(char *args)
|
|
|
|
|
{
|
|
|
|
|
unsigned copied = 0;
|
|
|
|
|
unsigned len = strlen(args) + 2;
|
|
|
|
|
char *pos;
|
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We need the same args as before, but minus
|
|
|
|
|
*
|
|
|
|
|
* subvol=a
|
|
|
|
|
*
|
|
|
|
|
* and add
|
|
|
|
|
*
|
|
|
|
|
* subvolid=0
|
|
|
|
|
*
|
|
|
|
|
* which is a difference of 2 characters, so we allocate strlen(args) +
|
|
|
|
|
* 2 characters.
|
|
|
|
|
*/
|
|
|
|
|
ret = kzalloc(len * sizeof(char), GFP_NOFS);
|
|
|
|
|
if (!ret)
|
|
|
|
|
return NULL;
|
|
|
|
|
pos = strstr(args, "subvol=");
|
|
|
|
|
|
|
|
|
|
/* This shouldn't happen, but just in case.. */
|
|
|
|
|
if (!pos) {
|
|
|
|
|
kfree(ret);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The subvol=<> arg is not at the front of the string, copy everybody
|
|
|
|
|
* up to that into ret.
|
|
|
|
|
*/
|
|
|
|
|
if (pos != args) {
|
|
|
|
|
*pos = '\0';
|
|
|
|
|
strcpy(ret, args);
|
|
|
|
|
copied += strlen(args);
|
|
|
|
|
pos++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
strncpy(ret + copied, "subvolid=0", len - copied);
|
|
|
|
|
|
|
|
|
|
/* Length of subvolid=0 */
|
|
|
|
|
copied += 10;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If there is no , after the subvol= option then we know there's no
|
|
|
|
|
* other options and we can just return.
|
|
|
|
|
*/
|
|
|
|
|
pos = strchr(pos, ',');
|
|
|
|
|
if (!pos)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
/* Copy the rest of the arguments into our buffer */
|
|
|
|
|
strncpy(ret + copied, pos, len - copied);
|
|
|
|
|
copied += strlen(pos);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct dentry *mount_subvol(const char *subvol_name, int flags,
|
|
|
|
|
const char *device_name, char *data)
|
|
|
|
|
{
|
|
|
|
|
struct dentry *root;
|
|
|
|
|
struct vfsmount *mnt;
|
|
|
|
|
char *newargs;
|
|
|
|
|
|
|
|
|
|
newargs = setup_root_args(data);
|
|
|
|
|
if (!newargs)
|
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name,
|
|
|
|
|
newargs);
|
|
|
|
|
kfree(newargs);
|
|
|
|
|
if (IS_ERR(mnt))
|
|
|
|
|
return ERR_CAST(mnt);
|
|
|
|
|
|
2011-11-17 02:43:59 +00:00
|
|
|
root = mount_subtree(mnt, subvol_name);
|
2011-07-25 19:55:42 +00:00
|
|
|
|
2011-11-17 02:43:59 +00:00
|
|
|
if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
|
|
|
|
|
struct super_block *s = root->d_sb;
|
|
|
|
|
dput(root);
|
|
|
|
|
root = ERR_PTR(-EINVAL);
|
|
|
|
|
deactivate_locked_super(s);
|
2011-09-29 11:11:33 +00:00
|
|
|
printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
|
|
|
|
|
subvol_name);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-25 19:55:42 +00:00
|
|
|
return root;
|
|
|
|
|
}
|
2010-11-19 19:59:15 +00:00
|
|
|
|
2008-06-10 14:40:29 +00:00
|
|
|
/*
|
|
|
|
|
* Find a superblock for the given device / mount point.
|
|
|
|
|
*
|
|
|
|
|
* Note: This is based on get_sb_bdev from fs/super.c with a few additions
|
|
|
|
|
* for multiple device setup. Make sure to keep it in sync.
|
|
|
|
|
*/
|
2010-07-26 12:21:33 +00:00
|
|
|
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
|
2011-04-19 12:29:38 +00:00
|
|
|
const char *device_name, void *data)
|
2007-08-29 13:11:44 +00:00
|
|
|
{
|
|
|
|
|
struct block_device *bdev = NULL;
|
|
|
|
|
struct super_block *s;
|
|
|
|
|
struct dentry *root;
|
2008-03-24 19:02:07 +00:00
|
|
|
struct btrfs_fs_devices *fs_devices = NULL;
|
2010-11-19 19:59:15 +00:00
|
|
|
struct btrfs_fs_info *fs_info = NULL;
|
2008-12-02 11:36:09 +00:00
|
|
|
fmode_t mode = FMODE_READ;
|
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-04 17:38:27 +00:00
|
|
|
char *subvol_name = NULL;
|
|
|
|
|
u64 subvol_objectid = 0;
|
2011-04-06 07:33:51 +00:00
|
|
|
u64 subvol_rootid = 0;
|
2007-08-29 13:11:44 +00:00
|
|
|
int error = 0;
|
|
|
|
|
|
2008-12-02 11:36:09 +00:00
|
|
|
if (!(flags & MS_RDONLY))
|
|
|
|
|
mode |= FMODE_WRITE;
|
|
|
|
|
|
|
|
|
|
error = btrfs_parse_early_options(data, mode, fs_type,
|
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-04 17:38:27 +00:00
|
|
|
&subvol_name, &subvol_objectid,
|
2011-04-06 07:33:51 +00:00
|
|
|
&subvol_rootid, &fs_devices);
|
2011-11-08 17:15:05 +00:00
|
|
|
if (error) {
|
|
|
|
|
kfree(subvol_name);
|
2010-07-26 12:21:33 +00:00
|
|
|
return ERR_PTR(error);
|
2011-11-08 17:15:05 +00:00
|
|
|
}
|
2008-06-10 14:40:29 +00:00
|
|
|
|
2011-07-25 19:55:42 +00:00
|
|
|
if (subvol_name) {
|
|
|
|
|
root = mount_subvol(subvol_name, flags, device_name, data);
|
|
|
|
|
kfree(subvol_name);
|
|
|
|
|
return root;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-19 12:29:38 +00:00
|
|
|
error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
|
2008-03-24 19:02:07 +00:00
|
|
|
if (error)
|
2011-07-25 19:55:42 +00:00
|
|
|
return ERR_PTR(error);
|
2007-08-29 13:11:44 +00:00
|
|
|
|
2010-11-19 19:59:15 +00:00
|
|
|
/*
|
|
|
|
|
* 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
|
|
|
|
|
* it for searching for existing supers, so this lets us do that and
|
|
|
|
|
* then open_ctree will properly initialize everything later.
|
|
|
|
|
*/
|
|
|
|
|
fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
|
2011-11-09 12:41:22 +00:00
|
|
|
if (!fs_info)
|
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
|
|
fs_info->tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
|
|
|
|
|
if (!fs_info->tree_root) {
|
2010-11-19 19:59:15 +00:00
|
|
|
error = -ENOMEM;
|
2011-11-09 12:41:22 +00:00
|
|
|
goto error_fs_info;
|
2010-11-19 19:59:15 +00:00
|
|
|
}
|
2011-11-09 12:41:22 +00:00
|
|
|
fs_info->tree_root->fs_info = fs_info;
|
2010-11-19 19:59:15 +00:00
|
|
|
fs_info->fs_devices = fs_devices;
|
|
|
|
|
|
2011-04-13 13:41:04 +00:00
|
|
|
fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
|
|
|
|
|
fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
|
|
|
|
|
if (!fs_info->super_copy || !fs_info->super_for_commit) {
|
|
|
|
|
error = -ENOMEM;
|
2011-11-09 12:41:22 +00:00
|
|
|
goto error_fs_info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
error = btrfs_open_devices(fs_devices, mode, fs_type);
|
|
|
|
|
if (error)
|
|
|
|
|
goto error_fs_info;
|
|
|
|
|
|
|
|
|
|
if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
|
|
|
|
|
error = -EACCES;
|
2011-04-13 13:41:04 +00:00
|
|
|
goto error_close_devices;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
bdev = fs_devices->latest_bdev;
|
2011-11-09 12:41:22 +00:00
|
|
|
s = sget(fs_type, btrfs_test_super, btrfs_set_super,
|
|
|
|
|
fs_info->tree_root);
|
2011-07-25 19:55:42 +00:00
|
|
|
if (IS_ERR(s)) {
|
|
|
|
|
error = PTR_ERR(s);
|
|
|
|
|
goto error_close_devices;
|
|
|
|
|
}
|
2007-08-29 13:11:44 +00:00
|
|
|
|
|
|
|
|
if (s->s_root) {
|
|
|
|
|
if ((flags ^ s->s_flags) & MS_RDONLY) {
|
2009-05-06 05:34:22 +00:00
|
|
|
deactivate_locked_super(s);
|
2011-11-09 12:41:22 +00:00
|
|
|
error = -EBUSY;
|
|
|
|
|
goto error_close_devices;
|
2007-08-29 13:11:44 +00:00
|
|
|
}
|
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
btrfs_close_devices(fs_devices);
|
2011-04-13 13:41:04 +00:00
|
|
|
free_fs_info(fs_info);
|
2007-08-29 13:11:44 +00:00
|
|
|
} else {
|
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
|
|
2011-06-03 22:24:58 +00:00
|
|
|
s->s_flags = flags | MS_NOSEC;
|
2007-08-29 13:11:44 +00:00
|
|
|
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
|
2011-10-12 21:20:43 +00:00
|
|
|
btrfs_sb(s)->fs_info->bdev_holder = fs_type;
|
2008-03-24 19:02:07 +00:00
|
|
|
error = btrfs_fill_super(s, fs_devices, data,
|
|
|
|
|
flags & MS_SILENT ? 1 : 0);
|
2007-08-29 13:11:44 +00:00
|
|
|
if (error) {
|
2009-05-06 05:34:22 +00:00
|
|
|
deactivate_locked_super(s);
|
2011-07-25 19:55:42 +00:00
|
|
|
return ERR_PTR(error);
|
2007-08-29 13:11:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
s->s_flags |= MS_ACTIVE;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-25 19:55:42 +00:00
|
|
|
root = get_default_root(s, subvol_objectid);
|
|
|
|
|
if (IS_ERR(root)) {
|
|
|
|
|
deactivate_locked_super(s);
|
|
|
|
|
return root;
|
2007-08-29 13:11:44 +00:00
|
|
|
}
|
|
|
|
|
|
2010-07-26 12:21:33 +00:00
|
|
|
return root;
|
2007-08-29 13:11:44 +00:00
|
|
|
|
2008-11-12 19:34:12 +00:00
|
|
|
error_close_devices:
|
2008-03-24 19:02:07 +00:00
|
|
|
btrfs_close_devices(fs_devices);
|
2011-11-09 12:41:22 +00:00
|
|
|
error_fs_info:
|
2011-04-13 13:41:04 +00:00
|
|
|
free_fs_info(fs_info);
|
2010-07-26 12:21:33 +00:00
|
|
|
return ERR_PTR(error);
|
2007-08-29 13:11:44 +00:00
|
|
|
}
|
2007-03-21 15:12:56 +00:00
|
|
|
|
2008-11-12 19:34:12 +00:00
|
|
|
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
|
|
|
|
int ret;
|
|
|
|
|
|
2009-02-12 14:37:35 +00:00
|
|
|
ret = btrfs_parse_options(root, data);
|
|
|
|
|
if (ret)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2008-11-12 19:34:12 +00:00
|
|
|
if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (*flags & MS_RDONLY) {
|
|
|
|
|
sb->s_flags |= MS_RDONLY;
|
|
|
|
|
|
|
|
|
|
ret = btrfs_commit_super(root);
|
|
|
|
|
WARN_ON(ret);
|
|
|
|
|
} else {
|
2008-11-18 02:11:30 +00:00
|
|
|
if (root->fs_info->fs_devices->rw_devices == 0)
|
|
|
|
|
return -EACCES;
|
|
|
|
|
|
2011-04-13 13:41:04 +00:00
|
|
|
if (btrfs_super_log_root(root->fs_info->super_copy) != 0)
|
2008-11-12 19:34:12 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2010-05-16 14:49:58 +00:00
|
|
|
ret = btrfs_cleanup_fs_roots(root->fs_info);
|
2008-11-12 19:34:12 +00:00
|
|
|
WARN_ON(ret);
|
|
|
|
|
|
2010-05-16 14:49:58 +00:00
|
|
|
/* recover relocation */
|
|
|
|
|
ret = btrfs_recover_relocation(root);
|
2008-11-12 19:34:12 +00:00
|
|
|
WARN_ON(ret);
|
|
|
|
|
|
|
|
|
|
sb->s_flags &= ~MS_RDONLY;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-12 08:43:21 +00:00
|
|
|
/* Used to sort the devices by max_avail(descending sort) */
|
|
|
|
|
static int btrfs_cmp_device_free_bytes(const void *dev_info1,
|
|
|
|
|
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 10:07:31 +00:00
|
|
|
/*
|
|
|
|
|
* The helper to calc the free space on the devices that can be used to store
|
|
|
|
|
* file data.
|
|
|
|
|
*/
|
|
|
|
|
static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
|
struct btrfs_device_info *devices_info;
|
|
|
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
|
|
|
struct btrfs_device *device;
|
|
|
|
|
u64 skip_space;
|
|
|
|
|
u64 type;
|
|
|
|
|
u64 avail_space;
|
|
|
|
|
u64 used_space;
|
|
|
|
|
u64 min_stripe_size;
|
2011-12-15 01:12:02 +00:00
|
|
|
int min_stripes = 1, 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 10:07:31 +00:00
|
|
|
int i = 0, nr_devices;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2011-11-28 08:43:00 +00:00
|
|
|
nr_devices = fs_info->fs_devices->open_devices;
|
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 10:07:31 +00:00
|
|
|
BUG_ON(!nr_devices);
|
|
|
|
|
|
|
|
|
|
devices_info = kmalloc(sizeof(*devices_info) * nr_devices,
|
|
|
|
|
GFP_NOFS);
|
|
|
|
|
if (!devices_info)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
/* calc min stripe number for data space alloction */
|
|
|
|
|
type = btrfs_get_alloc_profile(root, 1);
|
2011-12-15 01:12:02 +00:00
|
|
|
if (type & BTRFS_BLOCK_GROUP_RAID0) {
|
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 10:07:31 +00:00
|
|
|
min_stripes = 2;
|
2011-12-15 01:12:02 +00:00
|
|
|
num_stripes = nr_devices;
|
|
|
|
|
} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
|
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 10:07:31 +00:00
|
|
|
min_stripes = 2;
|
2011-12-15 01:12:02 +00:00
|
|
|
num_stripes = 2;
|
|
|
|
|
} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
|
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 10:07:31 +00:00
|
|
|
min_stripes = 4;
|
2011-12-15 01:12:02 +00: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 10:07:31 +00:00
|
|
|
|
|
|
|
|
if (type & BTRFS_BLOCK_GROUP_DUP)
|
|
|
|
|
min_stripe_size = 2 * BTRFS_STRIPE_LEN;
|
|
|
|
|
else
|
|
|
|
|
min_stripe_size = BTRFS_STRIPE_LEN;
|
|
|
|
|
|
2011-11-28 08:43:00 +00:00
|
|
|
list_for_each_entry(device, &fs_devices->devices, dev_list) {
|
|
|
|
|
if (!device->in_fs_metadata || !device->bdev)
|
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 10:07:31 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
avail_space = device->total_bytes - device->bytes_used;
|
|
|
|
|
|
|
|
|
|
/* align with stripe_len */
|
|
|
|
|
do_div(avail_space, BTRFS_STRIPE_LEN);
|
|
|
|
|
avail_space *= BTRFS_STRIPE_LEN;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* In order to avoid overwritting the superblock on the drive,
|
|
|
|
|
* btrfs starts at an offset of at least 1MB when doing chunk
|
|
|
|
|
* allocation.
|
|
|
|
|
*/
|
|
|
|
|
skip_space = 1024 * 1024;
|
|
|
|
|
|
|
|
|
|
/* user can set the offset in fs_info->alloc_start. */
|
|
|
|
|
if (fs_info->alloc_start + BTRFS_STRIPE_LEN <=
|
|
|
|
|
device->total_bytes)
|
|
|
|
|
skip_space = max(fs_info->alloc_start, skip_space);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* btrfs can not use the free space in [0, skip_space - 1],
|
|
|
|
|
* we must subtract it from the total. In order to implement
|
|
|
|
|
* it, we account the used space in this range first.
|
|
|
|
|
*/
|
|
|
|
|
ret = btrfs_account_dev_extents_size(device, 0, skip_space - 1,
|
|
|
|
|
&used_space);
|
|
|
|
|
if (ret) {
|
|
|
|
|
kfree(devices_info);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* calc the free space in [0, skip_space - 1] */
|
|
|
|
|
skip_space -= used_space;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* we can use the free space in [0, skip_space - 1], subtract
|
|
|
|
|
* it from the total.
|
|
|
|
|
*/
|
|
|
|
|
if (avail_space && avail_space >= skip_space)
|
|
|
|
|
avail_space -= skip_space;
|
|
|
|
|
else
|
|
|
|
|
avail_space = 0;
|
|
|
|
|
|
|
|
|
|
if (avail_space < min_stripe_size)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
devices_info[i].dev = device;
|
|
|
|
|
devices_info[i].max_avail = avail_space;
|
|
|
|
|
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nr_devices = i;
|
|
|
|
|
|
|
|
|
|
btrfs_descending_sort_devices(devices_info, nr_devices);
|
|
|
|
|
|
|
|
|
|
i = nr_devices - 1;
|
|
|
|
|
avail_space = 0;
|
|
|
|
|
while (nr_devices >= min_stripes) {
|
2011-12-15 01:12:02 +00:00
|
|
|
if (num_stripes > nr_devices)
|
|
|
|
|
num_stripes = nr_devices;
|
|
|
|
|
|
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 10:07:31 +00:00
|
|
|
if (devices_info[i].max_avail >= min_stripe_size) {
|
|
|
|
|
int j;
|
|
|
|
|
u64 alloc_size;
|
|
|
|
|
|
2011-12-15 01:12:02 +00: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 10:07:31 +00:00
|
|
|
alloc_size = devices_info[i].max_avail;
|
2011-12-15 01:12:02 +00: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 10:07:31 +00:00
|
|
|
devices_info[j].max_avail -= alloc_size;
|
|
|
|
|
}
|
|
|
|
|
i--;
|
|
|
|
|
nr_devices--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
kfree(devices_info);
|
|
|
|
|
*free_bytes = avail_space;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-20 01:01:03 +00:00
|
|
|
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = btrfs_sb(dentry->d_sb);
|
2011-04-13 13:41:04 +00:00
|
|
|
struct btrfs_super_block *disk_super = root->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-05 21:59:21 +00:00
|
|
|
struct list_head *head = &root->fs_info->space_info;
|
|
|
|
|
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 10:07:31 +00:00
|
|
|
u64 total_free_data = 0;
|
2007-10-15 20:15:53 +00:00
|
|
|
int bits = dentry->d_sb->s_blocksize_bits;
|
2008-08-18 11:01:52 +00:00
|
|
|
__be32 *fsid = (__be32 *)root->fs_info->fsid;
|
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 10:07:31 +00:00
|
|
|
int ret;
|
2007-04-20 01:01:03 +00: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 10:07:31 +00:00
|
|
|
/* holding chunk_muext to avoid allocating new chunks */
|
|
|
|
|
mutex_lock(&root->fs_info->chunk_mutex);
|
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-05 21:59:21 +00:00
|
|
|
rcu_read_lock();
|
2010-10-14 18:52:27 +00:00
|
|
|
list_for_each_entry_rcu(found, head, 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 10:07:31 +00:00
|
|
|
if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
|
|
|
|
|
total_free_data += found->disk_total - found->disk_used;
|
|
|
|
|
total_free_data -=
|
|
|
|
|
btrfs_account_ro_block_groups_free_space(found);
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-16 14:46:24 +00:00
|
|
|
total_used += found->disk_used;
|
2010-10-14 18:52:27 +00: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-05 21:59:21 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
2007-04-20 01:01:03 +00:00
|
|
|
buf->f_namelen = BTRFS_NAME_LEN;
|
2007-10-15 20:15:53 +00:00
|
|
|
buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
|
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-05 21:59:21 +00:00
|
|
|
buf->f_bfree = buf->f_blocks - (total_used >> bits);
|
2007-04-20 01:01:03 +00:00
|
|
|
buf->f_bsize = dentry->d_sb->s_blocksize;
|
|
|
|
|
buf->f_type = BTRFS_SUPER_MAGIC;
|
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 10:07:31 +00:00
|
|
|
buf->f_bavail = total_free_data;
|
|
|
|
|
ret = btrfs_calc_avail_data_space(root, &total_free_data);
|
|
|
|
|
if (ret) {
|
|
|
|
|
mutex_unlock(&root->fs_info->chunk_mutex);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
buf->f_bavail += total_free_data;
|
|
|
|
|
buf->f_bavail = buf->f_bavail >> bits;
|
|
|
|
|
mutex_unlock(&root->fs_info->chunk_mutex);
|
2009-01-06 02:25:51 +00:00
|
|
|
|
2008-08-18 11:01:52 +00:00
|
|
|
/* We treat it as constant endianness (it doesn't matter _which_)
|
2009-01-06 02:25:51 +00:00
|
|
|
because we want the fsid to come out the same whether mounted
|
2008-08-18 11:01:52 +00: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 12:10:20 +00:00
|
|
|
/* Mask in the root object ID too, to disambiguate subvols */
|
|
|
|
|
buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
|
|
|
|
|
buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
|
|
|
|
|
|
2007-04-20 01:01:03 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2007-04-24 15:52:22 +00:00
|
|
|
|
2007-03-21 15:12:56 +00:00
|
|
|
static struct file_system_type btrfs_fs_type = {
|
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
|
.name = "btrfs",
|
2010-07-26 12:21:33 +00:00
|
|
|
.mount = btrfs_mount,
|
2008-05-07 15:43:44 +00:00
|
|
|
.kill_sb = kill_anon_super,
|
2007-03-21 15:12:56 +00:00
|
|
|
.fs_flags = FS_REQUIRES_DEV,
|
|
|
|
|
};
|
2008-03-24 19:02:04 +00:00
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
|
* used by btrfsctl to scan devices when no FS is mounted
|
|
|
|
|
*/
|
2008-03-24 19:02:07 +00:00
|
|
|
static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
|
|
|
|
|
unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_vol_args *vol;
|
|
|
|
|
struct btrfs_fs_devices *fs_devices;
|
2009-01-16 16:59:08 +00:00
|
|
|
int ret = -ENOTTY;
|
2008-03-24 19:02:07 +00:00
|
|
|
|
2009-01-05 21:57:23 +00:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2009-04-08 07:06:54 +00:00
|
|
|
vol = memdup_user((void __user *)arg, sizeof(*vol));
|
|
|
|
|
if (IS_ERR(vol))
|
|
|
|
|
return PTR_ERR(vol);
|
2009-01-16 16:59:08 +00:00
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
switch (cmd) {
|
|
|
|
|
case BTRFS_IOC_SCAN_DEV:
|
2008-12-02 11:36:09 +00:00
|
|
|
ret = btrfs_scan_one_device(vol->name, FMODE_READ,
|
2008-03-24 19:02:07 +00:00
|
|
|
&btrfs_fs_type, &fs_devices);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-04-08 07:06:54 +00:00
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
kfree(vol);
|
2008-06-10 02:17:11 +00:00
|
|
|
return ret;
|
2008-03-24 19:02:07 +00:00
|
|
|
}
|
|
|
|
|
|
2009-01-10 14:09:52 +00:00
|
|
|
static int btrfs_freeze(struct super_block *sb)
|
2008-01-22 17:46:56 +00:00
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
2008-06-25 20:01:31 +00:00
|
|
|
mutex_lock(&root->fs_info->transaction_kthread_mutex);
|
|
|
|
|
mutex_lock(&root->fs_info->cleaner_mutex);
|
2009-01-10 14:09:52 +00:00
|
|
|
return 0;
|
2008-01-22 17:46:56 +00:00
|
|
|
}
|
|
|
|
|
|
2009-01-10 14:09:52 +00:00
|
|
|
static int btrfs_unfreeze(struct super_block *sb)
|
2008-01-22 17:46:56 +00:00
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
2008-06-25 20:01:31 +00:00
|
|
|
mutex_unlock(&root->fs_info->cleaner_mutex);
|
|
|
|
|
mutex_unlock(&root->fs_info->transaction_kthread_mutex);
|
2009-01-10 14:09:52 +00:00
|
|
|
return 0;
|
2008-01-22 17:46:56 +00:00
|
|
|
}
|
2007-03-21 15:12:56 +00:00
|
|
|
|
2011-11-30 15:45:38 +00:00
|
|
|
static void btrfs_fs_dirty_inode(struct inode *inode, int flags)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
ret = btrfs_dirty_inode(inode);
|
|
|
|
|
if (ret)
|
|
|
|
|
printk_ratelimited(KERN_ERR "btrfs: fail to dirty inode %Lu "
|
|
|
|
|
"error %d\n", btrfs_ino(inode), ret);
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-22 00:01:09 +00:00
|
|
|
static const struct super_operations btrfs_super_ops = {
|
2009-09-21 20:00:26 +00:00
|
|
|
.drop_inode = btrfs_drop_inode,
|
2010-06-07 15:35:40 +00:00
|
|
|
.evict_inode = btrfs_evict_inode,
|
2007-03-22 16:13:20 +00:00
|
|
|
.put_super = btrfs_put_super,
|
2007-03-23 14:01:08 +00:00
|
|
|
.sync_fs = btrfs_sync_fs,
|
2009-04-02 20:46:06 +00:00
|
|
|
.show_options = btrfs_show_options,
|
2007-03-26 16:00:39 +00:00
|
|
|
.write_inode = btrfs_write_inode,
|
2011-11-30 15:45:38 +00:00
|
|
|
.dirty_inode = btrfs_fs_dirty_inode,
|
2007-04-02 14:50:19 +00:00
|
|
|
.alloc_inode = btrfs_alloc_inode,
|
|
|
|
|
.destroy_inode = btrfs_destroy_inode,
|
2007-04-20 01:01:03 +00:00
|
|
|
.statfs = btrfs_statfs,
|
2008-11-12 19:34:12 +00:00
|
|
|
.remount_fs = btrfs_remount,
|
2009-01-10 14:09:52 +00:00
|
|
|
.freeze_fs = btrfs_freeze,
|
|
|
|
|
.unfreeze_fs = btrfs_unfreeze,
|
2007-03-22 16:13:20 +00:00
|
|
|
};
|
2008-03-24 19:02:04 +00:00
|
|
|
|
|
|
|
|
static const struct file_operations btrfs_ctl_fops = {
|
|
|
|
|
.unlocked_ioctl = btrfs_control_ioctl,
|
|
|
|
|
.compat_ioctl = btrfs_control_ioctl,
|
|
|
|
|
.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-15 16:52:59 +00:00
|
|
|
.llseek = noop_llseek,
|
2008-03-24 19:02:04 +00: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-20 16:07:20 +00:00
|
|
|
.minor = BTRFS_MINOR,
|
2008-03-24 19:02:04 +00: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-20 16:07:20 +00:00
|
|
|
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
|
|
|
|
|
MODULE_ALIAS("devname:btrfs-control");
|
|
|
|
|
|
2008-03-24 19:02:04 +00:00
|
|
|
static int btrfs_interface_init(void)
|
|
|
|
|
{
|
|
|
|
|
return misc_register(&btrfs_misc);
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-02 14:54:17 +00:00
|
|
|
static void btrfs_interface_exit(void)
|
2008-03-24 19:02:04 +00:00
|
|
|
{
|
|
|
|
|
if (misc_deregister(&btrfs_misc) < 0)
|
2009-01-06 02:25:51 +00:00
|
|
|
printk(KERN_INFO "misc_deregister failed for control device");
|
2008-03-24 19:02:04 +00:00
|
|
|
}
|
|
|
|
|
|
2007-03-21 15:12:56 +00:00
|
|
|
static int __init init_btrfs_fs(void)
|
|
|
|
|
{
|
2007-04-02 14:50:19 +00:00
|
|
|
int err;
|
2007-08-29 19:47:34 +00:00
|
|
|
|
|
|
|
|
err = btrfs_init_sysfs();
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2010-12-17 06:21:50 +00:00
|
|
|
err = btrfs_init_compress();
|
2007-04-02 14:50:19 +00:00
|
|
|
if (err)
|
2008-06-25 20:01:31 +00:00
|
|
|
goto free_sysfs;
|
2008-01-24 21:13:08 +00:00
|
|
|
|
2010-12-17 06:21:50 +00:00
|
|
|
err = btrfs_init_cachep();
|
|
|
|
|
if (err)
|
|
|
|
|
goto free_compress;
|
|
|
|
|
|
2008-01-24 21:13:08 +00:00
|
|
|
err = extent_io_init();
|
2007-11-19 15:22:33 +00:00
|
|
|
if (err)
|
|
|
|
|
goto free_cachep;
|
|
|
|
|
|
2008-01-24 21:13:08 +00:00
|
|
|
err = extent_map_init();
|
|
|
|
|
if (err)
|
|
|
|
|
goto free_extent_io;
|
|
|
|
|
|
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 10:12:22 +00:00
|
|
|
err = btrfs_delayed_inode_init();
|
2007-11-19 15:22:33 +00: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-29 18:49:59 +00:00
|
|
|
|
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 10:12:22 +00:00
|
|
|
err = btrfs_interface_init();
|
|
|
|
|
if (err)
|
|
|
|
|
goto free_delayed_inode;
|
|
|
|
|
|
2008-03-24 19:02:04 +00:00
|
|
|
err = register_filesystem(&btrfs_fs_type);
|
|
|
|
|
if (err)
|
|
|
|
|
goto unregister_ioctl;
|
2008-07-23 16:12:13 +00:00
|
|
|
|
|
|
|
|
printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
|
2007-11-19 15:22:33 +00:00
|
|
|
return 0;
|
|
|
|
|
|
2008-03-24 19:02:04 +00:00
|
|
|
unregister_ioctl:
|
|
|
|
|
btrfs_interface_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 10:12:22 +00:00
|
|
|
free_delayed_inode:
|
|
|
|
|
btrfs_delayed_inode_exit();
|
2007-11-19 15:22:33 +00:00
|
|
|
free_extent_map:
|
|
|
|
|
extent_map_exit();
|
2008-01-24 21:13:08 +00:00
|
|
|
free_extent_io:
|
|
|
|
|
extent_io_exit();
|
2007-11-19 15:22:33 +00:00
|
|
|
free_cachep:
|
|
|
|
|
btrfs_destroy_cachep();
|
2010-12-17 06:21:50 +00:00
|
|
|
free_compress:
|
|
|
|
|
btrfs_exit_compress();
|
2008-06-25 20:01:31 +00:00
|
|
|
free_sysfs:
|
2007-11-19 15:22:33 +00:00
|
|
|
btrfs_exit_sysfs();
|
|
|
|
|
return err;
|
2007-03-21 15:12:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit exit_btrfs_fs(void)
|
|
|
|
|
{
|
2007-06-12 10:35:45 +00:00
|
|
|
btrfs_destroy_cachep();
|
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 10:12:22 +00:00
|
|
|
btrfs_delayed_inode_exit();
|
2007-08-27 20:49:44 +00:00
|
|
|
extent_map_exit();
|
2008-01-24 21:13:08 +00:00
|
|
|
extent_io_exit();
|
2008-03-24 19:02:04 +00:00
|
|
|
btrfs_interface_exit();
|
2007-03-21 15:12:56 +00:00
|
|
|
unregister_filesystem(&btrfs_fs_type);
|
2007-08-29 19:47:34 +00:00
|
|
|
btrfs_exit_sysfs();
|
2008-03-24 19:02:07 +00:00
|
|
|
btrfs_cleanup_fs_uuids();
|
2010-12-17 06:21:50 +00:00
|
|
|
btrfs_exit_compress();
|
2007-03-21 15:12:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(init_btrfs_fs)
|
|
|
|
|
module_exit(exit_btrfs_fs)
|
|
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
