2008-06-12 05:53:53 +04: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.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/bio.h>
|
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
|
#include <linux/file.h>
|
|
|
|
|
#include <linux/fs.h>
|
2008-10-09 21:39:39 +04:00
|
|
|
#include <linux/fsnotify.h>
|
2008-06-12 05:53:53 +04:00
|
|
|
#include <linux/pagemap.h>
|
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
|
#include <linux/time.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/backing-dev.h>
|
2008-10-09 21:39:39 +04:00
|
|
|
#include <linux/mount.h>
|
2008-06-12 05:53:53 +04:00
|
|
|
#include <linux/mpage.h>
|
2008-10-09 21:39:39 +04:00
|
|
|
#include <linux/namei.h>
|
2008-06-12 05:53:53 +04:00
|
|
|
#include <linux/swap.h>
|
|
|
|
|
#include <linux/writeback.h>
|
|
|
|
|
#include <linux/statfs.h>
|
|
|
|
|
#include <linux/compat.h>
|
|
|
|
|
#include <linux/bit_spinlock.h>
|
2008-10-09 21:39:39 +04:00
|
|
|
#include <linux/security.h>
|
2008-06-12 05:53:53 +04:00
|
|
|
#include <linux/xattr.h>
|
2008-08-05 21:05:02 +04:00
|
|
|
#include <linux/vmalloc.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 11:04:11 +03:00
|
|
|
#include <linux/slab.h>
|
2011-03-24 13:24:28 +03:00
|
|
|
#include <linux/blkdev.h>
|
2012-07-25 19:35:53 +04:00
|
|
|
#include <linux/uuid.h>
|
2013-01-29 10:04:50 +04:00
|
|
|
#include <linux/btrfs.h>
|
2013-08-06 22:42:51 +04:00
|
|
|
#include <linux/uaccess.h>
|
2008-06-12 05:53:53 +04:00
|
|
|
#include "ctree.h"
|
|
|
|
|
#include "disk-io.h"
|
|
|
|
|
#include "transaction.h"
|
|
|
|
|
#include "btrfs_inode.h"
|
|
|
|
|
#include "print-tree.h"
|
|
|
|
|
#include "volumes.h"
|
2008-06-26 00:01:30 +04:00
|
|
|
#include "locking.h"
|
Btrfs: Cache free inode numbers in memory
Currently btrfs stores the highest objectid of the fs tree, and it always
returns (highest+1) inode number when we create a file, so inode numbers
won't be reclaimed when we delete files, so we'll run out of inode numbers
as we keep create/delete files in 32bits machines.
This fixes it, and it works similarly to how we cache free space in block
cgroups.
We start a kernel thread to read the file tree. By scanning inode items,
we know which chunks of inode numbers are free, and we cache them in
an rb-tree.
Because we are searching the commit root, we have to carefully handle the
cross-transaction case.
The rb-tree is a hybrid extent+bitmap tree, so if we have too many small
chunks of inode numbers, we'll use bitmaps. Initially we allow 16K ram
of extents, and a bitmap will be used if we exceed this threshold. The
extents threshold is adjusted in runtime.
Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
2011-04-20 06:06:11 +04:00
|
|
|
#include "inode-map.h"
|
2011-07-07 18:48:38 +04:00
|
|
|
#include "backref.h"
|
2012-06-04 22:03:51 +04:00
|
|
|
#include "rcu-string.h"
|
2012-07-26 01:19:24 +04:00
|
|
|
#include "send.h"
|
2012-11-06 18:08:53 +04:00
|
|
|
#include "dev-replace.h"
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 15:47:46 +04:00
|
|
|
#include "props.h"
|
2013-11-01 21:07:02 +04:00
|
|
|
#include "sysfs.h"
|
2014-05-14 04:30:47 +04:00
|
|
|
#include "qgroup.h"
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2014-01-31 00:17:00 +04:00
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
|
/* If we have a 32-bit userspace and 64-bit kernel, then the UAPI
|
|
|
|
|
* structures are incorrect, as the timespec structure from userspace
|
|
|
|
|
* is 4 bytes too small. We define these alternatives here to teach
|
|
|
|
|
* the kernel about the 32-bit struct packing.
|
|
|
|
|
*/
|
|
|
|
|
struct btrfs_ioctl_timespec_32 {
|
|
|
|
|
__u64 sec;
|
|
|
|
|
__u32 nsec;
|
|
|
|
|
} __attribute__ ((__packed__));
|
|
|
|
|
|
|
|
|
|
struct btrfs_ioctl_received_subvol_args_32 {
|
|
|
|
|
char uuid[BTRFS_UUID_SIZE]; /* in */
|
|
|
|
|
__u64 stransid; /* in */
|
|
|
|
|
__u64 rtransid; /* out */
|
|
|
|
|
struct btrfs_ioctl_timespec_32 stime; /* in */
|
|
|
|
|
struct btrfs_ioctl_timespec_32 rtime; /* out */
|
|
|
|
|
__u64 flags; /* in */
|
|
|
|
|
__u64 reserved[16]; /* in */
|
|
|
|
|
} __attribute__ ((__packed__));
|
|
|
|
|
|
|
|
|
|
#define BTRFS_IOC_SET_RECEIVED_SUBVOL_32 _IOWR(BTRFS_IOCTL_MAGIC, 37, \
|
|
|
|
|
struct btrfs_ioctl_received_subvol_args_32)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
2013-08-06 22:42:51 +04:00
|
|
|
static int btrfs_clone(struct inode *src, struct inode *inode,
|
|
|
|
|
u64 off, u64 olen, u64 olen_aligned, u64 destoff);
|
|
|
|
|
|
2009-04-17 12:37:41 +04:00
|
|
|
/* Mask out flags that are inappropriate for the given type of inode. */
|
|
|
|
|
static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags)
|
|
|
|
|
{
|
|
|
|
|
if (S_ISDIR(mode))
|
|
|
|
|
return flags;
|
|
|
|
|
else if (S_ISREG(mode))
|
|
|
|
|
return flags & ~FS_DIRSYNC_FL;
|
|
|
|
|
else
|
|
|
|
|
return flags & (FS_NODUMP_FL | FS_NOATIME_FL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Export inode flags to the format expected by the FS_IOC_GETFLAGS ioctl.
|
|
|
|
|
*/
|
|
|
|
|
static unsigned int btrfs_flags_to_ioctl(unsigned int flags)
|
|
|
|
|
{
|
|
|
|
|
unsigned int iflags = 0;
|
|
|
|
|
|
|
|
|
|
if (flags & BTRFS_INODE_SYNC)
|
|
|
|
|
iflags |= FS_SYNC_FL;
|
|
|
|
|
if (flags & BTRFS_INODE_IMMUTABLE)
|
|
|
|
|
iflags |= FS_IMMUTABLE_FL;
|
|
|
|
|
if (flags & BTRFS_INODE_APPEND)
|
|
|
|
|
iflags |= FS_APPEND_FL;
|
|
|
|
|
if (flags & BTRFS_INODE_NODUMP)
|
|
|
|
|
iflags |= FS_NODUMP_FL;
|
|
|
|
|
if (flags & BTRFS_INODE_NOATIME)
|
|
|
|
|
iflags |= FS_NOATIME_FL;
|
|
|
|
|
if (flags & BTRFS_INODE_DIRSYNC)
|
|
|
|
|
iflags |= FS_DIRSYNC_FL;
|
2011-04-15 07:03:06 +04:00
|
|
|
if (flags & BTRFS_INODE_NODATACOW)
|
|
|
|
|
iflags |= FS_NOCOW_FL;
|
|
|
|
|
|
|
|
|
|
if ((flags & BTRFS_INODE_COMPRESS) && !(flags & BTRFS_INODE_NOCOMPRESS))
|
|
|
|
|
iflags |= FS_COMPR_FL;
|
|
|
|
|
else if (flags & BTRFS_INODE_NOCOMPRESS)
|
|
|
|
|
iflags |= FS_NOCOMP_FL;
|
2009-04-17 12:37:41 +04:00
|
|
|
|
|
|
|
|
return iflags;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Update inode->i_flags based on the btrfs internal flags.
|
|
|
|
|
*/
|
|
|
|
|
void btrfs_update_iflags(struct inode *inode)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_inode *ip = BTRFS_I(inode);
|
2014-06-26 01:36:02 +04:00
|
|
|
unsigned int new_fl = 0;
|
2009-04-17 12:37:41 +04:00
|
|
|
|
|
|
|
|
if (ip->flags & BTRFS_INODE_SYNC)
|
2014-06-26 01:36:02 +04:00
|
|
|
new_fl |= S_SYNC;
|
2009-04-17 12:37:41 +04:00
|
|
|
if (ip->flags & BTRFS_INODE_IMMUTABLE)
|
2014-06-26 01:36:02 +04:00
|
|
|
new_fl |= S_IMMUTABLE;
|
2009-04-17 12:37:41 +04:00
|
|
|
if (ip->flags & BTRFS_INODE_APPEND)
|
2014-06-26 01:36:02 +04:00
|
|
|
new_fl |= S_APPEND;
|
2009-04-17 12:37:41 +04:00
|
|
|
if (ip->flags & BTRFS_INODE_NOATIME)
|
2014-06-26 01:36:02 +04:00
|
|
|
new_fl |= S_NOATIME;
|
2009-04-17 12:37:41 +04:00
|
|
|
if (ip->flags & BTRFS_INODE_DIRSYNC)
|
2014-06-26 01:36:02 +04:00
|
|
|
new_fl |= S_DIRSYNC;
|
|
|
|
|
|
|
|
|
|
set_mask_bits(&inode->i_flags,
|
|
|
|
|
S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME | S_DIRSYNC,
|
|
|
|
|
new_fl);
|
2009-04-17 12:37:41 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Inherit flags from the parent inode.
|
|
|
|
|
*
|
2011-09-27 19:01:30 +04:00
|
|
|
* Currently only the compression flags and the cow flags are inherited.
|
2009-04-17 12:37:41 +04:00
|
|
|
*/
|
|
|
|
|
void btrfs_inherit_iflags(struct inode *inode, struct inode *dir)
|
|
|
|
|
{
|
2009-06-11 19:13:35 +04:00
|
|
|
unsigned int flags;
|
|
|
|
|
|
|
|
|
|
if (!dir)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
flags = BTRFS_I(dir)->flags;
|
2009-04-17 12:37:41 +04:00
|
|
|
|
2011-09-27 19:01:30 +04:00
|
|
|
if (flags & BTRFS_INODE_NOCOMPRESS) {
|
|
|
|
|
BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;
|
|
|
|
|
BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
|
|
|
|
|
} else if (flags & BTRFS_INODE_COMPRESS) {
|
|
|
|
|
BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;
|
|
|
|
|
BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-11 18:33:50 +04:00
|
|
|
if (flags & BTRFS_INODE_NODATACOW) {
|
2011-09-27 19:01:30 +04:00
|
|
|
BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
|
2012-09-11 18:33:50 +04:00
|
|
|
if (S_ISREG(inode->i_mode))
|
|
|
|
|
BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
|
|
|
|
|
}
|
2009-04-17 12:37:41 +04:00
|
|
|
|
|
|
|
|
btrfs_update_iflags(inode);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int btrfs_ioctl_getflags(struct file *file, void __user *arg)
|
|
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_inode *ip = BTRFS_I(file_inode(file));
|
2009-04-17 12:37:41 +04:00
|
|
|
unsigned int flags = btrfs_flags_to_ioctl(ip->flags);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &flags, sizeof(flags)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
Btrfs: Per file/directory controls for COW and compression
Data compression and data cow are controlled across the entire FS by mount
options right now. ioctls are needed to set this on a per file or per
directory basis. This has been proposed previously, but VFS developers
wanted us to use generic ioctls rather than btrfs-specific ones.
According to Chris's comment, there should be just one true compression
method(probably LZO) stored in the super. However, before this, we would
wait for that one method is stable enough to be adopted into the super.
So I list it as a long term goal, and just store it in ram today.
After applying this patch, we can use the generic "FS_IOC_SETFLAGS" ioctl to
control file and directory's datacow and compression attribute.
NOTE:
- The compression type is selected by such rules:
If we mount btrfs with compress options, ie, zlib/lzo, the type is it.
Otherwise, we'll use the default compress type (zlib today).
v1->v2:
- rebase to the latest btrfs.
v2->v3:
- fix a problem, i.e. when a file is set NOCOW via mount option, then this NOCOW
will be screwed by inheritance from parent directory.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-22 13:12:20 +03:00
|
|
|
static int check_flags(unsigned int flags)
|
|
|
|
|
{
|
|
|
|
|
if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
|
|
|
|
|
FS_NOATIME_FL | FS_NODUMP_FL | \
|
|
|
|
|
FS_SYNC_FL | FS_DIRSYNC_FL | \
|
2011-04-15 07:02:49 +04:00
|
|
|
FS_NOCOMP_FL | FS_COMPR_FL |
|
|
|
|
|
FS_NOCOW_FL))
|
Btrfs: Per file/directory controls for COW and compression
Data compression and data cow are controlled across the entire FS by mount
options right now. ioctls are needed to set this on a per file or per
directory basis. This has been proposed previously, but VFS developers
wanted us to use generic ioctls rather than btrfs-specific ones.
According to Chris's comment, there should be just one true compression
method(probably LZO) stored in the super. However, before this, we would
wait for that one method is stable enough to be adopted into the super.
So I list it as a long term goal, and just store it in ram today.
After applying this patch, we can use the generic "FS_IOC_SETFLAGS" ioctl to
control file and directory's datacow and compression attribute.
NOTE:
- The compression type is selected by such rules:
If we mount btrfs with compress options, ie, zlib/lzo, the type is it.
Otherwise, we'll use the default compress type (zlib today).
v1->v2:
- rebase to the latest btrfs.
v2->v3:
- fix a problem, i.e. when a file is set NOCOW via mount option, then this NOCOW
will be screwed by inheritance from parent directory.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-22 13:12:20 +03:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-17 12:37:41 +04:00
|
|
|
static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
|
|
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2009-04-17 12:37:41 +04:00
|
|
|
struct btrfs_inode *ip = BTRFS_I(inode);
|
|
|
|
|
struct btrfs_root *root = ip->root;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
unsigned int flags, oldflags;
|
|
|
|
|
int ret;
|
2011-12-29 09:36:45 +04:00
|
|
|
u64 ip_oldflags;
|
|
|
|
|
unsigned int i_oldflags;
|
btrfs: allow setting NOCOW for a zero sized file via ioctl
Hi,
the patch si simple, but it has user visible impact and I'm not quite sure how
to resolve it.
In short, $subj says it, chattr -C supports it and we want to use it.
The conditions that acutally allow to change the NOCOW flag are clear. What if
I try to set the flag on a file that is not empty? Options:
1) whole ioctl will fail, EINVAL
2.1) ioctl will succeed, the NOCOW flag will be silently removed, but the file
will stay COW-ed and checksummed
2.2) ioctl will succeed, flag will not be removed and a syslog message will
warn that the COW flag has not been changed
2.2.1) dtto, no syslog message
Man page of chattr states that
"If it is set on a file which already has data blocks, it is undefined when
the blocks assigned to the file will be fully stable."
Yes, it's undefined and with current implementation it'll never happen. So from
this end, the user cannot expect anything. I'm trying to find a reasonable
behaviour, so that a command like 'chattr -R -aijS +C' to tweak a broad set of
flags in a deep directory does not fail unnecessarily and does not pollute the
log.
My personal preference is 2.2.1, but my dev's oppinion is skewed, not counting
the fact that I know the code and otherwise would look there before consulting
the documentation.
The patch implements 2.2.1.
david
-------------8<-------------------
From: David Sterba <dsterba@suse.cz>
It's safe to turn off checksums for a zero sized file.
http://thread.gmane.org/gmane.comp.file-systems.btrfs/18030
"We cannot switch on NODATASUM for a file that already has extents that
are checksummed. The invariant here is that either all the extents or
none are checksummed.
Theoretically it's possible to add/remove all checksums from a given
file, but it's a potentially longtime operation, the file has to be in
some intermediate state where the checksums partially exist but have to
be ignored (for the csum->nocsum) until the file is fully converted,
this brings more special cases to extent handling, it has to survive
power failure and remain consistent, and probably needs to be restarted
after next mount."
Signed-off-by: David Sterba <dsterba@suse.cz>
2012-09-07 15:56:55 +04:00
|
|
|
umode_t mode;
|
2009-04-17 12:37:41 +04:00
|
|
|
|
2014-01-16 18:50:22 +04:00
|
|
|
if (!inode_owner_or_capable(inode))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2010-12-20 11:04:08 +03:00
|
|
|
if (btrfs_root_readonly(root))
|
|
|
|
|
return -EROFS;
|
|
|
|
|
|
2009-04-17 12:37:41 +04:00
|
|
|
if (copy_from_user(&flags, arg, sizeof(flags)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
Btrfs: Per file/directory controls for COW and compression
Data compression and data cow are controlled across the entire FS by mount
options right now. ioctls are needed to set this on a per file or per
directory basis. This has been proposed previously, but VFS developers
wanted us to use generic ioctls rather than btrfs-specific ones.
According to Chris's comment, there should be just one true compression
method(probably LZO) stored in the super. However, before this, we would
wait for that one method is stable enough to be adopted into the super.
So I list it as a long term goal, and just store it in ram today.
After applying this patch, we can use the generic "FS_IOC_SETFLAGS" ioctl to
control file and directory's datacow and compression attribute.
NOTE:
- The compression type is selected by such rules:
If we mount btrfs with compress options, ie, zlib/lzo, the type is it.
Otherwise, we'll use the default compress type (zlib today).
v1->v2:
- rebase to the latest btrfs.
v2->v3:
- fix a problem, i.e. when a file is set NOCOW via mount option, then this NOCOW
will be screwed by inheritance from parent directory.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-22 13:12:20 +03:00
|
|
|
ret = check_flags(flags);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2012-06-12 18:20:32 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2009-04-17 12:37:41 +04:00
|
|
|
mutex_lock(&inode->i_mutex);
|
|
|
|
|
|
2011-12-29 09:36:45 +04:00
|
|
|
ip_oldflags = ip->flags;
|
|
|
|
|
i_oldflags = inode->i_flags;
|
btrfs: allow setting NOCOW for a zero sized file via ioctl
Hi,
the patch si simple, but it has user visible impact and I'm not quite sure how
to resolve it.
In short, $subj says it, chattr -C supports it and we want to use it.
The conditions that acutally allow to change the NOCOW flag are clear. What if
I try to set the flag on a file that is not empty? Options:
1) whole ioctl will fail, EINVAL
2.1) ioctl will succeed, the NOCOW flag will be silently removed, but the file
will stay COW-ed and checksummed
2.2) ioctl will succeed, flag will not be removed and a syslog message will
warn that the COW flag has not been changed
2.2.1) dtto, no syslog message
Man page of chattr states that
"If it is set on a file which already has data blocks, it is undefined when
the blocks assigned to the file will be fully stable."
Yes, it's undefined and with current implementation it'll never happen. So from
this end, the user cannot expect anything. I'm trying to find a reasonable
behaviour, so that a command like 'chattr -R -aijS +C' to tweak a broad set of
flags in a deep directory does not fail unnecessarily and does not pollute the
log.
My personal preference is 2.2.1, but my dev's oppinion is skewed, not counting
the fact that I know the code and otherwise would look there before consulting
the documentation.
The patch implements 2.2.1.
david
-------------8<-------------------
From: David Sterba <dsterba@suse.cz>
It's safe to turn off checksums for a zero sized file.
http://thread.gmane.org/gmane.comp.file-systems.btrfs/18030
"We cannot switch on NODATASUM for a file that already has extents that
are checksummed. The invariant here is that either all the extents or
none are checksummed.
Theoretically it's possible to add/remove all checksums from a given
file, but it's a potentially longtime operation, the file has to be in
some intermediate state where the checksums partially exist but have to
be ignored (for the csum->nocsum) until the file is fully converted,
this brings more special cases to extent handling, it has to survive
power failure and remain consistent, and probably needs to be restarted
after next mount."
Signed-off-by: David Sterba <dsterba@suse.cz>
2012-09-07 15:56:55 +04:00
|
|
|
mode = inode->i_mode;
|
2011-12-29 09:36:45 +04:00
|
|
|
|
2009-04-17 12:37:41 +04:00
|
|
|
flags = btrfs_mask_flags(inode->i_mode, flags);
|
|
|
|
|
oldflags = btrfs_flags_to_ioctl(ip->flags);
|
|
|
|
|
if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
|
|
|
|
|
if (!capable(CAP_LINUX_IMMUTABLE)) {
|
|
|
|
|
ret = -EPERM;
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (flags & FS_SYNC_FL)
|
|
|
|
|
ip->flags |= BTRFS_INODE_SYNC;
|
|
|
|
|
else
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_SYNC;
|
|
|
|
|
if (flags & FS_IMMUTABLE_FL)
|
|
|
|
|
ip->flags |= BTRFS_INODE_IMMUTABLE;
|
|
|
|
|
else
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_IMMUTABLE;
|
|
|
|
|
if (flags & FS_APPEND_FL)
|
|
|
|
|
ip->flags |= BTRFS_INODE_APPEND;
|
|
|
|
|
else
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_APPEND;
|
|
|
|
|
if (flags & FS_NODUMP_FL)
|
|
|
|
|
ip->flags |= BTRFS_INODE_NODUMP;
|
|
|
|
|
else
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_NODUMP;
|
|
|
|
|
if (flags & FS_NOATIME_FL)
|
|
|
|
|
ip->flags |= BTRFS_INODE_NOATIME;
|
|
|
|
|
else
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_NOATIME;
|
|
|
|
|
if (flags & FS_DIRSYNC_FL)
|
|
|
|
|
ip->flags |= BTRFS_INODE_DIRSYNC;
|
|
|
|
|
else
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_DIRSYNC;
|
btrfs: allow setting NOCOW for a zero sized file via ioctl
Hi,
the patch si simple, but it has user visible impact and I'm not quite sure how
to resolve it.
In short, $subj says it, chattr -C supports it and we want to use it.
The conditions that acutally allow to change the NOCOW flag are clear. What if
I try to set the flag on a file that is not empty? Options:
1) whole ioctl will fail, EINVAL
2.1) ioctl will succeed, the NOCOW flag will be silently removed, but the file
will stay COW-ed and checksummed
2.2) ioctl will succeed, flag will not be removed and a syslog message will
warn that the COW flag has not been changed
2.2.1) dtto, no syslog message
Man page of chattr states that
"If it is set on a file which already has data blocks, it is undefined when
the blocks assigned to the file will be fully stable."
Yes, it's undefined and with current implementation it'll never happen. So from
this end, the user cannot expect anything. I'm trying to find a reasonable
behaviour, so that a command like 'chattr -R -aijS +C' to tweak a broad set of
flags in a deep directory does not fail unnecessarily and does not pollute the
log.
My personal preference is 2.2.1, but my dev's oppinion is skewed, not counting
the fact that I know the code and otherwise would look there before consulting
the documentation.
The patch implements 2.2.1.
david
-------------8<-------------------
From: David Sterba <dsterba@suse.cz>
It's safe to turn off checksums for a zero sized file.
http://thread.gmane.org/gmane.comp.file-systems.btrfs/18030
"We cannot switch on NODATASUM for a file that already has extents that
are checksummed. The invariant here is that either all the extents or
none are checksummed.
Theoretically it's possible to add/remove all checksums from a given
file, but it's a potentially longtime operation, the file has to be in
some intermediate state where the checksums partially exist but have to
be ignored (for the csum->nocsum) until the file is fully converted,
this brings more special cases to extent handling, it has to survive
power failure and remain consistent, and probably needs to be restarted
after next mount."
Signed-off-by: David Sterba <dsterba@suse.cz>
2012-09-07 15:56:55 +04:00
|
|
|
if (flags & FS_NOCOW_FL) {
|
|
|
|
|
if (S_ISREG(mode)) {
|
|
|
|
|
/*
|
|
|
|
|
* It's safe to turn csums off here, no extents exist.
|
|
|
|
|
* Otherwise we want the flag to reflect the real COW
|
|
|
|
|
* status of the file and will not set it.
|
|
|
|
|
*/
|
|
|
|
|
if (inode->i_size == 0)
|
|
|
|
|
ip->flags |= BTRFS_INODE_NODATACOW
|
|
|
|
|
| BTRFS_INODE_NODATASUM;
|
|
|
|
|
} else {
|
|
|
|
|
ip->flags |= BTRFS_INODE_NODATACOW;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* Revert back under same assuptions as above
|
|
|
|
|
*/
|
|
|
|
|
if (S_ISREG(mode)) {
|
|
|
|
|
if (inode->i_size == 0)
|
|
|
|
|
ip->flags &= ~(BTRFS_INODE_NODATACOW
|
|
|
|
|
| BTRFS_INODE_NODATASUM);
|
|
|
|
|
} else {
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_NODATACOW;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-04-17 12:37:41 +04:00
|
|
|
|
Btrfs: Per file/directory controls for COW and compression
Data compression and data cow are controlled across the entire FS by mount
options right now. ioctls are needed to set this on a per file or per
directory basis. This has been proposed previously, but VFS developers
wanted us to use generic ioctls rather than btrfs-specific ones.
According to Chris's comment, there should be just one true compression
method(probably LZO) stored in the super. However, before this, we would
wait for that one method is stable enough to be adopted into the super.
So I list it as a long term goal, and just store it in ram today.
After applying this patch, we can use the generic "FS_IOC_SETFLAGS" ioctl to
control file and directory's datacow and compression attribute.
NOTE:
- The compression type is selected by such rules:
If we mount btrfs with compress options, ie, zlib/lzo, the type is it.
Otherwise, we'll use the default compress type (zlib today).
v1->v2:
- rebase to the latest btrfs.
v2->v3:
- fix a problem, i.e. when a file is set NOCOW via mount option, then this NOCOW
will be screwed by inheritance from parent directory.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-22 13:12:20 +03:00
|
|
|
/*
|
|
|
|
|
* The COMPRESS flag can only be changed by users, while the NOCOMPRESS
|
|
|
|
|
* flag may be changed automatically if compression code won't make
|
|
|
|
|
* things smaller.
|
|
|
|
|
*/
|
|
|
|
|
if (flags & FS_NOCOMP_FL) {
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_COMPRESS;
|
|
|
|
|
ip->flags |= BTRFS_INODE_NOCOMPRESS;
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 15:47:46 +04:00
|
|
|
|
|
|
|
|
ret = btrfs_set_prop(inode, "btrfs.compression", NULL, 0, 0);
|
|
|
|
|
if (ret && ret != -ENODATA)
|
|
|
|
|
goto out_drop;
|
Btrfs: Per file/directory controls for COW and compression
Data compression and data cow are controlled across the entire FS by mount
options right now. ioctls are needed to set this on a per file or per
directory basis. This has been proposed previously, but VFS developers
wanted us to use generic ioctls rather than btrfs-specific ones.
According to Chris's comment, there should be just one true compression
method(probably LZO) stored in the super. However, before this, we would
wait for that one method is stable enough to be adopted into the super.
So I list it as a long term goal, and just store it in ram today.
After applying this patch, we can use the generic "FS_IOC_SETFLAGS" ioctl to
control file and directory's datacow and compression attribute.
NOTE:
- The compression type is selected by such rules:
If we mount btrfs with compress options, ie, zlib/lzo, the type is it.
Otherwise, we'll use the default compress type (zlib today).
v1->v2:
- rebase to the latest btrfs.
v2->v3:
- fix a problem, i.e. when a file is set NOCOW via mount option, then this NOCOW
will be screwed by inheritance from parent directory.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-22 13:12:20 +03:00
|
|
|
} else if (flags & FS_COMPR_FL) {
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 15:47:46 +04:00
|
|
|
const char *comp;
|
|
|
|
|
|
Btrfs: Per file/directory controls for COW and compression
Data compression and data cow are controlled across the entire FS by mount
options right now. ioctls are needed to set this on a per file or per
directory basis. This has been proposed previously, but VFS developers
wanted us to use generic ioctls rather than btrfs-specific ones.
According to Chris's comment, there should be just one true compression
method(probably LZO) stored in the super. However, before this, we would
wait for that one method is stable enough to be adopted into the super.
So I list it as a long term goal, and just store it in ram today.
After applying this patch, we can use the generic "FS_IOC_SETFLAGS" ioctl to
control file and directory's datacow and compression attribute.
NOTE:
- The compression type is selected by such rules:
If we mount btrfs with compress options, ie, zlib/lzo, the type is it.
Otherwise, we'll use the default compress type (zlib today).
v1->v2:
- rebase to the latest btrfs.
v2->v3:
- fix a problem, i.e. when a file is set NOCOW via mount option, then this NOCOW
will be screwed by inheritance from parent directory.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-22 13:12:20 +03:00
|
|
|
ip->flags |= BTRFS_INODE_COMPRESS;
|
|
|
|
|
ip->flags &= ~BTRFS_INODE_NOCOMPRESS;
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 15:47:46 +04:00
|
|
|
|
|
|
|
|
if (root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
|
|
|
|
|
comp = "lzo";
|
|
|
|
|
else
|
|
|
|
|
comp = "zlib";
|
|
|
|
|
ret = btrfs_set_prop(inode, "btrfs.compression",
|
|
|
|
|
comp, strlen(comp), 0);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out_drop;
|
|
|
|
|
|
2011-04-15 07:03:17 +04:00
|
|
|
} else {
|
|
|
|
|
ip->flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS);
|
Btrfs: Per file/directory controls for COW and compression
Data compression and data cow are controlled across the entire FS by mount
options right now. ioctls are needed to set this on a per file or per
directory basis. This has been proposed previously, but VFS developers
wanted us to use generic ioctls rather than btrfs-specific ones.
According to Chris's comment, there should be just one true compression
method(probably LZO) stored in the super. However, before this, we would
wait for that one method is stable enough to be adopted into the super.
So I list it as a long term goal, and just store it in ram today.
After applying this patch, we can use the generic "FS_IOC_SETFLAGS" ioctl to
control file and directory's datacow and compression attribute.
NOTE:
- The compression type is selected by such rules:
If we mount btrfs with compress options, ie, zlib/lzo, the type is it.
Otherwise, we'll use the default compress type (zlib today).
v1->v2:
- rebase to the latest btrfs.
v2->v3:
- fix a problem, i.e. when a file is set NOCOW via mount option, then this NOCOW
will be screwed by inheritance from parent directory.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-22 13:12:20 +03:00
|
|
|
}
|
2009-04-17 12:37:41 +04:00
|
|
|
|
2011-12-29 09:39:50 +04:00
|
|
|
trans = btrfs_start_transaction(root, 1);
|
2011-12-29 09:36:45 +04:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out_drop;
|
|
|
|
|
}
|
2009-04-17 12:37:41 +04:00
|
|
|
|
2011-12-15 05:12:02 +04:00
|
|
|
btrfs_update_iflags(inode);
|
2012-04-05 23:03:02 +04:00
|
|
|
inode_inc_iversion(inode);
|
2011-12-15 05:12:02 +04:00
|
|
|
inode->i_ctime = CURRENT_TIME;
|
2009-04-17 12:37:41 +04:00
|
|
|
ret = btrfs_update_inode(trans, root, inode);
|
|
|
|
|
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
2011-12-29 09:36:45 +04:00
|
|
|
out_drop:
|
|
|
|
|
if (ret) {
|
|
|
|
|
ip->flags = ip_oldflags;
|
|
|
|
|
inode->i_flags = i_oldflags;
|
|
|
|
|
}
|
2009-04-17 12:37:41 +04:00
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
2012-06-12 18:20:32 +04:00
|
|
|
mnt_drop_write_file(file);
|
2011-02-24 12:38:16 +03:00
|
|
|
return ret;
|
2009-04-17 12:37:41 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
|
|
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2009-04-17 12:37:41 +04:00
|
|
|
|
|
|
|
|
return put_user(inode->i_generation, arg);
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2011-03-24 13:24:28 +03:00
|
|
|
static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
|
|
|
|
|
{
|
2013-09-01 23:57:51 +04:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(file_inode(file)->i_sb);
|
2011-03-24 13:24:28 +03:00
|
|
|
struct btrfs_device *device;
|
|
|
|
|
struct request_queue *q;
|
|
|
|
|
struct fstrim_range range;
|
|
|
|
|
u64 minlen = ULLONG_MAX;
|
|
|
|
|
u64 num_devices = 0;
|
2011-11-18 00:40:49 +04:00
|
|
|
u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
|
2011-03-24 13:24:28 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2011-04-20 14:09:16 +04:00
|
|
|
rcu_read_lock();
|
|
|
|
|
list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,
|
|
|
|
|
dev_list) {
|
2011-03-24 13:24:28 +03:00
|
|
|
if (!device->bdev)
|
|
|
|
|
continue;
|
|
|
|
|
q = bdev_get_queue(device->bdev);
|
|
|
|
|
if (blk_queue_discard(q)) {
|
|
|
|
|
num_devices++;
|
|
|
|
|
minlen = min((u64)q->limits.discard_granularity,
|
|
|
|
|
minlen);
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-04-20 14:09:16 +04:00
|
|
|
rcu_read_unlock();
|
2011-09-05 18:34:54 +04:00
|
|
|
|
2011-03-24 13:24:28 +03:00
|
|
|
if (!num_devices)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
if (copy_from_user(&range, arg, sizeof(range)))
|
|
|
|
|
return -EFAULT;
|
2012-10-16 13:34:36 +04:00
|
|
|
if (range.start > total_bytes ||
|
|
|
|
|
range.len < fs_info->sb->s_blocksize)
|
2011-09-05 18:34:54 +04:00
|
|
|
return -EINVAL;
|
2011-03-24 13:24:28 +03:00
|
|
|
|
2011-09-05 18:34:54 +04:00
|
|
|
range.len = min(range.len, total_bytes - range.start);
|
2011-03-24 13:24:28 +03:00
|
|
|
range.minlen = max(range.minlen, minlen);
|
2011-11-18 00:40:49 +04:00
|
|
|
ret = btrfs_trim_fs(fs_info->tree_root, &range);
|
2011-03-24 13:24:28 +03:00
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &range, sizeof(range)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-15 19:11:20 +04:00
|
|
|
int btrfs_is_empty_uuid(u8 *uuid)
|
|
|
|
|
{
|
2013-11-15 15:14:55 +04:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < BTRFS_UUID_SIZE; i++) {
|
|
|
|
|
if (uuid[i])
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
2013-08-15 19:11:20 +04:00
|
|
|
}
|
|
|
|
|
|
2013-02-28 14:04:33 +04:00
|
|
|
static noinline int create_subvol(struct inode *dir,
|
2008-10-09 21:39:39 +04:00
|
|
|
struct dentry *dentry,
|
2010-10-29 23:41:32 +04:00
|
|
|
char *name, int namelen,
|
2011-09-14 17:58:21 +04:00
|
|
|
u64 *async_transid,
|
2013-02-07 10:02:44 +04:00
|
|
|
struct btrfs_qgroup_inherit *inherit)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
struct btrfs_root_item root_item;
|
|
|
|
|
struct btrfs_inode_item *inode_item;
|
|
|
|
|
struct extent_buffer *leaf;
|
2013-02-28 14:04:33 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(dir)->root;
|
2009-09-22 00:00:26 +04:00
|
|
|
struct btrfs_root *new_root;
|
2013-02-28 14:04:33 +04:00
|
|
|
struct btrfs_block_rsv block_rsv;
|
2012-07-25 19:35:53 +04:00
|
|
|
struct timespec cur_time = CURRENT_TIME;
|
2013-12-13 04:51:42 +04:00
|
|
|
struct inode *inode;
|
2008-06-12 05:53:53 +04:00
|
|
|
int ret;
|
|
|
|
|
int err;
|
|
|
|
|
u64 objectid;
|
|
|
|
|
u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
|
2008-11-18 05:02:50 +03:00
|
|
|
u64 index = 0;
|
2013-02-28 14:04:33 +04:00
|
|
|
u64 qgroup_reserved;
|
2012-07-25 19:35:53 +04:00
|
|
|
uuid_le new_uuid;
|
2008-06-12 05:53:53 +04:00
|
|
|
|
Btrfs: Cache free inode numbers in memory
Currently btrfs stores the highest objectid of the fs tree, and it always
returns (highest+1) inode number when we create a file, so inode numbers
won't be reclaimed when we delete files, so we'll run out of inode numbers
as we keep create/delete files in 32bits machines.
This fixes it, and it works similarly to how we cache free space in block
cgroups.
We start a kernel thread to read the file tree. By scanning inode items,
we know which chunks of inode numbers are free, and we cache them in
an rb-tree.
Because we are searching the commit root, we have to carefully handle the
cross-transaction case.
The rb-tree is a hybrid extent+bitmap tree, so if we have too many small
chunks of inode numbers, we'll use bitmaps. Initially we allow 16K ram
of extents, and a bitmap will be used if we exceed this threshold. The
extents threshold is adjusted in runtime.
Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
2011-04-20 06:06:11 +04:00
|
|
|
ret = btrfs_find_free_objectid(root->fs_info->tree_root, &objectid);
|
2011-07-17 05:38:06 +04:00
|
|
|
if (ret)
|
2010-05-16 18:48:46 +04:00
|
|
|
return ret;
|
2010-11-20 12:48:00 +03:00
|
|
|
|
2013-02-28 14:04:33 +04:00
|
|
|
btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
|
2009-09-12 00:12:44 +04:00
|
|
|
/*
|
2013-02-28 14:04:33 +04:00
|
|
|
* The same as the snapshot creation, please see the comment
|
|
|
|
|
* of create_snapshot().
|
2009-09-12 00:12:44 +04:00
|
|
|
*/
|
2013-02-28 14:04:33 +04:00
|
|
|
ret = btrfs_subvolume_reserve_metadata(root, &block_rsv,
|
2013-08-15 19:11:20 +04:00
|
|
|
8, &qgroup_reserved, false);
|
2013-02-28 14:04:33 +04:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
trans = btrfs_start_transaction(root, 0);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
2014-01-09 10:57:06 +04:00
|
|
|
btrfs_subvolume_release_metadata(root, &block_rsv,
|
|
|
|
|
qgroup_reserved);
|
|
|
|
|
return ret;
|
2013-02-28 14:04:33 +04:00
|
|
|
}
|
|
|
|
|
trans->block_rsv = &block_rsv;
|
|
|
|
|
trans->bytes_reserved = block_rsv.size;
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2013-02-07 10:02:44 +04:00
|
|
|
ret = btrfs_qgroup_inherit(trans, root->fs_info, 0, objectid, inherit);
|
2011-09-14 17:58:21 +04:00
|
|
|
if (ret)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
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 18:45:14 +04:00
|
|
|
leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
|
2012-05-16 19:04:52 +04:00
|
|
|
0, objectid, NULL, 0, 0, 0);
|
2008-07-24 20:17:14 +04:00
|
|
|
if (IS_ERR(leaf)) {
|
|
|
|
|
ret = PTR_ERR(leaf);
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04: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 18:45:14 +04:00
|
|
|
memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
|
2008-06-12 05:53:53 +04:00
|
|
|
btrfs_set_header_bytenr(leaf, leaf->start);
|
|
|
|
|
btrfs_set_header_generation(leaf, trans->transid);
|
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 18:45:14 +04:00
|
|
|
btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
|
2008-06-12 05:53:53 +04:00
|
|
|
btrfs_set_header_owner(leaf, objectid);
|
|
|
|
|
|
2013-09-24 13:12:38 +04:00
|
|
|
write_extent_buffer(leaf, root->fs_info->fsid, btrfs_header_fsid(),
|
2008-06-12 05:53:53 +04:00
|
|
|
BTRFS_FSID_SIZE);
|
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 18:45:14 +04:00
|
|
|
write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
|
2013-08-20 15:20:15 +04:00
|
|
|
btrfs_header_chunk_tree_uuid(leaf),
|
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 18:45:14 +04:00
|
|
|
BTRFS_UUID_SIZE);
|
2008-06-12 05:53:53 +04:00
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
|
|
2012-07-25 19:35:53 +04:00
|
|
|
memset(&root_item, 0, sizeof(root_item));
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
inode_item = &root_item.inode;
|
2013-07-16 07:19:18 +04:00
|
|
|
btrfs_set_stack_inode_generation(inode_item, 1);
|
|
|
|
|
btrfs_set_stack_inode_size(inode_item, 3);
|
|
|
|
|
btrfs_set_stack_inode_nlink(inode_item, 1);
|
|
|
|
|
btrfs_set_stack_inode_nbytes(inode_item, root->leafsize);
|
|
|
|
|
btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2013-07-16 07:19:18 +04:00
|
|
|
btrfs_set_root_flags(&root_item, 0);
|
|
|
|
|
btrfs_set_root_limit(&root_item, 0);
|
|
|
|
|
btrfs_set_stack_inode_flags(inode_item, BTRFS_INODE_ROOT_ITEM_INIT);
|
2011-03-28 06:01:25 +04:00
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
btrfs_set_root_bytenr(&root_item, leaf->start);
|
2008-10-29 21:49:05 +03:00
|
|
|
btrfs_set_root_generation(&root_item, trans->transid);
|
2008-06-12 05:53:53 +04:00
|
|
|
btrfs_set_root_level(&root_item, 0);
|
|
|
|
|
btrfs_set_root_refs(&root_item, 1);
|
2009-11-12 12:36:50 +03:00
|
|
|
btrfs_set_root_used(&root_item, leaf->len);
|
2008-10-30 21:20:02 +03:00
|
|
|
btrfs_set_root_last_snapshot(&root_item, 0);
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2012-07-25 19:35:53 +04:00
|
|
|
btrfs_set_root_generation_v2(&root_item,
|
|
|
|
|
btrfs_root_generation(&root_item));
|
|
|
|
|
uuid_le_gen(&new_uuid);
|
|
|
|
|
memcpy(root_item.uuid, new_uuid.b, BTRFS_UUID_SIZE);
|
2013-07-16 07:19:18 +04:00
|
|
|
btrfs_set_stack_timespec_sec(&root_item.otime, cur_time.tv_sec);
|
|
|
|
|
btrfs_set_stack_timespec_nsec(&root_item.otime, cur_time.tv_nsec);
|
2012-07-25 19:35:53 +04:00
|
|
|
root_item.ctime = root_item.otime;
|
|
|
|
|
btrfs_set_root_ctransid(&root_item, trans->transid);
|
|
|
|
|
btrfs_set_root_otransid(&root_item, trans->transid);
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2008-06-26 00:01:30 +04:00
|
|
|
btrfs_tree_unlock(leaf);
|
2008-06-12 05:53:53 +04:00
|
|
|
free_extent_buffer(leaf);
|
|
|
|
|
leaf = NULL;
|
|
|
|
|
|
|
|
|
|
btrfs_set_root_dirid(&root_item, new_dirid);
|
|
|
|
|
|
|
|
|
|
key.objectid = objectid;
|
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 18:45:14 +04:00
|
|
|
key.offset = 0;
|
2008-06-12 05:53:53 +04:00
|
|
|
btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
|
|
|
|
|
ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
|
|
|
|
|
&root_item);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
2009-09-22 00:00:26 +04:00
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
new_root = btrfs_read_fs_root_no_name(root->fs_info, &key);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (IS_ERR(new_root)) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, PTR_ERR(new_root));
|
|
|
|
|
ret = PTR_ERR(new_root);
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
2009-09-22 00:00:26 +04:00
|
|
|
|
|
|
|
|
btrfs_record_root_in_trans(trans, new_root);
|
|
|
|
|
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 15:47:46 +04:00
|
|
|
ret = btrfs_create_subvol_root(trans, new_root, root, new_dirid);
|
2011-07-26 22:32:23 +04:00
|
|
|
if (ret) {
|
|
|
|
|
/* We potentially lose an unused inode item here */
|
2012-03-12 19:03:00 +04:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2011-07-26 22:32:23 +04:00
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
/*
|
|
|
|
|
* insert the directory item
|
|
|
|
|
*/
|
2008-11-18 05:02:50 +03:00
|
|
|
ret = btrfs_set_inode_index(dir, &index);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
2008-11-18 05:02:50 +03:00
|
|
|
|
|
|
|
|
ret = btrfs_insert_dir_item(trans, root,
|
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 14:12:22 +04:00
|
|
|
name, namelen, dir, &key,
|
2008-11-18 05:02:50 +03:00
|
|
|
BTRFS_FT_DIR, index);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2008-06-12 05:53:53 +04:00
|
|
|
goto fail;
|
2012-03-12 19:03:00 +04:00
|
|
|
}
|
2008-11-18 04:37:39 +03:00
|
|
|
|
2009-01-05 23:43:43 +03:00
|
|
|
btrfs_i_size_write(dir, dir->i_size + namelen * 2);
|
|
|
|
|
ret = btrfs_update_inode(trans, root, dir);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
2008-11-18 04:37:39 +03:00
|
|
|
ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
|
2009-09-21 23:56:00 +04:00
|
|
|
objectid, root->root_key.objectid,
|
2011-04-20 06:31:50 +04:00
|
|
|
btrfs_ino(dir), index, name, namelen);
|
2009-09-22 00:00:26 +04:00
|
|
|
BUG_ON(ret);
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2013-08-15 19:11:20 +04:00
|
|
|
ret = btrfs_uuid_tree_add(trans, root->fs_info->uuid_root,
|
|
|
|
|
root_item.uuid, BTRFS_UUID_KEY_SUBVOL,
|
|
|
|
|
objectid);
|
|
|
|
|
if (ret)
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
fail:
|
2013-02-28 14:04:33 +04:00
|
|
|
trans->block_rsv = NULL;
|
|
|
|
|
trans->bytes_reserved = 0;
|
2014-01-09 10:57:06 +04:00
|
|
|
btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved);
|
|
|
|
|
|
2010-10-29 23:41:32 +04:00
|
|
|
if (async_transid) {
|
|
|
|
|
*async_transid = trans->transid;
|
|
|
|
|
err = btrfs_commit_transaction_async(trans, root, 1);
|
2013-03-04 13:45:06 +04:00
|
|
|
if (err)
|
|
|
|
|
err = btrfs_commit_transaction(trans, root);
|
2010-10-29 23:41:32 +04:00
|
|
|
} else {
|
|
|
|
|
err = btrfs_commit_transaction(trans, root);
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
if (err && !ret)
|
|
|
|
|
ret = err;
|
2013-02-06 21:06:02 +04:00
|
|
|
|
2013-12-13 04:51:42 +04:00
|
|
|
if (!ret) {
|
|
|
|
|
inode = btrfs_lookup_dentry(dir, dentry);
|
2014-01-09 10:57:06 +04:00
|
|
|
if (IS_ERR(inode))
|
|
|
|
|
return PTR_ERR(inode);
|
2013-12-13 04:51:42 +04:00
|
|
|
d_instantiate(dentry, inode);
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-06 09:38:19 +04:00
|
|
|
static void btrfs_wait_nocow_write(struct btrfs_root *root)
|
|
|
|
|
{
|
|
|
|
|
s64 writers;
|
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
prepare_to_wait(&root->subv_writers->wait, &wait,
|
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
|
|
|
|
|
|
writers = percpu_counter_sum(&root->subv_writers->counter);
|
|
|
|
|
if (writers)
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
|
|
finish_wait(&root->subv_writers->wait, &wait);
|
|
|
|
|
} while (writers);
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-28 14:01:15 +04:00
|
|
|
static int create_snapshot(struct btrfs_root *root, struct inode *dir,
|
|
|
|
|
struct dentry *dentry, char *name, int namelen,
|
|
|
|
|
u64 *async_transid, bool readonly,
|
|
|
|
|
struct btrfs_qgroup_inherit *inherit)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
2009-11-12 12:37:02 +03:00
|
|
|
struct inode *inode;
|
2008-06-12 05:53:53 +04:00
|
|
|
struct btrfs_pending_snapshot *pending_snapshot;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
2009-11-12 12:37:02 +03:00
|
|
|
int ret;
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2014-04-02 15:51:05 +04:00
|
|
|
if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
|
2008-06-12 05:53:53 +04:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2014-03-06 09:38:19 +04:00
|
|
|
atomic_inc(&root->will_be_snapshoted);
|
2014-03-17 21:06:10 +04:00
|
|
|
smp_mb__after_atomic();
|
2014-03-06 09:38:19 +04:00
|
|
|
btrfs_wait_nocow_write(root);
|
|
|
|
|
|
2013-05-15 11:48:24 +04:00
|
|
|
ret = btrfs_start_delalloc_inodes(root, 0);
|
|
|
|
|
if (ret)
|
2014-03-06 09:38:19 +04:00
|
|
|
goto out;
|
2013-05-15 11:48:24 +04:00
|
|
|
|
2013-11-04 19:13:25 +04:00
|
|
|
btrfs_wait_ordered_extents(root, -1);
|
2013-05-15 11:48:24 +04:00
|
|
|
|
2008-11-18 05:02:50 +03:00
|
|
|
pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_NOFS);
|
2014-03-06 09:38:19 +04:00
|
|
|
if (!pending_snapshot) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2010-05-16 18:48:46 +04:00
|
|
|
|
2012-09-06 14:02:28 +04:00
|
|
|
btrfs_init_block_rsv(&pending_snapshot->block_rsv,
|
|
|
|
|
BTRFS_BLOCK_RSV_TEMP);
|
2013-02-28 14:04:33 +04:00
|
|
|
/*
|
|
|
|
|
* 1 - parent dir inode
|
|
|
|
|
* 2 - dir entries
|
|
|
|
|
* 1 - root item
|
|
|
|
|
* 2 - root ref/backref
|
|
|
|
|
* 1 - root of snapshot
|
2013-08-15 19:11:20 +04:00
|
|
|
* 1 - UUID item
|
2013-02-28 14:04:33 +04:00
|
|
|
*/
|
|
|
|
|
ret = btrfs_subvolume_reserve_metadata(BTRFS_I(dir)->root,
|
2013-08-15 19:11:20 +04:00
|
|
|
&pending_snapshot->block_rsv, 8,
|
2013-07-10 00:37:21 +04:00
|
|
|
&pending_snapshot->qgroup_reserved,
|
|
|
|
|
false);
|
2013-02-28 14:04:33 +04:00
|
|
|
if (ret)
|
2014-03-06 09:38:19 +04:00
|
|
|
goto free;
|
2013-02-28 14:04:33 +04:00
|
|
|
|
2008-11-18 05:02:50 +03:00
|
|
|
pending_snapshot->dentry = dentry;
|
2008-06-12 05:53:53 +04:00
|
|
|
pending_snapshot->root = root;
|
2010-12-20 11:04:08 +03:00
|
|
|
pending_snapshot->readonly = readonly;
|
2013-02-28 14:01:15 +04:00
|
|
|
pending_snapshot->dir = dir;
|
2013-02-07 10:02:44 +04:00
|
|
|
pending_snapshot->inherit = inherit;
|
2010-05-16 18:48:46 +04:00
|
|
|
|
2013-02-28 14:04:33 +04:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2010-05-16 18:48:46 +04:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-14 23:16:14 +04:00
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
2008-06-12 05:53:53 +04:00
|
|
|
list_add(&pending_snapshot->list,
|
|
|
|
|
&trans->transaction->pending_snapshots);
|
2011-06-14 23:16:14 +04:00
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2010-10-29 23:41:32 +04:00
|
|
|
if (async_transid) {
|
|
|
|
|
*async_transid = trans->transid;
|
|
|
|
|
ret = btrfs_commit_transaction_async(trans,
|
|
|
|
|
root->fs_info->extent_root, 1);
|
2013-03-04 13:45:06 +04:00
|
|
|
if (ret)
|
|
|
|
|
ret = btrfs_commit_transaction(trans, root);
|
2010-10-29 23:41:32 +04:00
|
|
|
} else {
|
|
|
|
|
ret = btrfs_commit_transaction(trans,
|
|
|
|
|
root->fs_info->extent_root);
|
|
|
|
|
}
|
2013-03-04 13:44:29 +04:00
|
|
|
if (ret)
|
2012-10-22 23:51:44 +04:00
|
|
|
goto fail;
|
2010-05-16 18:48:46 +04:00
|
|
|
|
|
|
|
|
ret = pending_snapshot->error;
|
|
|
|
|
if (ret)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
2011-07-17 05:38:06 +04:00
|
|
|
inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry);
|
2009-11-12 12:37:02 +03:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
|
ret = PTR_ERR(inode);
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
2013-12-13 04:51:42 +04:00
|
|
|
|
2009-11-12 12:37:02 +03:00
|
|
|
d_instantiate(dentry, inode);
|
|
|
|
|
ret = 0;
|
|
|
|
|
fail:
|
2013-02-28 14:04:33 +04:00
|
|
|
btrfs_subvolume_release_metadata(BTRFS_I(dir)->root,
|
|
|
|
|
&pending_snapshot->block_rsv,
|
|
|
|
|
pending_snapshot->qgroup_reserved);
|
2014-03-06 09:38:19 +04:00
|
|
|
free:
|
2010-05-16 18:48:46 +04:00
|
|
|
kfree(pending_snapshot);
|
2014-03-06 09:38:19 +04:00
|
|
|
out:
|
|
|
|
|
atomic_dec(&root->will_be_snapshoted);
|
2008-06-12 05:53:53 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-29 23:46:43 +04:00
|
|
|
/* copy of check_sticky in fs/namei.c()
|
|
|
|
|
* It's inline, so penalty for filesystems that don't use sticky bit is
|
|
|
|
|
* minimal.
|
|
|
|
|
*/
|
|
|
|
|
static inline int btrfs_check_sticky(struct inode *dir, struct inode *inode)
|
|
|
|
|
{
|
2012-02-10 23:05:07 +04:00
|
|
|
kuid_t fsuid = current_fsuid();
|
2010-10-29 23:46:43 +04:00
|
|
|
|
|
|
|
|
if (!(dir->i_mode & S_ISVTX))
|
|
|
|
|
return 0;
|
2012-02-10 23:05:07 +04:00
|
|
|
if (uid_eq(inode->i_uid, fsuid))
|
2010-10-29 23:46:43 +04:00
|
|
|
return 0;
|
2012-02-10 23:05:07 +04:00
|
|
|
if (uid_eq(dir->i_uid, fsuid))
|
2010-10-29 23:46:43 +04:00
|
|
|
return 0;
|
|
|
|
|
return !capable(CAP_FOWNER);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* copy of may_delete in fs/namei.c()
|
|
|
|
|
* Check whether we can remove a link victim from directory dir, check
|
|
|
|
|
* whether the type of victim is right.
|
|
|
|
|
* 1. We can't do it if dir is read-only (done in permission())
|
|
|
|
|
* 2. We should have write and exec permissions on dir
|
|
|
|
|
* 3. We can't remove anything from append-only dir
|
|
|
|
|
* 4. We can't do anything with immutable dir (done in permission())
|
|
|
|
|
* 5. If the sticky bit on dir is set we should either
|
|
|
|
|
* a. be owner of dir, or
|
|
|
|
|
* b. be owner of victim, or
|
|
|
|
|
* c. have CAP_FOWNER capability
|
|
|
|
|
* 6. If the victim is append-only or immutable we can't do antyhing with
|
|
|
|
|
* links pointing to it.
|
|
|
|
|
* 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
|
|
|
|
|
* 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
|
|
|
|
|
* 9. We can't remove a root or mountpoint.
|
|
|
|
|
* 10. We don't allow removal of NFS sillyrenamed files; it's handled by
|
|
|
|
|
* nfs_async_unlink().
|
|
|
|
|
*/
|
|
|
|
|
|
2013-10-31 09:03:04 +04:00
|
|
|
static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
|
2010-10-29 23:46:43 +04:00
|
|
|
{
|
|
|
|
|
int error;
|
|
|
|
|
|
|
|
|
|
if (!victim->d_inode)
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
|
|
BUG_ON(victim->d_parent->d_inode != dir);
|
2012-10-10 23:25:25 +04:00
|
|
|
audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
|
2010-10-29 23:46:43 +04:00
|
|
|
|
|
|
|
|
error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
|
|
|
|
|
if (error)
|
|
|
|
|
return error;
|
|
|
|
|
if (IS_APPEND(dir))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
if (btrfs_check_sticky(dir, victim->d_inode)||
|
|
|
|
|
IS_APPEND(victim->d_inode)||
|
|
|
|
|
IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
if (isdir) {
|
|
|
|
|
if (!S_ISDIR(victim->d_inode->i_mode))
|
|
|
|
|
return -ENOTDIR;
|
|
|
|
|
if (IS_ROOT(victim))
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
} else if (S_ISDIR(victim->d_inode->i_mode))
|
|
|
|
|
return -EISDIR;
|
|
|
|
|
if (IS_DEADDIR(dir))
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
if (victim->d_flags & DCACHE_NFSFS_RENAMED)
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-09 21:39:39 +04:00
|
|
|
/* copy of may_create in fs/namei.c() */
|
|
|
|
|
static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
|
|
|
|
|
{
|
|
|
|
|
if (child->d_inode)
|
|
|
|
|
return -EEXIST;
|
|
|
|
|
if (IS_DEADDIR(dir))
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
return inode_permission(dir, MAY_WRITE | MAY_EXEC);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Create a new subvolume below @parent. This is largely modeled after
|
|
|
|
|
* sys_mkdirat and vfs_mkdir, but we only do a single component lookup
|
|
|
|
|
* inside this filesystem so it's quite a bit simpler.
|
|
|
|
|
*/
|
2009-09-22 00:00:26 +04:00
|
|
|
static noinline int btrfs_mksubvol(struct path *parent,
|
|
|
|
|
char *name, int namelen,
|
2010-10-29 23:41:32 +04:00
|
|
|
struct btrfs_root *snap_src,
|
2011-09-14 17:58:21 +04:00
|
|
|
u64 *async_transid, bool readonly,
|
2013-02-07 10:02:44 +04:00
|
|
|
struct btrfs_qgroup_inherit *inherit)
|
2008-10-09 21:39:39 +04:00
|
|
|
{
|
2009-09-22 00:00:26 +04:00
|
|
|
struct inode *dir = parent->dentry->d_inode;
|
2008-10-09 21:39:39 +04:00
|
|
|
struct dentry *dentry;
|
|
|
|
|
int error;
|
|
|
|
|
|
2013-03-22 22:12:51 +04:00
|
|
|
error = mutex_lock_killable_nested(&dir->i_mutex, I_MUTEX_PARENT);
|
|
|
|
|
if (error == -EINTR)
|
|
|
|
|
return error;
|
2008-10-09 21:39:39 +04:00
|
|
|
|
|
|
|
|
dentry = lookup_one_len(name, parent->dentry, namelen);
|
|
|
|
|
error = PTR_ERR(dentry);
|
|
|
|
|
if (IS_ERR(dentry))
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
error = -EEXIST;
|
|
|
|
|
if (dentry->d_inode)
|
|
|
|
|
goto out_dput;
|
|
|
|
|
|
2009-09-22 00:00:26 +04:00
|
|
|
error = btrfs_may_create(dir, dentry);
|
2008-10-09 21:39:39 +04:00
|
|
|
if (error)
|
2012-06-29 13:58:46 +04:00
|
|
|
goto out_dput;
|
2008-10-09 21:39:39 +04:00
|
|
|
|
2012-12-17 23:26:57 +04:00
|
|
|
/*
|
|
|
|
|
* even if this name doesn't exist, we may get hash collisions.
|
|
|
|
|
* check for them now when we can safely fail
|
|
|
|
|
*/
|
|
|
|
|
error = btrfs_check_dir_item_collision(BTRFS_I(dir)->root,
|
|
|
|
|
dir->i_ino, name,
|
|
|
|
|
namelen);
|
|
|
|
|
if (error)
|
|
|
|
|
goto out_dput;
|
|
|
|
|
|
2009-09-22 00:00:26 +04:00
|
|
|
down_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);
|
|
|
|
|
|
|
|
|
|
if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0)
|
|
|
|
|
goto out_up_read;
|
|
|
|
|
|
2008-11-18 05:02:50 +03:00
|
|
|
if (snap_src) {
|
2013-02-28 14:01:15 +04:00
|
|
|
error = create_snapshot(snap_src, dir, dentry, name, namelen,
|
2011-09-14 17:58:21 +04:00
|
|
|
async_transid, readonly, inherit);
|
2008-11-18 05:02:50 +03:00
|
|
|
} else {
|
2013-02-28 14:04:33 +04:00
|
|
|
error = create_subvol(dir, dentry, name, namelen,
|
|
|
|
|
async_transid, inherit);
|
2008-11-18 05:02:50 +03:00
|
|
|
}
|
2009-09-22 00:00:26 +04:00
|
|
|
if (!error)
|
|
|
|
|
fsnotify_mkdir(dir, dentry);
|
|
|
|
|
out_up_read:
|
|
|
|
|
up_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);
|
2008-10-09 21:39:39 +04:00
|
|
|
out_dput:
|
|
|
|
|
dput(dentry);
|
|
|
|
|
out_unlock:
|
2009-09-22 00:00:26 +04:00
|
|
|
mutex_unlock(&dir->i_mutex);
|
2008-10-09 21:39:39 +04:00
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
/*
|
|
|
|
|
* When we're defragging a range, we don't want to kick it off again
|
|
|
|
|
* if it is really just waiting for delalloc to send it down.
|
|
|
|
|
* If we find a nice big extent or delalloc range for the bytes in the
|
|
|
|
|
* file you want to defrag, we return 0 to let you know to skip this
|
|
|
|
|
* part of the file
|
|
|
|
|
*/
|
|
|
|
|
static int check_defrag_in_cache(struct inode *inode, u64 offset, int thresh)
|
|
|
|
|
{
|
|
|
|
|
struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
|
|
|
|
|
struct extent_map *em = NULL;
|
|
|
|
|
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
|
|
|
|
|
u64 end;
|
|
|
|
|
|
|
|
|
|
read_lock(&em_tree->lock);
|
|
|
|
|
em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
|
|
|
|
|
read_unlock(&em_tree->lock);
|
|
|
|
|
|
|
|
|
|
if (em) {
|
|
|
|
|
end = extent_map_end(em);
|
|
|
|
|
free_extent_map(em);
|
|
|
|
|
if (end - offset > thresh)
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
/* if we already have a nice delalloc here, just stop */
|
|
|
|
|
thresh /= 2;
|
|
|
|
|
end = count_range_bits(io_tree, &offset, offset + thresh,
|
|
|
|
|
thresh, EXTENT_DELALLOC, 1);
|
|
|
|
|
if (end >= thresh)
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* helper function to walk through a file and find extents
|
|
|
|
|
* newer than a specific transid, and smaller than thresh.
|
|
|
|
|
*
|
|
|
|
|
* This is used by the defragging code to find new and small
|
|
|
|
|
* extents
|
|
|
|
|
*/
|
|
|
|
|
static int find_new_extents(struct btrfs_root *root,
|
|
|
|
|
struct inode *inode, u64 newer_than,
|
|
|
|
|
u64 *off, int thresh)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_path *path;
|
|
|
|
|
struct btrfs_key min_key;
|
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
struct btrfs_file_extent_item *extent;
|
|
|
|
|
int type;
|
|
|
|
|
int ret;
|
2011-05-31 21:08:14 +04:00
|
|
|
u64 ino = btrfs_ino(inode);
|
2011-05-24 23:35:30 +04:00
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
if (!path)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2011-05-31 21:08:14 +04:00
|
|
|
min_key.objectid = ino;
|
2011-05-24 23:35:30 +04:00
|
|
|
min_key.type = BTRFS_EXTENT_DATA_KEY;
|
|
|
|
|
min_key.offset = *off;
|
|
|
|
|
|
2013-10-31 09:03:04 +04:00
|
|
|
while (1) {
|
Btrfs: less fs tree lock contention when using autodefrag
When finding new extents during an autodefrag, don't do so many fs tree
lookups to find an extent with a size smaller then the target treshold.
Instead, after each fs tree forward search immediately unlock upper
levels and process the entire leaf while holding a read lock on the leaf,
since our leaf processing is very fast.
This reduces lock contention, allowing for higher concurrency when other
tasks want to write/update items related to other inodes in the fs tree,
as we're not holding read locks on upper tree levels while processing the
leaf and we do less tree searches.
Test:
sysbench --test=fileio --file-num=512 --file-total-size=16G \
--file-test-mode=rndrw --num-threads=32 --file-block-size=32768 \
--file-rw-ratio=3 --file-io-mode=sync --max-time=1800 \
--max-requests=10000000000 [prepare|run]
(fileystem mounted with -o autodefrag, averages of 5 runs)
Before this change: 58.852Mb/sec throughtput, read 77.589Gb, written 25.863Gb
After this change: 63.034Mb/sec throughtput, read 83.102Gb, written 27.701Gb
Test machine: quad core intel i5-3570K, 32Gb of RAM, SSD.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-03-12 05:28:24 +04:00
|
|
|
path->keep_locks = 1;
|
2013-10-01 19:13:42 +04:00
|
|
|
ret = btrfs_search_forward(root, &min_key, path, newer_than);
|
2011-05-24 23:35:30 +04:00
|
|
|
if (ret != 0)
|
|
|
|
|
goto none;
|
Btrfs: less fs tree lock contention when using autodefrag
When finding new extents during an autodefrag, don't do so many fs tree
lookups to find an extent with a size smaller then the target treshold.
Instead, after each fs tree forward search immediately unlock upper
levels and process the entire leaf while holding a read lock on the leaf,
since our leaf processing is very fast.
This reduces lock contention, allowing for higher concurrency when other
tasks want to write/update items related to other inodes in the fs tree,
as we're not holding read locks on upper tree levels while processing the
leaf and we do less tree searches.
Test:
sysbench --test=fileio --file-num=512 --file-total-size=16G \
--file-test-mode=rndrw --num-threads=32 --file-block-size=32768 \
--file-rw-ratio=3 --file-io-mode=sync --max-time=1800 \
--max-requests=10000000000 [prepare|run]
(fileystem mounted with -o autodefrag, averages of 5 runs)
Before this change: 58.852Mb/sec throughtput, read 77.589Gb, written 25.863Gb
After this change: 63.034Mb/sec throughtput, read 83.102Gb, written 27.701Gb
Test machine: quad core intel i5-3570K, 32Gb of RAM, SSD.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-03-12 05:28:24 +04:00
|
|
|
path->keep_locks = 0;
|
|
|
|
|
btrfs_unlock_up_safe(path, 1);
|
|
|
|
|
process_slot:
|
2011-05-31 21:08:14 +04:00
|
|
|
if (min_key.objectid != ino)
|
2011-05-24 23:35:30 +04:00
|
|
|
goto none;
|
|
|
|
|
if (min_key.type != BTRFS_EXTENT_DATA_KEY)
|
|
|
|
|
goto none;
|
|
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
extent = btrfs_item_ptr(leaf, path->slots[0],
|
|
|
|
|
struct btrfs_file_extent_item);
|
|
|
|
|
|
|
|
|
|
type = btrfs_file_extent_type(leaf, extent);
|
|
|
|
|
if (type == BTRFS_FILE_EXTENT_REG &&
|
|
|
|
|
btrfs_file_extent_num_bytes(leaf, extent) < thresh &&
|
|
|
|
|
check_defrag_in_cache(inode, min_key.offset, thresh)) {
|
|
|
|
|
*off = min_key.offset;
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
Btrfs: less fs tree lock contention when using autodefrag
When finding new extents during an autodefrag, don't do so many fs tree
lookups to find an extent with a size smaller then the target treshold.
Instead, after each fs tree forward search immediately unlock upper
levels and process the entire leaf while holding a read lock on the leaf,
since our leaf processing is very fast.
This reduces lock contention, allowing for higher concurrency when other
tasks want to write/update items related to other inodes in the fs tree,
as we're not holding read locks on upper tree levels while processing the
leaf and we do less tree searches.
Test:
sysbench --test=fileio --file-num=512 --file-total-size=16G \
--file-test-mode=rndrw --num-threads=32 --file-block-size=32768 \
--file-rw-ratio=3 --file-io-mode=sync --max-time=1800 \
--max-requests=10000000000 [prepare|run]
(fileystem mounted with -o autodefrag, averages of 5 runs)
Before this change: 58.852Mb/sec throughtput, read 77.589Gb, written 25.863Gb
After this change: 63.034Mb/sec throughtput, read 83.102Gb, written 27.701Gb
Test machine: quad core intel i5-3570K, 32Gb of RAM, SSD.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-03-12 05:28:24 +04:00
|
|
|
path->slots[0]++;
|
|
|
|
|
if (path->slots[0] < btrfs_header_nritems(leaf)) {
|
|
|
|
|
btrfs_item_key_to_cpu(leaf, &min_key, path->slots[0]);
|
|
|
|
|
goto process_slot;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
if (min_key.offset == (u64)-1)
|
|
|
|
|
goto none;
|
|
|
|
|
|
|
|
|
|
min_key.offset++;
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
}
|
|
|
|
|
none:
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-11 12:03:35 +04:00
|
|
|
static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start)
|
2012-03-29 17:57:45 +04:00
|
|
|
{
|
|
|
|
|
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
|
2012-06-11 12:03:35 +04:00
|
|
|
struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
|
|
|
|
|
struct extent_map *em;
|
|
|
|
|
u64 len = PAGE_CACHE_SIZE;
|
2012-03-29 17:57:45 +04:00
|
|
|
|
2012-06-11 12:03:35 +04:00
|
|
|
/*
|
|
|
|
|
* hopefully we have this extent in the tree already, try without
|
|
|
|
|
* the full extent lock
|
|
|
|
|
*/
|
2012-03-29 17:57:45 +04:00
|
|
|
read_lock(&em_tree->lock);
|
2012-06-11 12:03:35 +04:00
|
|
|
em = lookup_extent_mapping(em_tree, start, len);
|
2012-03-29 17:57:45 +04:00
|
|
|
read_unlock(&em_tree->lock);
|
|
|
|
|
|
2012-06-11 12:03:35 +04:00
|
|
|
if (!em) {
|
2014-03-11 17:56:15 +04:00
|
|
|
struct extent_state *cached = NULL;
|
|
|
|
|
u64 end = start + len - 1;
|
|
|
|
|
|
2012-06-11 12:03:35 +04:00
|
|
|
/* get the big lock and read metadata off disk */
|
2014-03-11 17:56:15 +04:00
|
|
|
lock_extent_bits(io_tree, start, end, 0, &cached);
|
2012-06-11 12:03:35 +04:00
|
|
|
em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
|
2014-03-11 17:56:15 +04:00
|
|
|
unlock_extent_cached(io_tree, start, end, &cached, GFP_NOFS);
|
2012-06-11 12:03:35 +04:00
|
|
|
|
|
|
|
|
if (IS_ERR(em))
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return em;
|
|
|
|
|
}
|
2012-03-29 17:57:45 +04:00
|
|
|
|
2012-06-11 12:03:35 +04:00
|
|
|
static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em)
|
|
|
|
|
{
|
|
|
|
|
struct extent_map *next;
|
|
|
|
|
bool ret = true;
|
|
|
|
|
|
|
|
|
|
/* this is the last extent */
|
|
|
|
|
if (em->start + em->len >= i_size_read(inode))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
next = defrag_lookup_extent(inode, em->start + em->len);
|
Btrfs: make defrag not fragment files when using prealloc extents
When using prealloc extents, a file defragment operation may actually
fragment the file and increase the amount of data space used by the file.
This change fixes that behaviour.
Example:
$ mkfs.btrfs -f /dev/sdb3
$ mount /dev/sdb3 /mnt
$ cd /mnt
$ xfs_io -f -c 'falloc 0 1048576' foobar && sync
$ xfs_io -c 'pwrite -S 0xff -b 100000 5000 100000' foobar
$ xfs_io -c 'pwrite -S 0xac -b 100000 200000 100000' foobar
$ xfs_io -c 'pwrite -S 0xe1 -b 100000 900000 100000' foobar && sync
Before defragmenting the file:
$ btrfs filesystem df /mnt
Data, single: total=8.00MiB, used=1.25MiB
System, DUP: total=8.00MiB, used=16.00KiB
System, single: total=4.00MiB, used=0.00
Metadata, DUP: total=1.00GiB, used=112.00KiB
Metadata, single: total=8.00MiB, used=0.00
$ btrfs-debug-tree /dev/sdb3
(...)
item 6 key (257 EXTENT_DATA 0) itemoff 15810 itemsize 53
prealloc data disk byte 12845056 nr 1048576
prealloc data offset 0 nr 4096
item 7 key (257 EXTENT_DATA 4096) itemoff 15757 itemsize 53
extent data disk byte 12845056 nr 1048576
extent data offset 4096 nr 102400 ram 1048576
extent compression 0
item 8 key (257 EXTENT_DATA 106496) itemoff 15704 itemsize 53
prealloc data disk byte 12845056 nr 1048576
prealloc data offset 106496 nr 90112
item 9 key (257 EXTENT_DATA 196608) itemoff 15651 itemsize 53
extent data disk byte 12845056 nr 1048576
extent data offset 196608 nr 106496 ram 1048576
extent compression 0
item 10 key (257 EXTENT_DATA 303104) itemoff 15598 itemsize 53
prealloc data disk byte 12845056 nr 1048576
prealloc data offset 303104 nr 593920
item 11 key (257 EXTENT_DATA 897024) itemoff 15545 itemsize 53
extent data disk byte 12845056 nr 1048576
extent data offset 897024 nr 106496 ram 1048576
extent compression 0
item 12 key (257 EXTENT_DATA 1003520) itemoff 15492 itemsize 53
prealloc data disk byte 12845056 nr 1048576
prealloc data offset 1003520 nr 45056
(...)
Now defragmenting the file results in more data space used than before:
$ btrfs filesystem defragment -f foobar && sync
$ btrfs filesystem df /mnt
Data, single: total=8.00MiB, used=1.55MiB
System, DUP: total=8.00MiB, used=16.00KiB
System, single: total=4.00MiB, used=0.00
Metadata, DUP: total=1.00GiB, used=112.00KiB
Metadata, single: total=8.00MiB, used=0.00
And the corresponding file extent items are now no longer perfectly sequential
as before, and we're now needlessly using more space from data block groups:
$ btrfs-debug-tree /dev/sdb3
(...)
item 6 key (257 EXTENT_DATA 0) itemoff 15810 itemsize 53
extent data disk byte 12845056 nr 1048576
extent data offset 0 nr 4096 ram 1048576
extent compression 0
item 7 key (257 EXTENT_DATA 4096) itemoff 15757 itemsize 53
extent data disk byte 13893632 nr 102400
extent data offset 0 nr 102400 ram 102400
extent compression 0
item 8 key (257 EXTENT_DATA 106496) itemoff 15704 itemsize 53
extent data disk byte 12845056 nr 1048576
extent data offset 106496 nr 90112 ram 1048576
extent compression 0
item 9 key (257 EXTENT_DATA 196608) itemoff 15651 itemsize 53
extent data disk byte 13996032 nr 106496
extent data offset 0 nr 106496 ram 106496
extent compression 0
item 10 key (257 EXTENT_DATA 303104) itemoff 15598 itemsize 53
prealloc data disk byte 12845056 nr 1048576
prealloc data offset 303104 nr 593920
item 11 key (257 EXTENT_DATA 897024) itemoff 15545 itemsize 53
extent data disk byte 14102528 nr 106496
extent data offset 0 nr 106496 ram 106496
extent compression 0
item 12 key (257 EXTENT_DATA 1003520) itemoff 15492 itemsize 53
extent data disk byte 12845056 nr 1048576
extent data offset 1003520 nr 45056 ram 1048576
extent compression 0
(...)
With this change, the above example will no longer cause allocation of new data
space nor change the sequentiality of the file extents, that is, defragment will
be effectless, leaving all extent items pointing to the extent starting at disk
byte 12845056.
In a 20Gb filesystem I had, mounted with the autodefrag option and 20 files of
400Mb each, initially consisting of a single prealloc extent of 400Mb, having
random writes happening at a low rate, lead to a total of over ~17Gb of data
space used, not far from eventually reaching an ENOSPC state.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-03-01 14:57:03 +04:00
|
|
|
if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE ||
|
|
|
|
|
(em->block_start + em->block_len == next->block_start))
|
2012-06-11 12:03:35 +04:00
|
|
|
ret = false;
|
|
|
|
|
|
|
|
|
|
free_extent_map(next);
|
2012-03-29 17:57:45 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-11 12:03:35 +04:00
|
|
|
static int should_defrag_range(struct inode *inode, u64 start, int thresh,
|
2012-06-20 05:08:32 +04:00
|
|
|
u64 *last_len, u64 *skip, u64 *defrag_end,
|
|
|
|
|
int compress)
|
2010-03-10 18:52:59 +03:00
|
|
|
{
|
2012-06-11 12:03:35 +04:00
|
|
|
struct extent_map *em;
|
2010-03-10 18:52:59 +03:00
|
|
|
int ret = 1;
|
2012-06-11 12:03:35 +04:00
|
|
|
bool next_mergeable = true;
|
2010-03-10 18:52:59 +03:00
|
|
|
|
|
|
|
|
/*
|
2011-09-02 11:57:07 +04:00
|
|
|
* make sure that once we start defragging an extent, we keep on
|
2010-03-10 18:52:59 +03:00
|
|
|
* defragging it
|
|
|
|
|
*/
|
|
|
|
|
if (start < *defrag_end)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
*skip = 0;
|
|
|
|
|
|
2012-06-11 12:03:35 +04:00
|
|
|
em = defrag_lookup_extent(inode, start);
|
|
|
|
|
if (!em)
|
|
|
|
|
return 0;
|
2010-03-10 18:52:59 +03:00
|
|
|
|
|
|
|
|
/* this will cover holes, and inline extents */
|
2012-03-29 17:57:45 +04:00
|
|
|
if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
|
2010-03-10 18:52:59 +03:00
|
|
|
ret = 0;
|
2012-03-29 17:57:45 +04:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-11 12:03:35 +04:00
|
|
|
next_mergeable = defrag_check_next_extent(inode, em);
|
2010-03-10 18:52:59 +03:00
|
|
|
|
|
|
|
|
/*
|
2012-06-11 12:03:35 +04:00
|
|
|
* we hit a real extent, if it is big or the next extent is not a
|
|
|
|
|
* real extent, don't bother defragging it
|
2010-03-10 18:52:59 +03:00
|
|
|
*/
|
2012-06-20 05:08:32 +04:00
|
|
|
if (!compress && (*last_len == 0 || *last_len >= thresh) &&
|
2012-06-11 12:03:35 +04:00
|
|
|
(em->len >= thresh || !next_mergeable))
|
2010-03-10 18:52:59 +03:00
|
|
|
ret = 0;
|
2012-03-29 17:57:45 +04:00
|
|
|
out:
|
2010-03-10 18:52:59 +03:00
|
|
|
/*
|
|
|
|
|
* last_len ends up being a counter of how many bytes we've defragged.
|
|
|
|
|
* every time we choose not to defrag an extent, we reset *last_len
|
|
|
|
|
* so that the next tiny extent will force a defrag.
|
|
|
|
|
*
|
|
|
|
|
* The end result of this is that tiny extents before a single big
|
|
|
|
|
* extent will force at least part of that big extent to be defragged.
|
|
|
|
|
*/
|
|
|
|
|
if (ret) {
|
|
|
|
|
*defrag_end = extent_map_end(em);
|
|
|
|
|
} else {
|
|
|
|
|
*last_len = 0;
|
|
|
|
|
*skip = extent_map_end(em);
|
|
|
|
|
*defrag_end = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
free_extent_map(em);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
/*
|
|
|
|
|
* it doesn't do much good to defrag one or two pages
|
|
|
|
|
* at a time. This pulls in a nice chunk of pages
|
|
|
|
|
* to COW and defrag.
|
|
|
|
|
*
|
|
|
|
|
* It also makes sure the delalloc code has enough
|
|
|
|
|
* dirty data to avoid making new small extents as part
|
|
|
|
|
* of the defrag
|
|
|
|
|
*
|
|
|
|
|
* It's a good idea to start RA on this range
|
|
|
|
|
* before calling this.
|
|
|
|
|
*/
|
|
|
|
|
static int cluster_pages_for_defrag(struct inode *inode,
|
|
|
|
|
struct page **pages,
|
|
|
|
|
unsigned long start_index,
|
2014-01-21 23:18:29 +04:00
|
|
|
unsigned long num_pages)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
2011-05-24 23:35:30 +04:00
|
|
|
unsigned long file_end;
|
|
|
|
|
u64 isize = i_size_read(inode);
|
|
|
|
|
u64 page_start;
|
|
|
|
|
u64 page_end;
|
2012-03-29 17:57:44 +04:00
|
|
|
u64 page_cnt;
|
2011-05-24 23:35:30 +04:00
|
|
|
int ret;
|
|
|
|
|
int i;
|
|
|
|
|
int i_done;
|
2008-07-24 19:57:52 +04:00
|
|
|
struct btrfs_ordered_extent *ordered;
|
2011-05-24 23:35:30 +04:00
|
|
|
struct extent_state *cached_state = NULL;
|
2012-02-16 11:01:24 +04:00
|
|
|
struct extent_io_tree *tree;
|
2011-09-21 23:05:58 +04:00
|
|
|
gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
|
2011-05-24 23:35:30 +04:00
|
|
|
|
|
|
|
|
file_end = (isize - 1) >> PAGE_CACHE_SHIFT;
|
2012-03-29 17:57:44 +04:00
|
|
|
if (!isize || start_index > file_end)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
page_cnt = min_t(u64, (u64)num_pages, (u64)file_end - start_index + 1);
|
2011-05-24 23:35:30 +04:00
|
|
|
|
|
|
|
|
ret = btrfs_delalloc_reserve_space(inode,
|
2012-03-29 17:57:44 +04:00
|
|
|
page_cnt << PAGE_CACHE_SHIFT);
|
2011-05-24 23:35:30 +04:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
i_done = 0;
|
2012-02-16 11:01:24 +04:00
|
|
|
tree = &BTRFS_I(inode)->io_tree;
|
2011-05-24 23:35:30 +04:00
|
|
|
|
|
|
|
|
/* step one, lock all the pages */
|
2012-03-29 17:57:44 +04:00
|
|
|
for (i = 0; i < page_cnt; i++) {
|
2011-05-24 23:35:30 +04:00
|
|
|
struct page *page;
|
2012-02-16 11:01:24 +04:00
|
|
|
again:
|
2011-07-11 18:47:06 +04:00
|
|
|
page = find_or_create_page(inode->i_mapping,
|
2012-02-16 11:01:24 +04:00
|
|
|
start_index + i, mask);
|
2011-05-24 23:35:30 +04:00
|
|
|
if (!page)
|
|
|
|
|
break;
|
|
|
|
|
|
2012-02-16 11:01:24 +04:00
|
|
|
page_start = page_offset(page);
|
|
|
|
|
page_end = page_start + PAGE_CACHE_SIZE - 1;
|
|
|
|
|
while (1) {
|
2014-03-11 17:56:15 +04:00
|
|
|
lock_extent_bits(tree, page_start, page_end,
|
|
|
|
|
0, &cached_state);
|
2012-02-16 11:01:24 +04:00
|
|
|
ordered = btrfs_lookup_ordered_extent(inode,
|
|
|
|
|
page_start);
|
2014-03-11 17:56:15 +04:00
|
|
|
unlock_extent_cached(tree, page_start, page_end,
|
|
|
|
|
&cached_state, GFP_NOFS);
|
2012-02-16 11:01:24 +04:00
|
|
|
if (!ordered)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
btrfs_start_ordered_extent(inode, ordered, 1);
|
|
|
|
|
btrfs_put_ordered_extent(ordered);
|
|
|
|
|
lock_page(page);
|
2012-03-29 17:57:44 +04:00
|
|
|
/*
|
|
|
|
|
* we unlocked the page above, so we need check if
|
|
|
|
|
* it was released or not.
|
|
|
|
|
*/
|
|
|
|
|
if (page->mapping != inode->i_mapping) {
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
page_cache_release(page);
|
|
|
|
|
goto again;
|
|
|
|
|
}
|
2012-02-16 11:01:24 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
if (!PageUptodate(page)) {
|
|
|
|
|
btrfs_readpage(NULL, page);
|
|
|
|
|
lock_page(page);
|
|
|
|
|
if (!PageUptodate(page)) {
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
page_cache_release(page);
|
|
|
|
|
ret = -EIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-02-16 11:01:24 +04:00
|
|
|
|
|
|
|
|
if (page->mapping != inode->i_mapping) {
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
page_cache_release(page);
|
|
|
|
|
goto again;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
pages[i] = page;
|
|
|
|
|
i_done++;
|
|
|
|
|
}
|
|
|
|
|
if (!i_done || ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
if (!(inode->i_sb->s_flags & MS_ACTIVE))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* so now we have a nice long stream of locked
|
|
|
|
|
* and up to date pages, lets wait on them
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < i_done; i++)
|
|
|
|
|
wait_on_page_writeback(pages[i]);
|
|
|
|
|
|
|
|
|
|
page_start = page_offset(pages[0]);
|
|
|
|
|
page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE;
|
|
|
|
|
|
|
|
|
|
lock_extent_bits(&BTRFS_I(inode)->io_tree,
|
2012-03-01 17:57:19 +04:00
|
|
|
page_start, page_end - 1, 0, &cached_state);
|
2011-05-24 23:35:30 +04:00
|
|
|
clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
|
|
|
|
|
page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
|
2012-09-06 05:10:51 +04:00
|
|
|
EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0,
|
|
|
|
|
&cached_state, GFP_NOFS);
|
2011-05-24 23:35:30 +04:00
|
|
|
|
2012-03-29 17:57:44 +04:00
|
|
|
if (i_done != page_cnt) {
|
2011-07-15 19:16:44 +04:00
|
|
|
spin_lock(&BTRFS_I(inode)->lock);
|
|
|
|
|
BTRFS_I(inode)->outstanding_extents++;
|
|
|
|
|
spin_unlock(&BTRFS_I(inode)->lock);
|
2011-05-24 23:35:30 +04:00
|
|
|
btrfs_delalloc_release_space(inode,
|
2012-03-29 17:57:44 +04:00
|
|
|
(page_cnt - i_done) << PAGE_CACHE_SHIFT);
|
2011-05-24 23:35:30 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-09-06 05:10:51 +04:00
|
|
|
set_extent_defrag(&BTRFS_I(inode)->io_tree, page_start, page_end - 1,
|
|
|
|
|
&cached_state, GFP_NOFS);
|
2011-05-24 23:35:30 +04:00
|
|
|
|
|
|
|
|
unlock_extent_cached(&BTRFS_I(inode)->io_tree,
|
|
|
|
|
page_start, page_end - 1, &cached_state,
|
|
|
|
|
GFP_NOFS);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < i_done; i++) {
|
|
|
|
|
clear_page_dirty_for_io(pages[i]);
|
|
|
|
|
ClearPageChecked(pages[i]);
|
|
|
|
|
set_page_extent_mapped(pages[i]);
|
|
|
|
|
set_page_dirty(pages[i]);
|
|
|
|
|
unlock_page(pages[i]);
|
|
|
|
|
page_cache_release(pages[i]);
|
|
|
|
|
}
|
|
|
|
|
return i_done;
|
|
|
|
|
out:
|
|
|
|
|
for (i = 0; i < i_done; i++) {
|
|
|
|
|
unlock_page(pages[i]);
|
|
|
|
|
page_cache_release(pages[i]);
|
|
|
|
|
}
|
2012-03-29 17:57:44 +04:00
|
|
|
btrfs_delalloc_release_space(inode, page_cnt << PAGE_CACHE_SHIFT);
|
2011-05-24 23:35:30 +04:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int btrfs_defrag_file(struct inode *inode, struct file *file,
|
|
|
|
|
struct btrfs_ioctl_defrag_range_args *range,
|
|
|
|
|
u64 newer_than, unsigned long max_to_defrag)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
struct file_ra_state *ra = NULL;
|
2008-06-12 05:53:53 +04:00
|
|
|
unsigned long last_index;
|
2011-09-02 11:56:39 +04:00
|
|
|
u64 isize = i_size_read(inode);
|
2010-03-10 18:52:59 +03:00
|
|
|
u64 last_len = 0;
|
|
|
|
|
u64 skip = 0;
|
|
|
|
|
u64 defrag_end = 0;
|
2011-05-24 23:35:30 +04:00
|
|
|
u64 newer_off = range->start;
|
2008-06-12 05:53:53 +04:00
|
|
|
unsigned long i;
|
2011-09-02 11:57:07 +04:00
|
|
|
unsigned long ra_index = 0;
|
2008-06-12 05:53:53 +04:00
|
|
|
int ret;
|
2011-05-24 23:35:30 +04:00
|
|
|
int defrag_count = 0;
|
2010-10-25 11:12:50 +04:00
|
|
|
int compress_type = BTRFS_COMPRESS_ZLIB;
|
2011-05-24 23:35:30 +04:00
|
|
|
int extent_thresh = range->extent_thresh;
|
2014-01-21 23:18:29 +04:00
|
|
|
unsigned long max_cluster = (256 * 1024) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
unsigned long cluster = max_cluster;
|
2011-05-24 23:35:30 +04:00
|
|
|
u64 new_align = ~((u64)128 * 1024 - 1);
|
|
|
|
|
struct page **pages = NULL;
|
|
|
|
|
|
2013-04-16 13:20:28 +04:00
|
|
|
if (isize == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (range->start >= isize)
|
|
|
|
|
return -EINVAL;
|
2010-10-25 11:12:50 +04:00
|
|
|
|
|
|
|
|
if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) {
|
|
|
|
|
if (range->compress_type > BTRFS_COMPRESS_TYPES)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (range->compress_type)
|
|
|
|
|
compress_type = range->compress_type;
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2013-04-16 13:20:28 +04:00
|
|
|
if (extent_thresh == 0)
|
|
|
|
|
extent_thresh = 256 * 1024;
|
2010-03-10 18:52:59 +03:00
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
/*
|
|
|
|
|
* if we were not given a file, allocate a readahead
|
|
|
|
|
* context
|
|
|
|
|
*/
|
|
|
|
|
if (!file) {
|
|
|
|
|
ra = kzalloc(sizeof(*ra), GFP_NOFS);
|
|
|
|
|
if (!ra)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
file_ra_state_init(ra, inode->i_mapping);
|
|
|
|
|
} else {
|
|
|
|
|
ra = &file->f_ra;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-31 09:02:18 +04:00
|
|
|
pages = kmalloc_array(max_cluster, sizeof(struct page *),
|
2011-05-24 23:35:30 +04:00
|
|
|
GFP_NOFS);
|
|
|
|
|
if (!pages) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out_ra;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* find the last page to defrag */
|
2010-03-11 17:42:04 +03:00
|
|
|
if (range->start + range->len > range->start) {
|
2011-09-02 11:56:39 +04:00
|
|
|
last_index = min_t(u64, isize - 1,
|
2010-03-11 17:42:04 +03:00
|
|
|
range->start + range->len - 1) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
} else {
|
2011-09-02 11:56:39 +04:00
|
|
|
last_index = (isize - 1) >> PAGE_CACHE_SHIFT;
|
2010-03-11 17:42:04 +03:00
|
|
|
}
|
|
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
if (newer_than) {
|
|
|
|
|
ret = find_new_extents(root, inode, newer_than,
|
|
|
|
|
&newer_off, 64 * 1024);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
range->start = newer_off;
|
|
|
|
|
/*
|
|
|
|
|
* we always align our defrag to help keep
|
|
|
|
|
* the extents in the file evenly spaced
|
|
|
|
|
*/
|
|
|
|
|
i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
} else
|
|
|
|
|
goto out_ra;
|
|
|
|
|
} else {
|
|
|
|
|
i = range->start >> PAGE_CACHE_SHIFT;
|
|
|
|
|
}
|
|
|
|
|
if (!max_to_defrag)
|
2012-01-27 00:01:12 +04:00
|
|
|
max_to_defrag = last_index + 1;
|
2011-05-24 23:35:30 +04:00
|
|
|
|
2011-10-10 23:43:34 +04:00
|
|
|
/*
|
|
|
|
|
* make writeback starts from i, so the defrag range can be
|
|
|
|
|
* written sequentially.
|
|
|
|
|
*/
|
|
|
|
|
if (i < inode->i_mapping->writeback_index)
|
|
|
|
|
inode->i_mapping->writeback_index = i;
|
|
|
|
|
|
2011-10-11 19:41:40 +04:00
|
|
|
while (i <= last_index && defrag_count < max_to_defrag &&
|
|
|
|
|
(i < (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
|
|
|
|
|
PAGE_CACHE_SHIFT)) {
|
2011-05-24 23:35:30 +04:00
|
|
|
/*
|
|
|
|
|
* make sure we stop running if someone unmounts
|
|
|
|
|
* the FS
|
|
|
|
|
*/
|
|
|
|
|
if (!(inode->i_sb->s_flags & MS_ACTIVE))
|
|
|
|
|
break;
|
|
|
|
|
|
2013-02-10 03:38:06 +04:00
|
|
|
if (btrfs_defrag_cancelled(root->fs_info)) {
|
2013-12-20 20:37:06 +04:00
|
|
|
printk(KERN_DEBUG "BTRFS: defrag_file cancelled\n");
|
2013-02-10 03:38:06 +04:00
|
|
|
ret = -EAGAIN;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-29 17:57:45 +04:00
|
|
|
if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
|
2012-06-11 12:03:35 +04:00
|
|
|
extent_thresh, &last_len, &skip,
|
2012-06-20 05:08:32 +04:00
|
|
|
&defrag_end, range->flags &
|
|
|
|
|
BTRFS_DEFRAG_RANGE_COMPRESS)) {
|
2010-03-10 18:52:59 +03:00
|
|
|
unsigned long next;
|
|
|
|
|
/*
|
|
|
|
|
* the should_defrag function tells us how much to skip
|
|
|
|
|
* bump our counter by the suggested amount
|
|
|
|
|
*/
|
|
|
|
|
next = (skip + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
i = max(i + 1, next);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2011-09-02 11:57:07 +04:00
|
|
|
|
|
|
|
|
if (!newer_than) {
|
|
|
|
|
cluster = (PAGE_CACHE_ALIGN(defrag_end) >>
|
|
|
|
|
PAGE_CACHE_SHIFT) - i;
|
|
|
|
|
cluster = min(cluster, max_cluster);
|
|
|
|
|
} else {
|
|
|
|
|
cluster = max_cluster;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (i + cluster > ra_index) {
|
|
|
|
|
ra_index = max(i, ra_index);
|
|
|
|
|
btrfs_force_ra(inode->i_mapping, ra, file, ra_index,
|
|
|
|
|
cluster);
|
|
|
|
|
ra_index += max_cluster;
|
|
|
|
|
}
|
2010-03-10 18:52:59 +03:00
|
|
|
|
2012-03-29 17:57:44 +04:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2013-08-16 18:23:33 +04:00
|
|
|
if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)
|
|
|
|
|
BTRFS_I(inode)->force_compress = compress_type;
|
2011-09-02 11:57:07 +04:00
|
|
|
ret = cluster_pages_for_defrag(inode, pages, i, cluster);
|
2012-03-29 17:57:44 +04:00
|
|
|
if (ret < 0) {
|
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
2011-05-24 23:35:30 +04:00
|
|
|
goto out_ra;
|
2012-03-29 17:57:44 +04:00
|
|
|
}
|
2011-05-24 23:35:30 +04:00
|
|
|
|
|
|
|
|
defrag_count += ret;
|
2012-12-12 04:00:21 +04:00
|
|
|
balance_dirty_pages_ratelimited(inode->i_mapping);
|
2012-03-29 17:57:44 +04:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2011-05-24 23:35:30 +04:00
|
|
|
|
|
|
|
|
if (newer_than) {
|
|
|
|
|
if (newer_off == (u64)-1)
|
|
|
|
|
break;
|
|
|
|
|
|
2012-03-29 17:57:45 +04:00
|
|
|
if (ret > 0)
|
|
|
|
|
i += ret;
|
|
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
newer_off = max(newer_off + 1,
|
|
|
|
|
(u64)i << PAGE_CACHE_SHIFT);
|
|
|
|
|
|
|
|
|
|
ret = find_new_extents(root, inode,
|
|
|
|
|
newer_than, &newer_off,
|
|
|
|
|
64 * 1024);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
range->start = newer_off;
|
|
|
|
|
i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
} else {
|
|
|
|
|
break;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
2011-05-24 23:35:30 +04:00
|
|
|
} else {
|
2011-09-02 11:57:07 +04:00
|
|
|
if (ret > 0) {
|
2011-09-02 11:56:25 +04:00
|
|
|
i += ret;
|
2011-09-02 11:57:07 +04:00
|
|
|
last_len += ret << PAGE_CACHE_SHIFT;
|
|
|
|
|
} else {
|
2011-09-02 11:56:25 +04:00
|
|
|
i++;
|
2011-09-02 11:57:07 +04:00
|
|
|
last_len = 0;
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-01 14:55:54 +04:00
|
|
|
if ((range->flags & BTRFS_DEFRAG_RANGE_START_IO)) {
|
2010-03-11 17:42:04 +03:00
|
|
|
filemap_flush(inode->i_mapping);
|
2014-03-01 14:55:54 +04:00
|
|
|
if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
|
|
|
|
|
&BTRFS_I(inode)->runtime_flags))
|
|
|
|
|
filemap_flush(inode->i_mapping);
|
|
|
|
|
}
|
2010-03-11 17:42:04 +03:00
|
|
|
|
|
|
|
|
if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
|
|
|
|
|
/* the filemap_flush will queue IO into the worker threads, but
|
|
|
|
|
* we have to make sure the IO is actually started and that
|
|
|
|
|
* ordered extents get created before we return
|
|
|
|
|
*/
|
|
|
|
|
atomic_inc(&root->fs_info->async_submit_draining);
|
|
|
|
|
while (atomic_read(&root->fs_info->nr_async_submits) ||
|
|
|
|
|
atomic_read(&root->fs_info->async_delalloc_pages)) {
|
|
|
|
|
wait_event(root->fs_info->async_submit_wait,
|
|
|
|
|
(atomic_read(&root->fs_info->nr_async_submits) == 0 &&
|
|
|
|
|
atomic_read(&root->fs_info->async_delalloc_pages) == 0));
|
|
|
|
|
}
|
|
|
|
|
atomic_dec(&root->fs_info->async_submit_draining);
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-25 11:12:50 +04:00
|
|
|
if (range->compress_type == BTRFS_COMPRESS_LZO) {
|
2012-07-24 21:58:43 +04:00
|
|
|
btrfs_set_fs_incompat(root->fs_info, COMPRESS_LZO);
|
2010-10-25 11:12:50 +04:00
|
|
|
}
|
|
|
|
|
|
2011-09-01 18:33:57 +04:00
|
|
|
ret = defrag_count;
|
2010-03-10 18:52:59 +03:00
|
|
|
|
2011-05-24 23:35:30 +04:00
|
|
|
out_ra:
|
2013-08-16 18:23:33 +04:00
|
|
|
if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) {
|
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
|
|
|
BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE;
|
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
|
}
|
2011-05-24 23:35:30 +04:00
|
|
|
if (!file)
|
|
|
|
|
kfree(ra);
|
|
|
|
|
kfree(pages);
|
2010-03-10 18:52:59 +03:00
|
|
|
return ret;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:43:45 +04:00
|
|
|
static noinline int btrfs_ioctl_resize(struct file *file,
|
2009-09-22 00:00:26 +04:00
|
|
|
void __user *arg)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
|
|
|
|
u64 new_size;
|
|
|
|
|
u64 old_size;
|
|
|
|
|
u64 devid = 1;
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2008-06-12 05:53:53 +04:00
|
|
|
struct btrfs_ioctl_vol_args *vol_args;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
struct btrfs_device *device = NULL;
|
|
|
|
|
char *sizestr;
|
2014-03-31 14:03:25 +04:00
|
|
|
char *retptr;
|
2008-06-12 05:53:53 +04:00
|
|
|
char *devstr = NULL;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int mod = 0;
|
|
|
|
|
|
2009-01-06 00:57:23 +03:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-26 12:43:45 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2012-11-05 20:54:08 +04:00
|
|
|
if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
|
|
|
|
|
1)) {
|
2012-12-21 14:38:50 +04:00
|
|
|
mnt_drop_write_file(file);
|
2013-08-21 07:44:48 +04:00
|
|
|
return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
|
2012-01-17 00:04:47 +04:00
|
|
|
}
|
|
|
|
|
|
2012-11-05 20:54:08 +04:00
|
|
|
mutex_lock(&root->fs_info->volume_mutex);
|
2009-04-08 11:06:54 +04:00
|
|
|
vol_args = memdup_user(arg, sizeof(*vol_args));
|
2012-01-17 00:04:47 +04:00
|
|
|
if (IS_ERR(vol_args)) {
|
|
|
|
|
ret = PTR_ERR(vol_args);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2008-07-24 20:20:14 +04:00
|
|
|
|
|
|
|
|
vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
|
2008-06-12 05:53:53 +04:00
|
|
|
|
|
|
|
|
sizestr = vol_args->name;
|
|
|
|
|
devstr = strchr(sizestr, ':');
|
|
|
|
|
if (devstr) {
|
|
|
|
|
sizestr = devstr + 1;
|
|
|
|
|
*devstr = '\0';
|
|
|
|
|
devstr = vol_args->name;
|
2014-05-13 12:36:08 +04:00
|
|
|
ret = kstrtoull(devstr, 10, &devid);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out_free;
|
2012-12-21 13:21:30 +04:00
|
|
|
if (!devid) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out_free;
|
|
|
|
|
}
|
2013-12-20 20:37:06 +04:00
|
|
|
btrfs_info(root->fs_info, "resizing devid %llu", devid);
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
2012-12-21 13:19:51 +04:00
|
|
|
|
2012-11-05 20:03:39 +04:00
|
|
|
device = btrfs_find_device(root->fs_info, devid, NULL, NULL);
|
2008-06-12 05:53:53 +04:00
|
|
|
if (!device) {
|
2013-12-20 20:37:06 +04:00
|
|
|
btrfs_info(root->fs_info, "resizer unable to find device %llu",
|
2013-08-20 15:20:07 +04:00
|
|
|
devid);
|
2012-12-21 13:21:30 +04:00
|
|
|
ret = -ENODEV;
|
2012-01-17 00:04:47 +04:00
|
|
|
goto out_free;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
2012-12-21 13:19:51 +04:00
|
|
|
|
|
|
|
|
if (!device->writeable) {
|
2013-12-20 20:37:06 +04:00
|
|
|
btrfs_info(root->fs_info,
|
|
|
|
|
"resizer unable to apply on readonly device %llu",
|
2013-08-20 15:20:07 +04:00
|
|
|
devid);
|
2012-12-21 13:21:30 +04:00
|
|
|
ret = -EPERM;
|
2012-06-14 12:23:19 +04:00
|
|
|
goto out_free;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
if (!strcmp(sizestr, "max"))
|
|
|
|
|
new_size = device->bdev->bd_inode->i_size;
|
|
|
|
|
else {
|
|
|
|
|
if (sizestr[0] == '-') {
|
|
|
|
|
mod = -1;
|
|
|
|
|
sizestr++;
|
|
|
|
|
} else if (sizestr[0] == '+') {
|
|
|
|
|
mod = 1;
|
|
|
|
|
sizestr++;
|
|
|
|
|
}
|
2014-03-31 14:03:25 +04:00
|
|
|
new_size = memparse(sizestr, &retptr);
|
|
|
|
|
if (*retptr != '\0' || new_size == 0) {
|
2008-06-12 05:53:53 +04:00
|
|
|
ret = -EINVAL;
|
2012-01-17 00:04:47 +04:00
|
|
|
goto out_free;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-05 21:29:28 +04:00
|
|
|
if (device->is_tgtdev_for_dev_replace) {
|
2012-12-21 13:21:30 +04:00
|
|
|
ret = -EPERM;
|
2012-11-05 21:29:28 +04:00
|
|
|
goto out_free;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
old_size = device->total_bytes;
|
|
|
|
|
|
|
|
|
|
if (mod < 0) {
|
|
|
|
|
if (new_size > old_size) {
|
|
|
|
|
ret = -EINVAL;
|
2012-01-17 00:04:47 +04:00
|
|
|
goto out_free;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
new_size = old_size - new_size;
|
|
|
|
|
} else if (mod > 0) {
|
2013-12-20 11:28:56 +04:00
|
|
|
if (new_size > ULLONG_MAX - old_size) {
|
2014-05-29 05:19:58 +04:00
|
|
|
ret = -ERANGE;
|
2013-12-20 11:28:56 +04:00
|
|
|
goto out_free;
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
new_size = old_size + new_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (new_size < 256 * 1024 * 1024) {
|
|
|
|
|
ret = -EINVAL;
|
2012-01-17 00:04:47 +04:00
|
|
|
goto out_free;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
if (new_size > device->bdev->bd_inode->i_size) {
|
|
|
|
|
ret = -EFBIG;
|
2012-01-17 00:04:47 +04:00
|
|
|
goto out_free;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
do_div(new_size, root->sectorsize);
|
|
|
|
|
new_size *= root->sectorsize;
|
|
|
|
|
|
2013-12-20 20:37:06 +04:00
|
|
|
printk_in_rcu(KERN_INFO "BTRFS: new size for %s is %llu\n",
|
2013-08-20 15:20:07 +04:00
|
|
|
rcu_str_deref(device->name), new_size);
|
2008-06-12 05:53:53 +04:00
|
|
|
|
|
|
|
|
if (new_size > old_size) {
|
2010-05-16 18:48:46 +04:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2011-01-20 09:19:37 +03:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
2012-01-17 00:04:47 +04:00
|
|
|
goto out_free;
|
2011-01-20 09:19:37 +03:00
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
ret = btrfs_grow_device(trans, device, new_size);
|
|
|
|
|
btrfs_commit_transaction(trans, root);
|
2011-11-18 22:55:01 +04:00
|
|
|
} else if (new_size < old_size) {
|
2008-06-12 05:53:53 +04:00
|
|
|
ret = btrfs_shrink_device(device, new_size);
|
2012-10-27 16:06:39 +04:00
|
|
|
} /* equal, nothing need to do */
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2012-01-17 00:04:47 +04:00
|
|
|
out_free:
|
2008-06-12 05:53:53 +04:00
|
|
|
kfree(vol_args);
|
2012-01-17 00:04:47 +04:00
|
|
|
out:
|
|
|
|
|
mutex_unlock(&root->fs_info->volume_mutex);
|
2012-11-05 20:54:08 +04:00
|
|
|
atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
|
2013-01-20 17:57:57 +04:00
|
|
|
mnt_drop_write_file(file);
|
2008-06-12 05:53:53 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-29 23:41:32 +04:00
|
|
|
static noinline int btrfs_ioctl_snap_create_transid(struct file *file,
|
2011-09-14 17:58:21 +04:00
|
|
|
char *name, unsigned long fd, int subvol,
|
|
|
|
|
u64 *transid, bool readonly,
|
2013-02-07 10:02:44 +04:00
|
|
|
struct btrfs_qgroup_inherit *inherit)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
|
|
|
|
int namelen;
|
2008-11-18 05:02:50 +03:00
|
|
|
int ret = 0;
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2012-06-29 13:58:46 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2010-10-29 23:41:32 +04:00
|
|
|
namelen = strlen(name);
|
|
|
|
|
if (strchr(name, '/')) {
|
2008-06-12 05:53:53 +04:00
|
|
|
ret = -EINVAL;
|
2012-06-29 13:58:46 +04:00
|
|
|
goto out_drop_write;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
|
2012-02-21 07:14:55 +04:00
|
|
|
if (name[0] == '.' &&
|
|
|
|
|
(namelen == 1 || (name[1] == '.' && namelen == 2))) {
|
|
|
|
|
ret = -EEXIST;
|
2012-06-29 13:58:46 +04:00
|
|
|
goto out_drop_write;
|
2012-02-21 07:14:55 +04:00
|
|
|
}
|
|
|
|
|
|
2008-11-18 05:02:50 +03:00
|
|
|
if (subvol) {
|
2010-10-29 23:41:32 +04:00
|
|
|
ret = btrfs_mksubvol(&file->f_path, name, namelen,
|
2011-09-14 17:58:21 +04:00
|
|
|
NULL, transid, readonly, inherit);
|
2008-10-09 21:39:39 +04:00
|
|
|
} else {
|
2012-08-28 20:52:22 +04:00
|
|
|
struct fd src = fdget(fd);
|
2008-11-18 05:02:50 +03:00
|
|
|
struct inode *src_inode;
|
2012-08-28 20:52:22 +04:00
|
|
|
if (!src.file) {
|
2008-11-18 05:02:50 +03:00
|
|
|
ret = -EINVAL;
|
2012-06-29 13:58:46 +04:00
|
|
|
goto out_drop_write;
|
2008-11-18 05:02:50 +03:00
|
|
|
}
|
|
|
|
|
|
2013-01-24 02:07:38 +04:00
|
|
|
src_inode = file_inode(src.file);
|
|
|
|
|
if (src_inode->i_sb != file_inode(file)->i_sb) {
|
2013-12-20 20:37:06 +04:00
|
|
|
btrfs_info(BTRFS_I(src_inode)->root->fs_info,
|
|
|
|
|
"Snapshot src from another FS");
|
2014-01-30 11:32:02 +04:00
|
|
|
ret = -EXDEV;
|
2014-01-15 21:15:52 +04:00
|
|
|
} else if (!inode_owner_or_capable(src_inode)) {
|
|
|
|
|
/*
|
|
|
|
|
* Subvolume creation is not restricted, but snapshots
|
|
|
|
|
* are limited to own subvolumes only
|
|
|
|
|
*/
|
|
|
|
|
ret = -EPERM;
|
2012-08-27 05:20:24 +04:00
|
|
|
} else {
|
|
|
|
|
ret = btrfs_mksubvol(&file->f_path, name, namelen,
|
|
|
|
|
BTRFS_I(src_inode)->root,
|
|
|
|
|
transid, readonly, inherit);
|
2008-11-18 05:02:50 +03:00
|
|
|
}
|
2012-08-28 20:52:22 +04:00
|
|
|
fdput(src);
|
2008-10-09 21:39:39 +04:00
|
|
|
}
|
2012-06-29 13:58:46 +04:00
|
|
|
out_drop_write:
|
|
|
|
|
mnt_drop_write_file(file);
|
2008-06-12 05:53:53 +04:00
|
|
|
out:
|
2010-10-29 23:41:32 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline int btrfs_ioctl_snap_create(struct file *file,
|
2010-12-20 10:53:28 +03:00
|
|
|
void __user *arg, int subvol)
|
2010-10-29 23:41:32 +04:00
|
|
|
{
|
2010-12-20 10:53:28 +03:00
|
|
|
struct btrfs_ioctl_vol_args *vol_args;
|
2010-10-29 23:41:32 +04:00
|
|
|
int ret;
|
|
|
|
|
|
2010-12-20 10:53:28 +03:00
|
|
|
vol_args = memdup_user(arg, sizeof(*vol_args));
|
|
|
|
|
if (IS_ERR(vol_args))
|
|
|
|
|
return PTR_ERR(vol_args);
|
|
|
|
|
vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
|
2010-10-29 23:41:32 +04:00
|
|
|
|
2010-12-20 10:53:28 +03:00
|
|
|
ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
|
2010-12-20 11:04:08 +03:00
|
|
|
vol_args->fd, subvol,
|
2011-09-14 17:58:21 +04:00
|
|
|
NULL, false, NULL);
|
2010-12-10 09:41:56 +03:00
|
|
|
|
2010-12-20 10:53:28 +03:00
|
|
|
kfree(vol_args);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2010-12-10 09:41:56 +03:00
|
|
|
|
2010-12-20 10:53:28 +03:00
|
|
|
static noinline int btrfs_ioctl_snap_create_v2(struct file *file,
|
|
|
|
|
void __user *arg, int subvol)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_vol_args_v2 *vol_args;
|
|
|
|
|
int ret;
|
|
|
|
|
u64 transid = 0;
|
|
|
|
|
u64 *ptr = NULL;
|
2010-12-20 11:04:08 +03:00
|
|
|
bool readonly = false;
|
2011-09-14 17:58:21 +04:00
|
|
|
struct btrfs_qgroup_inherit *inherit = NULL;
|
2010-12-10 03:36:28 +03:00
|
|
|
|
2010-12-20 10:53:28 +03:00
|
|
|
vol_args = memdup_user(arg, sizeof(*vol_args));
|
|
|
|
|
if (IS_ERR(vol_args))
|
|
|
|
|
return PTR_ERR(vol_args);
|
|
|
|
|
vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
|
2010-12-10 03:36:28 +03:00
|
|
|
|
2010-12-20 11:04:08 +03:00
|
|
|
if (vol_args->flags &
|
2011-09-14 17:58:21 +04:00
|
|
|
~(BTRFS_SUBVOL_CREATE_ASYNC | BTRFS_SUBVOL_RDONLY |
|
|
|
|
|
BTRFS_SUBVOL_QGROUP_INHERIT)) {
|
2010-12-20 11:04:08 +03:00
|
|
|
ret = -EOPNOTSUPP;
|
2010-12-20 10:53:28 +03:00
|
|
|
goto out;
|
2010-10-29 23:41:32 +04:00
|
|
|
}
|
2010-12-20 10:53:28 +03:00
|
|
|
|
|
|
|
|
if (vol_args->flags & BTRFS_SUBVOL_CREATE_ASYNC)
|
|
|
|
|
ptr = &transid;
|
2010-12-20 11:04:08 +03:00
|
|
|
if (vol_args->flags & BTRFS_SUBVOL_RDONLY)
|
|
|
|
|
readonly = true;
|
2011-09-14 17:58:21 +04:00
|
|
|
if (vol_args->flags & BTRFS_SUBVOL_QGROUP_INHERIT) {
|
|
|
|
|
if (vol_args->size > PAGE_CACHE_SIZE) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
inherit = memdup_user(vol_args->qgroup_inherit, vol_args->size);
|
|
|
|
|
if (IS_ERR(inherit)) {
|
|
|
|
|
ret = PTR_ERR(inherit);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-12-20 10:53:28 +03:00
|
|
|
|
|
|
|
|
ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
|
2011-09-14 17:58:21 +04:00
|
|
|
vol_args->fd, subvol, ptr,
|
2013-02-07 10:02:44 +04:00
|
|
|
readonly, inherit);
|
2010-12-20 10:53:28 +03:00
|
|
|
|
|
|
|
|
if (ret == 0 && ptr &&
|
|
|
|
|
copy_to_user(arg +
|
|
|
|
|
offsetof(struct btrfs_ioctl_vol_args_v2,
|
|
|
|
|
transid), ptr, sizeof(*ptr)))
|
|
|
|
|
ret = -EFAULT;
|
2010-12-10 09:41:56 +03:00
|
|
|
out:
|
2008-06-12 05:53:53 +04:00
|
|
|
kfree(vol_args);
|
2011-09-14 17:58:21 +04:00
|
|
|
kfree(inherit);
|
2008-06-12 05:53:53 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-20 11:30:25 +03:00
|
|
|
static noinline int btrfs_ioctl_subvol_getflags(struct file *file,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2010-12-20 11:30:25 +03:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
u64 flags = 0;
|
|
|
|
|
|
2011-04-20 06:31:50 +04:00
|
|
|
if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID)
|
2010-12-20 11:30:25 +03:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
down_read(&root->fs_info->subvol_sem);
|
|
|
|
|
if (btrfs_root_readonly(root))
|
|
|
|
|
flags |= BTRFS_SUBVOL_RDONLY;
|
|
|
|
|
up_read(&root->fs_info->subvol_sem);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &flags, sizeof(flags)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2010-12-20 11:30:25 +03:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
u64 root_flags;
|
|
|
|
|
u64 flags;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2014-01-16 18:50:22 +04:00
|
|
|
if (!inode_owner_or_capable(inode))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-06-29 13:58:49 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
2010-12-20 11:30:25 +03:00
|
|
|
|
2012-06-29 13:58:49 +04:00
|
|
|
if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out_drop_write;
|
|
|
|
|
}
|
2010-12-20 11:30:25 +03:00
|
|
|
|
2012-06-29 13:58:49 +04:00
|
|
|
if (copy_from_user(&flags, arg, sizeof(flags))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out_drop_write;
|
|
|
|
|
}
|
2010-12-20 11:30:25 +03:00
|
|
|
|
2012-06-29 13:58:49 +04:00
|
|
|
if (flags & BTRFS_SUBVOL_CREATE_ASYNC) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out_drop_write;
|
|
|
|
|
}
|
2010-12-20 11:30:25 +03:00
|
|
|
|
2012-06-29 13:58:49 +04:00
|
|
|
if (flags & ~BTRFS_SUBVOL_RDONLY) {
|
|
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
|
goto out_drop_write;
|
|
|
|
|
}
|
2010-12-20 11:30:25 +03:00
|
|
|
|
|
|
|
|
down_write(&root->fs_info->subvol_sem);
|
|
|
|
|
|
|
|
|
|
/* nothing to do */
|
|
|
|
|
if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root))
|
2012-06-29 13:58:49 +04:00
|
|
|
goto out_drop_sem;
|
2010-12-20 11:30:25 +03:00
|
|
|
|
|
|
|
|
root_flags = btrfs_root_flags(&root->root_item);
|
2013-12-16 20:34:17 +04:00
|
|
|
if (flags & BTRFS_SUBVOL_RDONLY) {
|
2010-12-20 11:30:25 +03:00
|
|
|
btrfs_set_root_flags(&root->root_item,
|
|
|
|
|
root_flags | BTRFS_ROOT_SUBVOL_RDONLY);
|
2013-12-16 20:34:17 +04:00
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* Block RO -> RW transition if this subvolume is involved in
|
|
|
|
|
* send
|
|
|
|
|
*/
|
|
|
|
|
spin_lock(&root->root_item_lock);
|
|
|
|
|
if (root->send_in_progress == 0) {
|
|
|
|
|
btrfs_set_root_flags(&root->root_item,
|
2010-12-20 11:30:25 +03:00
|
|
|
root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY);
|
2013-12-16 20:34:17 +04:00
|
|
|
spin_unlock(&root->root_item_lock);
|
|
|
|
|
} else {
|
|
|
|
|
spin_unlock(&root->root_item_lock);
|
|
|
|
|
btrfs_warn(root->fs_info,
|
|
|
|
|
"Attempt to set subvolume %llu read-write during send",
|
|
|
|
|
root->root_key.objectid);
|
|
|
|
|
ret = -EPERM;
|
|
|
|
|
goto out_drop_sem;
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-12-20 11:30:25 +03:00
|
|
|
|
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out_reset;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-16 09:06:34 +03:00
|
|
|
ret = btrfs_update_root(trans, root->fs_info->tree_root,
|
2010-12-20 11:30:25 +03:00
|
|
|
&root->root_key, &root->root_item);
|
|
|
|
|
|
|
|
|
|
btrfs_commit_transaction(trans, root);
|
|
|
|
|
out_reset:
|
|
|
|
|
if (ret)
|
|
|
|
|
btrfs_set_root_flags(&root->root_item, root_flags);
|
2012-06-29 13:58:49 +04:00
|
|
|
out_drop_sem:
|
2010-12-20 11:30:25 +03:00
|
|
|
up_write(&root->fs_info->subvol_sem);
|
2012-06-29 13:58:49 +04:00
|
|
|
out_drop_write:
|
|
|
|
|
mnt_drop_write_file(file);
|
|
|
|
|
out:
|
2010-12-20 11:30:25 +03:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-22 00:00:26 +04:00
|
|
|
/*
|
|
|
|
|
* helper to check if the subvolume references other subvolumes
|
|
|
|
|
*/
|
|
|
|
|
static noinline int may_destroy_subvol(struct btrfs_root *root)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_path *path;
|
2013-08-12 23:36:44 +04:00
|
|
|
struct btrfs_dir_item *di;
|
2009-09-22 00:00:26 +04:00
|
|
|
struct btrfs_key key;
|
2013-08-12 23:36:44 +04:00
|
|
|
u64 dir_id;
|
2009-09-22 00:00:26 +04:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
if (!path)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2013-08-12 23:36:44 +04:00
|
|
|
/* Make sure this root isn't set as the default subvol */
|
|
|
|
|
dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
|
|
|
|
|
di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root, path,
|
|
|
|
|
dir_id, "default", 7, 0);
|
|
|
|
|
if (di && !IS_ERR(di)) {
|
|
|
|
|
btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);
|
|
|
|
|
if (key.objectid == root->root_key.objectid) {
|
2014-03-11 22:24:18 +04:00
|
|
|
ret = -EPERM;
|
|
|
|
|
btrfs_err(root->fs_info, "deleting default subvolume "
|
|
|
|
|
"%llu is not allowed", key.objectid);
|
2013-08-12 23:36:44 +04:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-22 00:00:26 +04:00
|
|
|
key.objectid = root->root_key.objectid;
|
|
|
|
|
key.type = BTRFS_ROOT_REF_KEY;
|
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
|
|
|
|
|
&key, path, 0, 0);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
BUG_ON(ret == 0);
|
|
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
if (path->slots[0] > 0) {
|
|
|
|
|
path->slots[0]--;
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
|
|
|
|
|
if (key.objectid == root->root_key.objectid &&
|
|
|
|
|
key.type == BTRFS_ROOT_REF_KEY)
|
|
|
|
|
ret = -ENOTEMPTY;
|
|
|
|
|
}
|
|
|
|
|
out:
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-28 23:39:26 +03:00
|
|
|
static noinline int key_in_sk(struct btrfs_key *key,
|
|
|
|
|
struct btrfs_ioctl_search_key *sk)
|
|
|
|
|
{
|
2010-03-18 19:10:08 +03:00
|
|
|
struct btrfs_key test;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
test.objectid = sk->min_objectid;
|
|
|
|
|
test.type = sk->min_type;
|
|
|
|
|
test.offset = sk->min_offset;
|
|
|
|
|
|
|
|
|
|
ret = btrfs_comp_cpu_keys(key, &test);
|
|
|
|
|
if (ret < 0)
|
2010-02-28 23:39:26 +03:00
|
|
|
return 0;
|
2010-03-18 19:10:08 +03:00
|
|
|
|
|
|
|
|
test.objectid = sk->max_objectid;
|
|
|
|
|
test.type = sk->max_type;
|
|
|
|
|
test.offset = sk->max_offset;
|
|
|
|
|
|
|
|
|
|
ret = btrfs_comp_cpu_keys(key, &test);
|
|
|
|
|
if (ret > 0)
|
2010-02-28 23:39:26 +03:00
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline int copy_to_sk(struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
|
|
|
|
struct btrfs_key *key,
|
|
|
|
|
struct btrfs_ioctl_search_key *sk,
|
2014-01-30 19:24:00 +04:00
|
|
|
size_t *buf_size,
|
2014-01-30 19:24:02 +04:00
|
|
|
char __user *ubuf,
|
2010-02-28 23:39:26 +03:00
|
|
|
unsigned long *sk_offset,
|
|
|
|
|
int *num_found)
|
|
|
|
|
{
|
|
|
|
|
u64 found_transid;
|
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
struct btrfs_ioctl_search_header sh;
|
|
|
|
|
unsigned long item_off;
|
|
|
|
|
unsigned long item_len;
|
|
|
|
|
int nritems;
|
|
|
|
|
int i;
|
|
|
|
|
int slot;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
nritems = btrfs_header_nritems(leaf);
|
|
|
|
|
|
|
|
|
|
if (btrfs_header_generation(leaf) > sk->max_transid) {
|
|
|
|
|
i = nritems;
|
|
|
|
|
goto advance_key;
|
|
|
|
|
}
|
|
|
|
|
found_transid = btrfs_header_generation(leaf);
|
|
|
|
|
|
|
|
|
|
for (i = slot; i < nritems; i++) {
|
|
|
|
|
item_off = btrfs_item_ptr_offset(leaf, i);
|
|
|
|
|
item_len = btrfs_item_size_nr(leaf, i);
|
|
|
|
|
|
2013-05-06 21:40:18 +04:00
|
|
|
btrfs_item_key_to_cpu(leaf, key, i);
|
|
|
|
|
if (!key_in_sk(key, sk))
|
|
|
|
|
continue;
|
|
|
|
|
|
2014-01-30 19:24:00 +04:00
|
|
|
if (sizeof(sh) + item_len > *buf_size) {
|
2014-01-30 19:23:59 +04:00
|
|
|
if (*num_found) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* return one empty item back for v1, which does not
|
|
|
|
|
* handle -EOVERFLOW
|
|
|
|
|
*/
|
|
|
|
|
|
2014-01-30 19:24:00 +04:00
|
|
|
*buf_size = sizeof(sh) + item_len;
|
2010-02-28 23:39:26 +03:00
|
|
|
item_len = 0;
|
2014-01-30 19:23:59 +04:00
|
|
|
ret = -EOVERFLOW;
|
|
|
|
|
}
|
2010-02-28 23:39:26 +03:00
|
|
|
|
2014-01-30 19:24:00 +04:00
|
|
|
if (sizeof(sh) + item_len + *sk_offset > *buf_size) {
|
2010-02-28 23:39:26 +03:00
|
|
|
ret = 1;
|
2014-01-30 19:23:57 +04:00
|
|
|
goto out;
|
2010-02-28 23:39:26 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sh.objectid = key->objectid;
|
|
|
|
|
sh.offset = key->offset;
|
|
|
|
|
sh.type = key->type;
|
|
|
|
|
sh.len = item_len;
|
|
|
|
|
sh.transid = found_transid;
|
|
|
|
|
|
|
|
|
|
/* copy search result header */
|
2014-01-30 19:24:02 +04:00
|
|
|
if (copy_to_user(ubuf + *sk_offset, &sh, sizeof(sh))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-28 23:39:26 +03:00
|
|
|
*sk_offset += sizeof(sh);
|
|
|
|
|
|
|
|
|
|
if (item_len) {
|
2014-01-30 19:24:02 +04:00
|
|
|
char __user *up = ubuf + *sk_offset;
|
2010-02-28 23:39:26 +03:00
|
|
|
/* copy the item */
|
2014-01-30 19:24:02 +04:00
|
|
|
if (read_extent_buffer_to_user(leaf, up,
|
|
|
|
|
item_off, item_len)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-28 23:39:26 +03:00
|
|
|
*sk_offset += item_len;
|
|
|
|
|
}
|
2011-05-14 21:43:41 +04:00
|
|
|
(*num_found)++;
|
2010-02-28 23:39:26 +03:00
|
|
|
|
2014-01-30 19:23:59 +04:00
|
|
|
if (ret) /* -EOVERFLOW from above */
|
|
|
|
|
goto out;
|
|
|
|
|
|
2014-01-30 19:23:57 +04:00
|
|
|
if (*num_found >= sk->nr_items) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2010-02-28 23:39:26 +03:00
|
|
|
}
|
|
|
|
|
advance_key:
|
2010-03-18 19:10:08 +03:00
|
|
|
ret = 0;
|
|
|
|
|
if (key->offset < (u64)-1 && key->offset < sk->max_offset)
|
2010-02-28 23:39:26 +03:00
|
|
|
key->offset++;
|
2010-03-18 19:10:08 +03:00
|
|
|
else if (key->type < (u8)-1 && key->type < sk->max_type) {
|
|
|
|
|
key->offset = 0;
|
2010-02-28 23:39:26 +03:00
|
|
|
key->type++;
|
2010-03-18 19:10:08 +03:00
|
|
|
} else if (key->objectid < (u64)-1 && key->objectid < sk->max_objectid) {
|
|
|
|
|
key->offset = 0;
|
|
|
|
|
key->type = 0;
|
2010-02-28 23:39:26 +03:00
|
|
|
key->objectid++;
|
2010-03-18 19:10:08 +03:00
|
|
|
} else
|
|
|
|
|
ret = 1;
|
2014-01-30 19:23:57 +04:00
|
|
|
out:
|
2014-01-30 19:24:02 +04:00
|
|
|
/*
|
|
|
|
|
* 0: all items from this leaf copied, continue with next
|
|
|
|
|
* 1: * more items can be copied, but unused buffer is too small
|
|
|
|
|
* * all items were found
|
|
|
|
|
* Either way, it will stops the loop which iterates to the next
|
|
|
|
|
* leaf
|
|
|
|
|
* -EOVERFLOW: item was to large for buffer
|
|
|
|
|
* -EFAULT: could not copy extent buffer back to userspace
|
|
|
|
|
*/
|
2010-02-28 23:39:26 +03:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline int search_ioctl(struct inode *inode,
|
2014-01-30 19:23:58 +04:00
|
|
|
struct btrfs_ioctl_search_key *sk,
|
2014-01-30 19:24:00 +04:00
|
|
|
size_t *buf_size,
|
2014-01-30 19:24:02 +04:00
|
|
|
char __user *ubuf)
|
2010-02-28 23:39:26 +03:00
|
|
|
{
|
|
|
|
|
struct btrfs_root *root;
|
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
struct btrfs_path *path;
|
|
|
|
|
struct btrfs_fs_info *info = BTRFS_I(inode)->root->fs_info;
|
|
|
|
|
int ret;
|
|
|
|
|
int num_found = 0;
|
|
|
|
|
unsigned long sk_offset = 0;
|
|
|
|
|
|
2014-01-30 19:24:00 +04:00
|
|
|
if (*buf_size < sizeof(struct btrfs_ioctl_search_header)) {
|
|
|
|
|
*buf_size = sizeof(struct btrfs_ioctl_search_header);
|
2014-01-30 19:23:58 +04:00
|
|
|
return -EOVERFLOW;
|
2014-01-30 19:24:00 +04:00
|
|
|
}
|
2014-01-30 19:23:58 +04:00
|
|
|
|
2010-02-28 23:39:26 +03:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
if (!path)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
if (sk->tree_id == 0) {
|
|
|
|
|
/* search the root of the inode that was passed */
|
|
|
|
|
root = BTRFS_I(inode)->root;
|
|
|
|
|
} else {
|
|
|
|
|
key.objectid = sk->tree_id;
|
|
|
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
root = btrfs_read_fs_root_no_name(info, &key);
|
|
|
|
|
if (IS_ERR(root)) {
|
2013-12-20 20:37:06 +04:00
|
|
|
printk(KERN_ERR "BTRFS: could not find root %llu\n",
|
2010-02-28 23:39:26 +03:00
|
|
|
sk->tree_id);
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
key.objectid = sk->min_objectid;
|
|
|
|
|
key.type = sk->min_type;
|
|
|
|
|
key.offset = sk->min_offset;
|
|
|
|
|
|
|
|
|
|
path->keep_locks = 1;
|
|
|
|
|
|
2013-10-31 09:03:04 +04:00
|
|
|
while (1) {
|
2013-10-01 19:13:42 +04:00
|
|
|
ret = btrfs_search_forward(root, &key, path, sk->min_transid);
|
2010-02-28 23:39:26 +03:00
|
|
|
if (ret != 0) {
|
|
|
|
|
if (ret > 0)
|
|
|
|
|
ret = 0;
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
2014-01-30 19:24:02 +04:00
|
|
|
ret = copy_to_sk(root, path, &key, sk, buf_size, ubuf,
|
2010-02-28 23:39:26 +03:00
|
|
|
&sk_offset, &num_found);
|
2011-04-21 03:20:15 +04:00
|
|
|
btrfs_release_path(path);
|
2014-01-30 19:23:57 +04:00
|
|
|
if (ret)
|
2010-02-28 23:39:26 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
}
|
2014-01-30 19:23:59 +04:00
|
|
|
if (ret > 0)
|
|
|
|
|
ret = 0;
|
2010-02-28 23:39:26 +03:00
|
|
|
err:
|
|
|
|
|
sk->nr_items = num_found;
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline int btrfs_ioctl_tree_search(struct file *file,
|
|
|
|
|
void __user *argp)
|
|
|
|
|
{
|
2014-01-30 19:24:02 +04:00
|
|
|
struct btrfs_ioctl_search_args __user *uargs;
|
|
|
|
|
struct btrfs_ioctl_search_key sk;
|
2014-01-30 19:24:00 +04:00
|
|
|
struct inode *inode;
|
|
|
|
|
int ret;
|
|
|
|
|
size_t buf_size;
|
2010-02-28 23:39:26 +03:00
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2014-01-30 19:24:02 +04:00
|
|
|
uargs = (struct btrfs_ioctl_search_args __user *)argp;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&sk, &uargs->key, sizeof(sk)))
|
|
|
|
|
return -EFAULT;
|
2010-02-28 23:39:26 +03:00
|
|
|
|
2014-01-30 19:24:02 +04:00
|
|
|
buf_size = sizeof(uargs->buf);
|
2010-02-28 23:39:26 +03:00
|
|
|
|
2013-01-24 02:07:38 +04:00
|
|
|
inode = file_inode(file);
|
2014-01-30 19:24:02 +04:00
|
|
|
ret = search_ioctl(inode, &sk, &buf_size, uargs->buf);
|
2014-01-30 19:23:59 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* In the origin implementation an overflow is handled by returning a
|
|
|
|
|
* search header with a len of zero, so reset ret.
|
|
|
|
|
*/
|
|
|
|
|
if (ret == -EOVERFLOW)
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
2014-01-30 19:24:02 +04:00
|
|
|
if (ret == 0 && copy_to_user(&uargs->key, &sk, sizeof(sk)))
|
2010-02-28 23:39:26 +03:00
|
|
|
ret = -EFAULT;
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-30 19:24:03 +04:00
|
|
|
static noinline int btrfs_ioctl_tree_search_v2(struct file *file,
|
|
|
|
|
void __user *argp)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_search_args_v2 __user *uarg;
|
|
|
|
|
struct btrfs_ioctl_search_args_v2 args;
|
|
|
|
|
struct inode *inode;
|
|
|
|
|
int ret;
|
|
|
|
|
size_t buf_size;
|
|
|
|
|
const size_t buf_limit = 16 * 1024 * 1024;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
/* copy search header and buffer size */
|
|
|
|
|
uarg = (struct btrfs_ioctl_search_args_v2 __user *)argp;
|
|
|
|
|
if (copy_from_user(&args, uarg, sizeof(args)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
buf_size = args.buf_size;
|
|
|
|
|
|
|
|
|
|
if (buf_size < sizeof(struct btrfs_ioctl_search_header))
|
|
|
|
|
return -EOVERFLOW;
|
|
|
|
|
|
|
|
|
|
/* limit result size to 16MB */
|
|
|
|
|
if (buf_size > buf_limit)
|
|
|
|
|
buf_size = buf_limit;
|
|
|
|
|
|
|
|
|
|
inode = file_inode(file);
|
|
|
|
|
ret = search_ioctl(inode, &args.key, &buf_size,
|
|
|
|
|
(char *)(&uarg->buf[0]));
|
|
|
|
|
if (ret == 0 && copy_to_user(&uarg->key, &args.key, sizeof(args.key)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
else if (ret == -EOVERFLOW &&
|
|
|
|
|
copy_to_user(&uarg->buf_size, &buf_size, sizeof(buf_size)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
2010-02-28 23:39:26 +03:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-18 08:42:14 +03:00
|
|
|
/*
|
2010-02-28 23:39:26 +03:00
|
|
|
* Search INODE_REFs to identify path name of 'dirid' directory
|
|
|
|
|
* in a 'tree_id' tree. and sets path name to 'name'.
|
|
|
|
|
*/
|
2009-11-18 08:42:14 +03:00
|
|
|
static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
|
|
|
|
|
u64 tree_id, u64 dirid, char *name)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_root *root;
|
|
|
|
|
struct btrfs_key key;
|
2010-02-28 23:39:26 +03:00
|
|
|
char *ptr;
|
2009-11-18 08:42:14 +03:00
|
|
|
int ret = -1;
|
|
|
|
|
int slot;
|
|
|
|
|
int len;
|
|
|
|
|
int total_len = 0;
|
|
|
|
|
struct btrfs_inode_ref *iref;
|
|
|
|
|
struct extent_buffer *l;
|
|
|
|
|
struct btrfs_path *path;
|
|
|
|
|
|
|
|
|
|
if (dirid == BTRFS_FIRST_FREE_OBJECTID) {
|
|
|
|
|
name[0]='\0';
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
if (!path)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2010-02-28 23:39:26 +03:00
|
|
|
ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX];
|
2009-11-18 08:42:14 +03:00
|
|
|
|
|
|
|
|
key.objectid = tree_id;
|
|
|
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
root = btrfs_read_fs_root_no_name(info, &key);
|
|
|
|
|
if (IS_ERR(root)) {
|
2013-12-20 20:37:06 +04:00
|
|
|
printk(KERN_ERR "BTRFS: could not find root %llu\n", tree_id);
|
2010-03-18 19:23:10 +03:00
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto out;
|
2009-11-18 08:42:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
key.objectid = dirid;
|
|
|
|
|
key.type = BTRFS_INODE_REF_KEY;
|
2010-03-18 19:23:10 +03:00
|
|
|
key.offset = (u64)-1;
|
2009-11-18 08:42:14 +03:00
|
|
|
|
2013-10-31 09:03:04 +04:00
|
|
|
while (1) {
|
2009-11-18 08:42:14 +03:00
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2013-08-14 06:00:21 +04:00
|
|
|
else if (ret > 0) {
|
|
|
|
|
ret = btrfs_previous_item(root, path, dirid,
|
|
|
|
|
BTRFS_INODE_REF_KEY);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
else if (ret > 0) {
|
|
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-11-18 08:42:14 +03:00
|
|
|
|
|
|
|
|
l = path->nodes[0];
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
btrfs_item_key_to_cpu(l, &key, slot);
|
|
|
|
|
|
|
|
|
|
iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref);
|
|
|
|
|
len = btrfs_inode_ref_name_len(l, iref);
|
|
|
|
|
ptr -= len + 1;
|
|
|
|
|
total_len += len + 1;
|
2013-08-14 06:00:20 +04:00
|
|
|
if (ptr < name) {
|
|
|
|
|
ret = -ENAMETOOLONG;
|
2009-11-18 08:42:14 +03:00
|
|
|
goto out;
|
2013-08-14 06:00:20 +04:00
|
|
|
}
|
2009-11-18 08:42:14 +03:00
|
|
|
|
|
|
|
|
*(ptr + len) = '/';
|
2013-10-31 09:03:04 +04:00
|
|
|
read_extent_buffer(l, ptr, (unsigned long)(iref + 1), len);
|
2009-11-18 08:42:14 +03:00
|
|
|
|
|
|
|
|
if (key.offset == BTRFS_FIRST_FREE_OBJECTID)
|
|
|
|
|
break;
|
|
|
|
|
|
2011-04-21 03:20:15 +04:00
|
|
|
btrfs_release_path(path);
|
2009-11-18 08:42:14 +03:00
|
|
|
key.objectid = key.offset;
|
2010-03-18 19:23:10 +03:00
|
|
|
key.offset = (u64)-1;
|
2009-11-18 08:42:14 +03:00
|
|
|
dirid = key.objectid;
|
|
|
|
|
}
|
2011-07-14 07:16:00 +04:00
|
|
|
memmove(name, ptr, total_len);
|
2013-10-31 09:03:04 +04:00
|
|
|
name[total_len] = '\0';
|
2009-11-18 08:42:14 +03:00
|
|
|
ret = 0;
|
|
|
|
|
out:
|
|
|
|
|
btrfs_free_path(path);
|
2010-02-28 23:39:26 +03:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline int btrfs_ioctl_ino_lookup(struct file *file,
|
|
|
|
|
void __user *argp)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_ino_lookup_args *args;
|
|
|
|
|
struct inode *inode;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2010-10-29 23:14:18 +04:00
|
|
|
args = memdup_user(argp, sizeof(*args));
|
|
|
|
|
if (IS_ERR(args))
|
|
|
|
|
return PTR_ERR(args);
|
2010-03-20 14:24:15 +03:00
|
|
|
|
2013-01-24 02:07:38 +04:00
|
|
|
inode = file_inode(file);
|
2010-02-28 23:39:26 +03:00
|
|
|
|
2010-03-18 19:17:05 +03:00
|
|
|
if (args->treeid == 0)
|
|
|
|
|
args->treeid = BTRFS_I(inode)->root->root_key.objectid;
|
|
|
|
|
|
2010-02-28 23:39:26 +03:00
|
|
|
ret = btrfs_search_path_in_tree(BTRFS_I(inode)->root->fs_info,
|
|
|
|
|
args->treeid, args->objectid,
|
|
|
|
|
args->name);
|
|
|
|
|
|
|
|
|
|
if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
kfree(args);
|
2009-11-18 08:42:14 +03:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-22 00:00:26 +04:00
|
|
|
static noinline int btrfs_ioctl_snap_destroy(struct file *file,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
2013-09-01 23:57:51 +04:00
|
|
|
struct dentry *parent = file->f_path.dentry;
|
2009-09-22 00:00:26 +04:00
|
|
|
struct dentry *dentry;
|
|
|
|
|
struct inode *dir = parent->d_inode;
|
|
|
|
|
struct inode *inode;
|
|
|
|
|
struct btrfs_root *root = BTRFS_I(dir)->root;
|
|
|
|
|
struct btrfs_root *dest = NULL;
|
|
|
|
|
struct btrfs_ioctl_vol_args *vol_args;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
2013-02-28 14:05:36 +04:00
|
|
|
struct btrfs_block_rsv block_rsv;
|
2014-04-15 18:41:44 +04:00
|
|
|
u64 root_flags;
|
2013-02-28 14:05:36 +04:00
|
|
|
u64 qgroup_reserved;
|
2009-09-22 00:00:26 +04:00
|
|
|
int namelen;
|
|
|
|
|
int ret;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
vol_args = memdup_user(arg, sizeof(*vol_args));
|
|
|
|
|
if (IS_ERR(vol_args))
|
|
|
|
|
return PTR_ERR(vol_args);
|
|
|
|
|
|
|
|
|
|
vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
|
|
|
|
|
namelen = strlen(vol_args->name);
|
|
|
|
|
if (strchr(vol_args->name, '/') ||
|
|
|
|
|
strncmp(vol_args->name, "..", namelen) == 0) {
|
|
|
|
|
err = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-23 20:57:51 +04:00
|
|
|
err = mnt_want_write_file(file);
|
2009-09-22 00:00:26 +04:00
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2014-04-15 18:41:44 +04:00
|
|
|
|
2013-03-22 22:12:51 +04:00
|
|
|
err = mutex_lock_killable_nested(&dir->i_mutex, I_MUTEX_PARENT);
|
|
|
|
|
if (err == -EINTR)
|
2013-12-06 20:51:32 +04:00
|
|
|
goto out_drop_write;
|
2009-09-22 00:00:26 +04:00
|
|
|
dentry = lookup_one_len(vol_args->name, parent, namelen);
|
|
|
|
|
if (IS_ERR(dentry)) {
|
|
|
|
|
err = PTR_ERR(dentry);
|
|
|
|
|
goto out_unlock_dir;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!dentry->d_inode) {
|
|
|
|
|
err = -ENOENT;
|
|
|
|
|
goto out_dput;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inode = dentry->d_inode;
|
2010-10-29 23:46:43 +04:00
|
|
|
dest = BTRFS_I(inode)->root;
|
2013-10-31 09:03:04 +04:00
|
|
|
if (!capable(CAP_SYS_ADMIN)) {
|
2010-10-29 23:46:43 +04:00
|
|
|
/*
|
|
|
|
|
* Regular user. Only allow this with a special mount
|
|
|
|
|
* option, when the user has write+exec access to the
|
|
|
|
|
* subvol root, and when rmdir(2) would have been
|
|
|
|
|
* allowed.
|
|
|
|
|
*
|
|
|
|
|
* Note that this is _not_ check that the subvol is
|
|
|
|
|
* empty or doesn't contain data that we wouldn't
|
|
|
|
|
* otherwise be able to delete.
|
|
|
|
|
*
|
|
|
|
|
* Users who want to delete empty subvols should try
|
|
|
|
|
* rmdir(2).
|
|
|
|
|
*/
|
|
|
|
|
err = -EPERM;
|
|
|
|
|
if (!btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
|
|
|
|
|
goto out_dput;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Do not allow deletion if the parent dir is the same
|
|
|
|
|
* as the dir to be deleted. That means the ioctl
|
|
|
|
|
* must be called on the dentry referencing the root
|
|
|
|
|
* of the subvol, not a random directory contained
|
|
|
|
|
* within it.
|
|
|
|
|
*/
|
|
|
|
|
err = -EINVAL;
|
|
|
|
|
if (root == dest)
|
|
|
|
|
goto out_dput;
|
|
|
|
|
|
|
|
|
|
err = inode_permission(inode, MAY_WRITE | MAY_EXEC);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_dput;
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-22 15:39:53 +04:00
|
|
|
/* check if subvolume may be deleted by a user */
|
|
|
|
|
err = btrfs_may_delete(dir, dentry, 1);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_dput;
|
|
|
|
|
|
2011-04-20 06:31:50 +04:00
|
|
|
if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
|
2009-09-22 00:00:26 +04:00
|
|
|
err = -EINVAL;
|
|
|
|
|
goto out_dput;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mutex_lock(&inode->i_mutex);
|
2014-04-15 18:41:44 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Don't allow to delete a subvolume with send in progress. This is
|
|
|
|
|
* inside the i_mutex so the error handling that has to drop the bit
|
|
|
|
|
* again is not run concurrently.
|
|
|
|
|
*/
|
|
|
|
|
spin_lock(&dest->root_item_lock);
|
2014-05-25 06:55:44 +04:00
|
|
|
root_flags = btrfs_root_flags(&dest->root_item);
|
|
|
|
|
if (dest->send_in_progress == 0) {
|
|
|
|
|
btrfs_set_root_flags(&dest->root_item,
|
2014-04-15 18:41:44 +04:00
|
|
|
root_flags | BTRFS_ROOT_SUBVOL_DEAD);
|
|
|
|
|
spin_unlock(&dest->root_item_lock);
|
|
|
|
|
} else {
|
|
|
|
|
spin_unlock(&dest->root_item_lock);
|
|
|
|
|
btrfs_warn(root->fs_info,
|
|
|
|
|
"Attempt to delete subvolume %llu during send",
|
2014-05-25 06:55:44 +04:00
|
|
|
dest->root_key.objectid);
|
2014-04-15 18:41:44 +04:00
|
|
|
err = -EPERM;
|
|
|
|
|
goto out_dput;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-22 00:00:26 +04:00
|
|
|
err = d_invalidate(dentry);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
down_write(&root->fs_info->subvol_sem);
|
|
|
|
|
|
|
|
|
|
err = may_destroy_subvol(dest);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_up_write;
|
|
|
|
|
|
2013-02-28 14:05:36 +04:00
|
|
|
btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
|
|
|
|
|
/*
|
|
|
|
|
* One for dir inode, two for dir entries, two for root
|
|
|
|
|
* ref/backref.
|
|
|
|
|
*/
|
|
|
|
|
err = btrfs_subvolume_reserve_metadata(root, &block_rsv,
|
2013-07-10 00:37:21 +04:00
|
|
|
5, &qgroup_reserved, true);
|
2013-02-28 14:05:36 +04:00
|
|
|
if (err)
|
|
|
|
|
goto out_up_write;
|
|
|
|
|
|
2010-05-16 18:48:46 +04:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
err = PTR_ERR(trans);
|
2013-02-28 14:05:36 +04:00
|
|
|
goto out_release;
|
2010-05-16 18:48:46 +04:00
|
|
|
}
|
2013-02-28 14:05:36 +04:00
|
|
|
trans->block_rsv = &block_rsv;
|
|
|
|
|
trans->bytes_reserved = block_rsv.size;
|
2010-05-16 18:48:46 +04:00
|
|
|
|
2009-09-22 00:00:26 +04:00
|
|
|
ret = btrfs_unlink_subvol(trans, root, dir,
|
|
|
|
|
dest->root_key.objectid,
|
|
|
|
|
dentry->d_name.name,
|
|
|
|
|
dentry->d_name.len);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
|
|
|
|
err = ret;
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
goto out_end_trans;
|
|
|
|
|
}
|
2009-09-22 00:00:26 +04:00
|
|
|
|
|
|
|
|
btrfs_record_root_in_trans(trans, dest);
|
|
|
|
|
|
|
|
|
|
memset(&dest->root_item.drop_progress, 0,
|
|
|
|
|
sizeof(dest->root_item.drop_progress));
|
|
|
|
|
dest->root_item.drop_level = 0;
|
|
|
|
|
btrfs_set_root_refs(&dest->root_item, 0);
|
|
|
|
|
|
2014-04-02 15:51:05 +04:00
|
|
|
if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) {
|
2010-05-16 18:49:58 +04:00
|
|
|
ret = btrfs_insert_orphan_item(trans,
|
|
|
|
|
root->fs_info->tree_root,
|
|
|
|
|
dest->root_key.objectid);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
err = ret;
|
|
|
|
|
goto out_end_trans;
|
|
|
|
|
}
|
2010-05-16 18:49:58 +04:00
|
|
|
}
|
2013-08-15 19:11:20 +04:00
|
|
|
|
|
|
|
|
ret = btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root,
|
|
|
|
|
dest->root_item.uuid, BTRFS_UUID_KEY_SUBVOL,
|
|
|
|
|
dest->root_key.objectid);
|
|
|
|
|
if (ret && ret != -ENOENT) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
err = ret;
|
|
|
|
|
goto out_end_trans;
|
|
|
|
|
}
|
|
|
|
|
if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) {
|
|
|
|
|
ret = btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root,
|
|
|
|
|
dest->root_item.received_uuid,
|
|
|
|
|
BTRFS_UUID_KEY_RECEIVED_SUBVOL,
|
|
|
|
|
dest->root_key.objectid);
|
|
|
|
|
if (ret && ret != -ENOENT) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
err = ret;
|
|
|
|
|
goto out_end_trans;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-12 19:03:00 +04:00
|
|
|
out_end_trans:
|
2013-02-28 14:05:36 +04:00
|
|
|
trans->block_rsv = NULL;
|
|
|
|
|
trans->bytes_reserved = 0;
|
2010-10-29 23:41:32 +04:00
|
|
|
ret = btrfs_end_transaction(trans, root);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret && !err)
|
|
|
|
|
err = ret;
|
2009-09-22 00:00:26 +04:00
|
|
|
inode->i_flags |= S_DEAD;
|
2013-02-28 14:05:36 +04:00
|
|
|
out_release:
|
|
|
|
|
btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved);
|
2009-09-22 00:00:26 +04:00
|
|
|
out_up_write:
|
|
|
|
|
up_write(&root->fs_info->subvol_sem);
|
|
|
|
|
out_unlock:
|
2014-04-15 18:41:44 +04:00
|
|
|
if (err) {
|
|
|
|
|
spin_lock(&dest->root_item_lock);
|
2014-05-25 06:55:44 +04:00
|
|
|
root_flags = btrfs_root_flags(&dest->root_item);
|
|
|
|
|
btrfs_set_root_flags(&dest->root_item,
|
2014-04-15 18:41:44 +04:00
|
|
|
root_flags & ~BTRFS_ROOT_SUBVOL_DEAD);
|
|
|
|
|
spin_unlock(&dest->root_item_lock);
|
|
|
|
|
}
|
2009-09-22 00:00:26 +04:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
|
if (!err) {
|
2009-10-09 17:25:16 +04:00
|
|
|
shrink_dcache_sb(root->fs_info->sb);
|
2009-09-22 00:00:26 +04:00
|
|
|
btrfs_invalidate_inodes(dest);
|
|
|
|
|
d_delete(dentry);
|
2014-04-15 18:42:03 +04:00
|
|
|
ASSERT(dest->send_in_progress == 0);
|
Btrfs: fix cleaner thread not working with inode cache option
Right now inode cache inode is treated as the same as space cache
inode, ie. keep inode in memory till putting super.
But this leads to an awkward situation.
If we're going to delete a snapshot/subvolume, btrfs will not
actually delete it and return free space, but will add it to dead
roots list until the last inode on this snap/subvol being destroyed.
Then we'll fetch deleted roots and cleanup them via cleaner thread.
So here is the problem, if we enable inode cache option, each
snap/subvol has a cached inode which is used to store inode allcation
information. And this cache inode will be kept in memory, as the above
said. So with inode cache, snap/subvol can only be added into
dead roots list during freeing roots stage in umount, so that we can
ONLY get space back after another remount(we cleanup dead roots on mount).
But the real thing is we'll no more use the snap/subvol if we mark it
deleted, so we can safely iput its cache inode when we delete snap/subvol.
Another thing is that we need to change the rules of droping inode, we
don't keep snap/subvol's cache inode in memory till end so that we can
add snap/subvol into dead roots list in time.
Reported-by: Mitch Harder <mitch.harder@sabayonlinux.org>
Signed-off-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2013-02-20 18:10:23 +04:00
|
|
|
|
|
|
|
|
/* the last ref */
|
|
|
|
|
if (dest->cache_inode) {
|
|
|
|
|
iput(dest->cache_inode);
|
|
|
|
|
dest->cache_inode = NULL;
|
|
|
|
|
}
|
2009-09-22 00:00:26 +04:00
|
|
|
}
|
|
|
|
|
out_dput:
|
|
|
|
|
dput(dentry);
|
|
|
|
|
out_unlock_dir:
|
|
|
|
|
mutex_unlock(&dir->i_mutex);
|
2013-12-06 20:51:32 +04:00
|
|
|
out_drop_write:
|
2011-12-09 17:06:57 +04:00
|
|
|
mnt_drop_write_file(file);
|
2009-09-22 00:00:26 +04:00
|
|
|
out:
|
|
|
|
|
kfree(vol_args);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-11 17:42:04 +03:00
|
|
|
static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2008-06-12 05:53:53 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
2010-03-11 17:42:04 +03:00
|
|
|
struct btrfs_ioctl_defrag_range_args *range;
|
2008-11-12 22:34:12 +03:00
|
|
|
int ret;
|
|
|
|
|
|
2013-01-20 17:57:57 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2010-12-20 11:04:08 +03:00
|
|
|
|
2013-01-20 17:57:57 +04:00
|
|
|
if (btrfs_root_readonly(root)) {
|
|
|
|
|
ret = -EROFS;
|
|
|
|
|
goto out;
|
2012-11-05 20:54:08 +04:00
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
|
|
|
|
|
switch (inode->i_mode & S_IFMT) {
|
|
|
|
|
case S_IFDIR:
|
2009-01-06 00:57:23 +03:00
|
|
|
if (!capable(CAP_SYS_ADMIN)) {
|
|
|
|
|
ret = -EPERM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2013-01-31 22:21:12 +04:00
|
|
|
ret = btrfs_defrag_root(root);
|
2010-05-16 18:49:58 +04:00
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
2013-01-31 22:21:12 +04:00
|
|
|
ret = btrfs_defrag_root(root->fs_info->extent_root);
|
2008-06-12 05:53:53 +04:00
|
|
|
break;
|
|
|
|
|
case S_IFREG:
|
2009-01-06 00:57:23 +03:00
|
|
|
if (!(file->f_mode & FMODE_WRITE)) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2010-03-11 17:42:04 +03:00
|
|
|
|
|
|
|
|
range = kzalloc(sizeof(*range), GFP_KERNEL);
|
|
|
|
|
if (!range) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (argp) {
|
|
|
|
|
if (copy_from_user(range, argp,
|
|
|
|
|
sizeof(*range))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
kfree(range);
|
2010-03-20 14:24:48 +03:00
|
|
|
goto out;
|
2010-03-11 17:42:04 +03:00
|
|
|
}
|
|
|
|
|
/* compression requires us to start the IO */
|
|
|
|
|
if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
|
|
|
|
|
range->flags |= BTRFS_DEFRAG_RANGE_START_IO;
|
|
|
|
|
range->extent_thresh = (u32)-1;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* the rest are all set to zero by kzalloc */
|
|
|
|
|
range->len = (u64)-1;
|
|
|
|
|
}
|
2013-01-24 02:07:38 +04:00
|
|
|
ret = btrfs_defrag_file(file_inode(file), file,
|
2011-05-24 23:35:30 +04:00
|
|
|
range, 0, 0);
|
|
|
|
|
if (ret > 0)
|
|
|
|
|
ret = 0;
|
2010-03-11 17:42:04 +03:00
|
|
|
kfree(range);
|
2008-06-12 05:53:53 +04:00
|
|
|
break;
|
2010-05-16 18:49:58 +04:00
|
|
|
default:
|
|
|
|
|
ret = -EINVAL;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
2009-01-06 00:57:23 +03:00
|
|
|
out:
|
2013-01-20 17:57:57 +04:00
|
|
|
mnt_drop_write_file(file);
|
2009-01-06 00:57:23 +03:00
|
|
|
return ret;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
|
2008-12-02 17:54:17 +03:00
|
|
|
static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_vol_args *vol_args;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2009-01-06 00:57:23 +03:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-05 20:54:08 +04:00
|
|
|
if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
|
|
|
|
|
1)) {
|
2013-08-21 07:44:48 +04:00
|
|
|
return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
|
2012-01-17 00:04:47 +04:00
|
|
|
}
|
|
|
|
|
|
2012-11-05 20:54:08 +04:00
|
|
|
mutex_lock(&root->fs_info->volume_mutex);
|
2009-04-08 11:06:54 +04:00
|
|
|
vol_args = memdup_user(arg, sizeof(*vol_args));
|
2012-01-17 00:04:47 +04:00
|
|
|
if (IS_ERR(vol_args)) {
|
|
|
|
|
ret = PTR_ERR(vol_args);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2008-07-24 20:20:14 +04:00
|
|
|
vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
|
2008-06-12 05:53:53 +04:00
|
|
|
ret = btrfs_init_new_device(root, vol_args->name);
|
|
|
|
|
|
|
|
|
|
kfree(vol_args);
|
2012-01-17 00:04:47 +04:00
|
|
|
out:
|
|
|
|
|
mutex_unlock(&root->fs_info->volume_mutex);
|
2012-11-05 20:54:08 +04:00
|
|
|
atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
|
2008-06-12 05:53:53 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:44:50 +04:00
|
|
|
static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2008-06-12 05:53:53 +04:00
|
|
|
struct btrfs_ioctl_vol_args *vol_args;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2009-01-06 00:57:23 +03:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-26 12:44:50 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2008-11-12 22:34:12 +03:00
|
|
|
|
2009-04-08 11:06:54 +04:00
|
|
|
vol_args = memdup_user(arg, sizeof(*vol_args));
|
2012-01-17 00:04:47 +04:00
|
|
|
if (IS_ERR(vol_args)) {
|
|
|
|
|
ret = PTR_ERR(vol_args);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2008-07-24 20:20:14 +04:00
|
|
|
vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2013-05-17 14:52:45 +04:00
|
|
|
if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
|
|
|
|
|
1)) {
|
|
|
|
|
ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->volume_mutex);
|
|
|
|
|
ret = btrfs_rm_device(root, vol_args->name);
|
2012-01-17 00:04:47 +04:00
|
|
|
mutex_unlock(&root->fs_info->volume_mutex);
|
2012-11-05 20:54:08 +04:00
|
|
|
atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
|
2013-05-17 14:52:45 +04:00
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(vol_args);
|
2013-01-20 17:57:57 +04:00
|
|
|
mnt_drop_write_file(file);
|
2008-06-12 05:53:53 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-11 17:41:01 +03:00
|
|
|
static long btrfs_ioctl_fs_info(struct btrfs_root *root, void __user *arg)
|
|
|
|
|
{
|
2011-06-08 12:27:56 +04:00
|
|
|
struct btrfs_ioctl_fs_info_args *fi_args;
|
2011-03-11 17:41:01 +03:00
|
|
|
struct btrfs_device *device;
|
|
|
|
|
struct btrfs_device *next;
|
|
|
|
|
struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
|
2011-06-08 12:27:56 +04:00
|
|
|
int ret = 0;
|
2011-03-11 17:41:01 +03:00
|
|
|
|
2011-06-08 12:27:56 +04:00
|
|
|
fi_args = kzalloc(sizeof(*fi_args), GFP_KERNEL);
|
|
|
|
|
if (!fi_args)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
Btrfs: fix race conditions in BTRFS_IOC_FS_INFO ioctl
The handler for the ioctl BTRFS_IOC_FS_INFO was reading the
number of devices before acquiring the device list mutex.
This could lead to inconsistent results because the update of
the device list and the number of devices counter (amongst other
counters related to the device list) are updated in volumes.c
while holding the device list mutex - except for 2 places, one
was volumes.c:btrfs_prepare_sprout() and the other was
volumes.c:device_list_add().
For example, if we have 2 devices, with IDs 1 and 2 and then add
a new device, with ID 3, and while adding the device is in progress
an BTRFS_IOC_FS_INFO ioctl arrives, it could return a number of
devices of 2 and a max dev id of 3. This would be incorrect.
Also, this ioctl handler was reading the fsid while it can be
updated concurrently. This can happen when while a new device is
being added and the current filesystem is in seeding mode.
Example:
$ mkfs.btrfs -f /dev/sdb1
$ mkfs.btrfs -f /dev/sdb2
$ btrfstune -S 1 /dev/sdb1
$ mount /dev/sdb1 /mnt/test
$ btrfs device add /dev/sdb2 /mnt/test
If during the last step a BTRFS_IOC_FS_INFO ioctl was requested, it
could read an fsid that was never valid (some bits part of the old
fsid and others part of the new fsid). Also, it could read a number
of devices that doesn't match the number of devices in the list and
the max device id, as explained before.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2013-08-12 23:56:58 +04:00
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
2011-06-08 12:27:56 +04:00
|
|
|
fi_args->num_devices = fs_devices->num_devices;
|
|
|
|
|
memcpy(&fi_args->fsid, root->fs_info->fsid, sizeof(fi_args->fsid));
|
2011-03-11 17:41:01 +03:00
|
|
|
|
|
|
|
|
list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
|
2011-06-08 12:27:56 +04:00
|
|
|
if (device->devid > fi_args->max_id)
|
|
|
|
|
fi_args->max_id = device->devid;
|
2011-03-11 17:41:01 +03:00
|
|
|
}
|
|
|
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
|
|
2014-05-07 20:17:06 +04:00
|
|
|
fi_args->nodesize = root->fs_info->super_copy->nodesize;
|
|
|
|
|
fi_args->sectorsize = root->fs_info->super_copy->sectorsize;
|
|
|
|
|
fi_args->clone_alignment = root->fs_info->super_copy->sectorsize;
|
|
|
|
|
|
2011-06-08 12:27:56 +04:00
|
|
|
if (copy_to_user(arg, fi_args, sizeof(*fi_args)))
|
|
|
|
|
ret = -EFAULT;
|
2011-03-11 17:41:01 +03:00
|
|
|
|
2011-06-08 12:27:56 +04:00
|
|
|
kfree(fi_args);
|
|
|
|
|
return ret;
|
2011-03-11 17:41:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_dev_info_args *di_args;
|
|
|
|
|
struct btrfs_device *dev;
|
|
|
|
|
struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
char *s_uuid = NULL;
|
|
|
|
|
|
|
|
|
|
di_args = memdup_user(arg, sizeof(*di_args));
|
|
|
|
|
if (IS_ERR(di_args))
|
|
|
|
|
return PTR_ERR(di_args);
|
|
|
|
|
|
2013-08-15 19:11:20 +04:00
|
|
|
if (!btrfs_is_empty_uuid(di_args->uuid))
|
2011-03-11 17:41:01 +03:00
|
|
|
s_uuid = di_args->uuid;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
2012-11-05 20:03:39 +04:00
|
|
|
dev = btrfs_find_device(root->fs_info, di_args->devid, s_uuid, NULL);
|
2011-03-11 17:41:01 +03:00
|
|
|
|
|
|
|
|
if (!dev) {
|
|
|
|
|
ret = -ENODEV;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
di_args->devid = dev->devid;
|
|
|
|
|
di_args->bytes_used = dev->bytes_used;
|
|
|
|
|
di_args->total_bytes = dev->total_bytes;
|
|
|
|
|
memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid));
|
2012-04-26 20:36:56 +04:00
|
|
|
if (dev->name) {
|
2012-06-04 22:03:51 +04:00
|
|
|
struct rcu_string *name;
|
|
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
name = rcu_dereference(dev->name);
|
|
|
|
|
strncpy(di_args->path, name->str, sizeof(di_args->path));
|
|
|
|
|
rcu_read_unlock();
|
2012-04-26 20:36:56 +04:00
|
|
|
di_args->path[sizeof(di_args->path) - 1] = 0;
|
|
|
|
|
} else {
|
2012-03-19 19:17:22 +04:00
|
|
|
di_args->path[0] = '\0';
|
2012-04-26 20:36:56 +04:00
|
|
|
}
|
2011-03-11 17:41:01 +03:00
|
|
|
|
|
|
|
|
out:
|
2013-04-26 19:20:23 +04:00
|
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
2011-03-11 17:41:01 +03:00
|
|
|
if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
kfree(di_args);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-06 22:42:51 +04:00
|
|
|
static struct page *extent_same_get_page(struct inode *inode, u64 off)
|
|
|
|
|
{
|
|
|
|
|
struct page *page;
|
|
|
|
|
pgoff_t index;
|
|
|
|
|
struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
|
|
|
|
|
|
|
|
|
|
index = off >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
|
|
page = grab_cache_page(inode->i_mapping, index);
|
|
|
|
|
if (!page)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (!PageUptodate(page)) {
|
|
|
|
|
if (extent_read_full_page_nolock(tree, page, btrfs_get_extent,
|
|
|
|
|
0))
|
|
|
|
|
return NULL;
|
|
|
|
|
lock_page(page);
|
|
|
|
|
if (!PageUptodate(page)) {
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
page_cache_release(page);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
|
|
|
|
|
return page;
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-06 22:42:48 +04:00
|
|
|
static inline void lock_extent_range(struct inode *inode, u64 off, u64 len)
|
|
|
|
|
{
|
|
|
|
|
/* do any pending delalloc/csum calc on src, one way or
|
|
|
|
|
another, and lock file content */
|
|
|
|
|
while (1) {
|
|
|
|
|
struct btrfs_ordered_extent *ordered;
|
|
|
|
|
lock_extent(&BTRFS_I(inode)->io_tree, off, off + len - 1);
|
|
|
|
|
ordered = btrfs_lookup_first_ordered_extent(inode,
|
|
|
|
|
off + len - 1);
|
2014-05-30 20:56:24 +04:00
|
|
|
if ((!ordered ||
|
|
|
|
|
ordered->file_offset + ordered->len <= off ||
|
|
|
|
|
ordered->file_offset >= off + len) &&
|
2013-08-06 22:42:48 +04:00
|
|
|
!test_range_bit(&BTRFS_I(inode)->io_tree, off,
|
2014-05-30 20:56:24 +04:00
|
|
|
off + len - 1, EXTENT_DELALLOC, 0, NULL)) {
|
|
|
|
|
if (ordered)
|
|
|
|
|
btrfs_put_ordered_extent(ordered);
|
2013-08-06 22:42:48 +04:00
|
|
|
break;
|
2014-05-30 20:56:24 +04:00
|
|
|
}
|
2013-08-06 22:42:48 +04:00
|
|
|
unlock_extent(&BTRFS_I(inode)->io_tree, off, off + len - 1);
|
|
|
|
|
if (ordered)
|
|
|
|
|
btrfs_put_ordered_extent(ordered);
|
|
|
|
|
btrfs_wait_ordered_range(inode, off, len);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-06 22:42:51 +04:00
|
|
|
static void btrfs_double_unlock(struct inode *inode1, u64 loff1,
|
|
|
|
|
struct inode *inode2, u64 loff2, u64 len)
|
|
|
|
|
{
|
|
|
|
|
unlock_extent(&BTRFS_I(inode1)->io_tree, loff1, loff1 + len - 1);
|
|
|
|
|
unlock_extent(&BTRFS_I(inode2)->io_tree, loff2, loff2 + len - 1);
|
|
|
|
|
|
|
|
|
|
mutex_unlock(&inode1->i_mutex);
|
|
|
|
|
mutex_unlock(&inode2->i_mutex);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void btrfs_double_lock(struct inode *inode1, u64 loff1,
|
|
|
|
|
struct inode *inode2, u64 loff2, u64 len)
|
|
|
|
|
{
|
|
|
|
|
if (inode1 < inode2) {
|
|
|
|
|
swap(inode1, inode2);
|
|
|
|
|
swap(loff1, loff2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mutex_lock_nested(&inode1->i_mutex, I_MUTEX_PARENT);
|
|
|
|
|
lock_extent_range(inode1, loff1, len);
|
|
|
|
|
if (inode1 != inode2) {
|
|
|
|
|
mutex_lock_nested(&inode2->i_mutex, I_MUTEX_CHILD);
|
|
|
|
|
lock_extent_range(inode2, loff2, len);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int btrfs_cmp_data(struct inode *src, u64 loff, struct inode *dst,
|
|
|
|
|
u64 dst_loff, u64 len)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct page *src_page, *dst_page;
|
|
|
|
|
unsigned int cmp_len = PAGE_CACHE_SIZE;
|
|
|
|
|
void *addr, *dst_addr;
|
|
|
|
|
|
|
|
|
|
while (len) {
|
|
|
|
|
if (len < PAGE_CACHE_SIZE)
|
|
|
|
|
cmp_len = len;
|
|
|
|
|
|
|
|
|
|
src_page = extent_same_get_page(src, loff);
|
|
|
|
|
if (!src_page)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
dst_page = extent_same_get_page(dst, dst_loff);
|
|
|
|
|
if (!dst_page) {
|
|
|
|
|
page_cache_release(src_page);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
addr = kmap_atomic(src_page);
|
|
|
|
|
dst_addr = kmap_atomic(dst_page);
|
|
|
|
|
|
|
|
|
|
flush_dcache_page(src_page);
|
|
|
|
|
flush_dcache_page(dst_page);
|
|
|
|
|
|
|
|
|
|
if (memcmp(addr, dst_addr, cmp_len))
|
|
|
|
|
ret = BTRFS_SAME_DATA_DIFFERS;
|
|
|
|
|
|
|
|
|
|
kunmap_atomic(addr);
|
|
|
|
|
kunmap_atomic(dst_addr);
|
|
|
|
|
page_cache_release(src_page);
|
|
|
|
|
page_cache_release(dst_page);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
loff += cmp_len;
|
|
|
|
|
dst_loff += cmp_len;
|
|
|
|
|
len -= cmp_len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int extent_same_check_offsets(struct inode *inode, u64 off, u64 len)
|
|
|
|
|
{
|
|
|
|
|
u64 bs = BTRFS_I(inode)->root->fs_info->sb->s_blocksize;
|
|
|
|
|
|
|
|
|
|
if (off + len > inode->i_size || off + len < off)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
/* Check that we are block aligned - btrfs_clone() requires this */
|
|
|
|
|
if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int btrfs_extent_same(struct inode *src, u64 loff, u64 len,
|
|
|
|
|
struct inode *dst, u64 dst_loff)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* btrfs_clone() can't handle extents in the same file
|
|
|
|
|
* yet. Once that works, we can drop this check and replace it
|
|
|
|
|
* with a check for the same inode, but overlapping extents.
|
|
|
|
|
*/
|
|
|
|
|
if (src == dst)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
btrfs_double_lock(src, loff, dst, dst_loff, len);
|
|
|
|
|
|
|
|
|
|
ret = extent_same_check_offsets(src, loff, len);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
ret = extent_same_check_offsets(dst, dst_loff, len);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
/* don't make the dst file partly checksummed */
|
|
|
|
|
if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) !=
|
|
|
|
|
(BTRFS_I(dst)->flags & BTRFS_INODE_NODATASUM)) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = btrfs_cmp_data(src, loff, dst, dst_loff, len);
|
|
|
|
|
if (ret == 0)
|
|
|
|
|
ret = btrfs_clone(src, dst, loff, len, len, dst_loff);
|
|
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
|
btrfs_double_unlock(src, loff, dst, dst_loff, len);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define BTRFS_MAX_DEDUPE_LEN (16 * 1024 * 1024)
|
|
|
|
|
|
|
|
|
|
static long btrfs_ioctl_file_extent_same(struct file *file,
|
2013-12-12 08:07:51 +04:00
|
|
|
struct btrfs_ioctl_same_args __user *argp)
|
2013-08-06 22:42:51 +04:00
|
|
|
{
|
2013-09-18 02:43:54 +04:00
|
|
|
struct btrfs_ioctl_same_args *same;
|
|
|
|
|
struct btrfs_ioctl_same_extent_info *info;
|
2013-12-12 08:07:51 +04:00
|
|
|
struct inode *src = file_inode(file);
|
2013-08-06 22:42:51 +04:00
|
|
|
u64 off;
|
|
|
|
|
u64 len;
|
|
|
|
|
int i;
|
|
|
|
|
int ret;
|
2013-09-18 02:43:54 +04:00
|
|
|
unsigned long size;
|
2013-08-06 22:42:51 +04:00
|
|
|
u64 bs = BTRFS_I(src)->root->fs_info->sb->s_blocksize;
|
|
|
|
|
bool is_admin = capable(CAP_SYS_ADMIN);
|
2013-12-12 08:07:51 +04:00
|
|
|
u16 count;
|
2013-08-06 22:42:51 +04:00
|
|
|
|
|
|
|
|
if (!(file->f_mode & FMODE_READ))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2013-12-12 08:07:51 +04:00
|
|
|
if (get_user(count, &argp->dest_count)) {
|
2013-08-06 22:42:51 +04:00
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-12 08:07:51 +04:00
|
|
|
size = offsetof(struct btrfs_ioctl_same_args __user, info[count]);
|
2013-09-18 02:43:54 +04:00
|
|
|
|
2013-12-12 08:07:51 +04:00
|
|
|
same = memdup_user(argp, size);
|
2013-09-18 02:43:54 +04:00
|
|
|
|
2013-10-14 19:18:25 +04:00
|
|
|
if (IS_ERR(same)) {
|
|
|
|
|
ret = PTR_ERR(same);
|
2013-09-18 02:43:54 +04:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
off = same->logical_offset;
|
|
|
|
|
len = same->length;
|
2013-08-06 22:42:51 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Limit the total length we will dedupe for each operation.
|
|
|
|
|
* This is intended to bound the total time spent in this
|
|
|
|
|
* ioctl to something sane.
|
|
|
|
|
*/
|
|
|
|
|
if (len > BTRFS_MAX_DEDUPE_LEN)
|
|
|
|
|
len = BTRFS_MAX_DEDUPE_LEN;
|
|
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(bs < PAGE_CACHE_SIZE)) {
|
|
|
|
|
/*
|
|
|
|
|
* Btrfs does not support blocksize < page_size. As a
|
|
|
|
|
* result, btrfs_cmp_data() won't correctly handle
|
|
|
|
|
* this situation without an update.
|
|
|
|
|
*/
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = -EISDIR;
|
|
|
|
|
if (S_ISDIR(src->i_mode))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
ret = -EACCES;
|
|
|
|
|
if (!S_ISREG(src->i_mode))
|
|
|
|
|
goto out;
|
|
|
|
|
|
2013-09-18 02:43:54 +04:00
|
|
|
/* pre-format output fields to sane values */
|
2013-12-12 08:07:51 +04:00
|
|
|
for (i = 0; i < count; i++) {
|
2013-09-18 02:43:54 +04:00
|
|
|
same->info[i].bytes_deduped = 0ULL;
|
|
|
|
|
same->info[i].status = 0;
|
|
|
|
|
}
|
2013-08-06 22:42:51 +04:00
|
|
|
|
2013-12-12 08:07:51 +04:00
|
|
|
for (i = 0, info = same->info; i < count; i++, info++) {
|
|
|
|
|
struct inode *dst;
|
|
|
|
|
struct fd dst_file = fdget(info->fd);
|
|
|
|
|
if (!dst_file.file) {
|
2013-09-18 02:43:54 +04:00
|
|
|
info->status = -EBADF;
|
2013-12-12 08:07:51 +04:00
|
|
|
continue;
|
2013-08-06 22:42:51 +04:00
|
|
|
}
|
2013-12-12 08:07:51 +04:00
|
|
|
dst = file_inode(dst_file.file);
|
2013-08-06 22:42:51 +04:00
|
|
|
|
2013-12-12 08:07:51 +04:00
|
|
|
if (!(is_admin || (dst_file.file->f_mode & FMODE_WRITE))) {
|
2013-09-18 02:43:54 +04:00
|
|
|
info->status = -EINVAL;
|
2013-12-12 08:07:51 +04:00
|
|
|
} else if (file->f_path.mnt != dst_file.file->f_path.mnt) {
|
|
|
|
|
info->status = -EXDEV;
|
|
|
|
|
} else if (S_ISDIR(dst->i_mode)) {
|
2013-09-18 02:43:54 +04:00
|
|
|
info->status = -EISDIR;
|
2013-12-12 08:07:51 +04:00
|
|
|
} else if (!S_ISREG(dst->i_mode)) {
|
2013-09-18 02:43:54 +04:00
|
|
|
info->status = -EACCES;
|
2013-12-12 08:07:51 +04:00
|
|
|
} else {
|
|
|
|
|
info->status = btrfs_extent_same(src, off, len, dst,
|
|
|
|
|
info->logical_offset);
|
|
|
|
|
if (info->status == 0)
|
|
|
|
|
info->bytes_deduped += len;
|
2013-08-06 22:42:51 +04:00
|
|
|
}
|
2013-12-12 08:07:51 +04:00
|
|
|
fdput(dst_file);
|
2013-08-06 22:42:51 +04:00
|
|
|
}
|
|
|
|
|
|
2013-09-18 02:43:54 +04:00
|
|
|
ret = copy_to_user(argp, same, size);
|
|
|
|
|
if (ret)
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
2013-08-06 22:42:51 +04:00
|
|
|
out:
|
|
|
|
|
mnt_drop_write_file(file);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-14 04:30:47 +04:00
|
|
|
/* Helper to check and see if this root currently has a ref on the given disk
|
|
|
|
|
* bytenr. If it does then we need to update the quota for this root. This
|
|
|
|
|
* doesn't do anything if quotas aren't enabled.
|
|
|
|
|
*/
|
|
|
|
|
static int check_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
|
|
|
|
|
u64 disko)
|
|
|
|
|
{
|
|
|
|
|
struct seq_list tree_mod_seq_elem = {};
|
|
|
|
|
struct ulist *roots;
|
|
|
|
|
struct ulist_iterator uiter;
|
|
|
|
|
struct ulist_node *root_node = NULL;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!root->fs_info->quota_enabled)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
btrfs_get_tree_mod_seq(root->fs_info, &tree_mod_seq_elem);
|
|
|
|
|
ret = btrfs_find_all_roots(trans, root->fs_info, disko,
|
|
|
|
|
tree_mod_seq_elem.seq, &roots);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
ret = 0;
|
|
|
|
|
ULIST_ITER_INIT(&uiter);
|
|
|
|
|
while ((root_node = ulist_next(roots, &uiter))) {
|
|
|
|
|
if (root_node->val == root->objectid) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
ulist_free(roots);
|
|
|
|
|
out:
|
|
|
|
|
btrfs_put_tree_mod_seq(root->fs_info, &tree_mod_seq_elem);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-01 04:50:28 +04:00
|
|
|
static int clone_finish_inode_update(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct inode *inode,
|
|
|
|
|
u64 endoff,
|
|
|
|
|
const u64 destoff,
|
|
|
|
|
const u64 olen)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
inode_inc_iversion(inode);
|
|
|
|
|
inode->i_mtime = inode->i_ctime = CURRENT_TIME;
|
|
|
|
|
/*
|
|
|
|
|
* We round up to the block size at eof when determining which
|
|
|
|
|
* extents to clone above, but shouldn't round up the file size.
|
|
|
|
|
*/
|
|
|
|
|
if (endoff > destoff + olen)
|
|
|
|
|
endoff = destoff + olen;
|
|
|
|
|
if (endoff > inode->i_size)
|
|
|
|
|
btrfs_i_size_write(inode, endoff);
|
|
|
|
|
|
|
|
|
|
ret = btrfs_update_inode(trans, root, inode);
|
|
|
|
|
if (ret) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
ret = btrfs_end_transaction(trans, root);
|
|
|
|
|
out:
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-09 06:48:05 +04:00
|
|
|
static void clone_update_extent_map(struct inode *inode,
|
|
|
|
|
const struct btrfs_trans_handle *trans,
|
|
|
|
|
const struct btrfs_path *path,
|
|
|
|
|
const u64 hole_offset,
|
|
|
|
|
const u64 hole_len)
|
|
|
|
|
{
|
|
|
|
|
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
|
|
|
|
|
struct extent_map *em;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
em = alloc_extent_map();
|
|
|
|
|
if (!em) {
|
|
|
|
|
set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
|
|
|
|
|
&BTRFS_I(inode)->runtime_flags);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-30 00:45:40 +04:00
|
|
|
if (path) {
|
|
|
|
|
struct btrfs_file_extent_item *fi;
|
|
|
|
|
|
|
|
|
|
fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
|
struct btrfs_file_extent_item);
|
2014-06-09 06:48:05 +04:00
|
|
|
btrfs_extent_item_to_extent_map(inode, path, fi, false, em);
|
|
|
|
|
em->generation = -1;
|
|
|
|
|
if (btrfs_file_extent_type(path->nodes[0], fi) ==
|
|
|
|
|
BTRFS_FILE_EXTENT_INLINE)
|
|
|
|
|
set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
|
|
|
|
|
&BTRFS_I(inode)->runtime_flags);
|
|
|
|
|
} else {
|
|
|
|
|
em->start = hole_offset;
|
|
|
|
|
em->len = hole_len;
|
|
|
|
|
em->ram_bytes = em->len;
|
|
|
|
|
em->orig_start = hole_offset;
|
|
|
|
|
em->block_start = EXTENT_MAP_HOLE;
|
|
|
|
|
em->block_len = 0;
|
|
|
|
|
em->orig_block_len = 0;
|
|
|
|
|
em->compress_type = BTRFS_COMPRESS_NONE;
|
|
|
|
|
em->generation = trans->transid;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
|
write_lock(&em_tree->lock);
|
|
|
|
|
ret = add_extent_mapping(em_tree, em, 1);
|
|
|
|
|
write_unlock(&em_tree->lock);
|
|
|
|
|
if (ret != -EEXIST) {
|
|
|
|
|
free_extent_map(em);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
btrfs_drop_extent_cache(inode, em->start,
|
|
|
|
|
em->start + em->len - 1, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (unlikely(ret))
|
|
|
|
|
set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
|
|
|
|
|
&BTRFS_I(inode)->runtime_flags);
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-06 22:42:49 +04:00
|
|
|
/**
|
|
|
|
|
* btrfs_clone() - clone a range from inode file to another
|
|
|
|
|
*
|
|
|
|
|
* @src: Inode to clone from
|
|
|
|
|
* @inode: Inode to clone to
|
|
|
|
|
* @off: Offset within source to start clone from
|
|
|
|
|
* @olen: Original length, passed by user, of range to clone
|
|
|
|
|
* @olen_aligned: Block-aligned value of olen, extent_same uses
|
|
|
|
|
* identical values here
|
|
|
|
|
* @destoff: Offset within @inode to start clone
|
|
|
|
|
*/
|
|
|
|
|
static int btrfs_clone(struct inode *src, struct inode *inode,
|
2014-06-01 04:50:28 +04:00
|
|
|
const u64 off, const u64 olen, const u64 olen_aligned,
|
|
|
|
|
const u64 destoff)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
2013-08-06 22:42:49 +04:00
|
|
|
struct btrfs_path *path = NULL;
|
2008-06-12 05:53:53 +04:00
|
|
|
struct extent_buffer *leaf;
|
2013-08-06 22:42:49 +04:00
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
char *buf = NULL;
|
2008-08-05 07:23:47 +04:00
|
|
|
struct btrfs_key key;
|
2008-06-12 05:53:53 +04:00
|
|
|
u32 nritems;
|
|
|
|
|
int slot;
|
2008-08-05 07:23:47 +04:00
|
|
|
int ret;
|
2014-05-14 04:30:47 +04:00
|
|
|
int no_quota;
|
2014-06-01 04:50:28 +04:00
|
|
|
const u64 len = olen_aligned;
|
2014-05-14 04:30:47 +04:00
|
|
|
u64 last_disko = 0;
|
2014-06-01 04:50:28 +04:00
|
|
|
u64 last_dest_end = destoff;
|
2008-08-05 07:23:47 +04:00
|
|
|
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
buf = vmalloc(btrfs_level_size(root, 0));
|
|
|
|
|
if (!buf)
|
2013-08-06 22:42:49 +04:00
|
|
|
return ret;
|
2008-08-05 07:23:47 +04:00
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
if (!path) {
|
|
|
|
|
vfree(buf);
|
2013-08-06 22:42:49 +04:00
|
|
|
return ret;
|
2011-09-11 18:52:25 +04:00
|
|
|
}
|
|
|
|
|
|
2013-08-06 22:42:49 +04:00
|
|
|
path->reada = 2;
|
2008-11-12 22:32:25 +03:00
|
|
|
/* clone data */
|
2011-04-20 06:31:50 +04:00
|
|
|
key.objectid = btrfs_ino(src);
|
2008-08-05 07:23:47 +04:00
|
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
2014-05-31 05:31:05 +04:00
|
|
|
key.offset = off;
|
2008-06-12 05:53:53 +04:00
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
|
/*
|
|
|
|
|
* note the key will change type as we walk through the
|
|
|
|
|
* tree.
|
|
|
|
|
*/
|
2014-01-13 23:35:01 +04:00
|
|
|
path->leave_spinning = 1;
|
2011-08-01 20:11:57 +04:00
|
|
|
ret = btrfs_search_slot(NULL, BTRFS_I(src)->root, &key, path,
|
|
|
|
|
0, 0);
|
2008-06-12 05:53:53 +04:00
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2014-05-31 05:31:05 +04:00
|
|
|
/*
|
|
|
|
|
* First search, if no extent item that starts at offset off was
|
|
|
|
|
* found but the previous item is an extent item, it's possible
|
|
|
|
|
* it might overlap our target range, therefore process it.
|
|
|
|
|
*/
|
|
|
|
|
if (key.offset == off && ret > 0 && path->slots[0] > 0) {
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key,
|
|
|
|
|
path->slots[0] - 1);
|
|
|
|
|
if (key.type == BTRFS_EXTENT_DATA_KEY)
|
|
|
|
|
path->slots[0]--;
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2008-08-05 07:23:47 +04:00
|
|
|
nritems = btrfs_header_nritems(path->nodes[0]);
|
2014-01-13 23:35:01 +04:00
|
|
|
process_slot:
|
2014-05-14 04:30:47 +04:00
|
|
|
no_quota = 1;
|
2008-08-05 07:23:47 +04:00
|
|
|
if (path->slots[0] >= nritems) {
|
2011-08-01 20:11:57 +04:00
|
|
|
ret = btrfs_next_leaf(BTRFS_I(src)->root, path);
|
2008-06-12 05:53:53 +04:00
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
if (ret > 0)
|
|
|
|
|
break;
|
2008-08-05 07:23:47 +04:00
|
|
|
nritems = btrfs_header_nritems(path->nodes[0]);
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
|
2008-08-05 07:23:47 +04:00
|
|
|
btrfs_item_key_to_cpu(leaf, &key, slot);
|
Btrfs: move data checksumming into a dedicated tree
Btrfs stores checksums for each data block. Until now, they have
been stored in the subvolume trees, indexed by the inode that is
referencing the data block. This means that when we read the inode,
we've probably read in at least some checksums as well.
But, this has a few problems:
* The checksums are indexed by logical offset in the file. When
compression is on, this means we have to do the expensive checksumming
on the uncompressed data. It would be faster if we could checksum
the compressed data instead.
* If we implement encryption, we'll be checksumming the plain text and
storing that on disk. This is significantly less secure.
* For either compression or encryption, we have to get the plain text
back before we can verify the checksum as correct. This makes the raid
layer balancing and extent moving much more expensive.
* It makes the front end caching code more complex, as we have touch
the subvolume and inodes as we cache extents.
* There is potentitally one copy of the checksum in each subvolume
referencing an extent.
The solution used here is to store the extent checksums in a dedicated
tree. This allows us to index the checksums by phyiscal extent
start and length. It means:
* The checksum is against the data stored on disk, after any compression
or encryption is done.
* The checksum is stored in a central location, and can be verified without
following back references, or reading inodes.
This makes compression significantly faster by reducing the amount of
data that needs to be checksummed. It will also allow much faster
raid management code in general.
The checksums are indexed by a key with a fixed objectid (a magic value
in ctree.h) and offset set to the starting byte of the extent. This
allows us to copy the checksum items into the fsync log tree directly (or
any other tree), without having to invent a second format for them.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-12-09 00:58:54 +03:00
|
|
|
if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY ||
|
2011-04-20 06:31:50 +04:00
|
|
|
key.objectid != btrfs_ino(src))
|
2008-06-12 05:53:53 +04:00
|
|
|
break;
|
|
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
|
|
|
|
|
struct btrfs_file_extent_item *extent;
|
|
|
|
|
int type;
|
2008-09-23 21:14:14 +04:00
|
|
|
u32 size;
|
|
|
|
|
struct btrfs_key new_key;
|
2008-11-12 22:32:25 +03:00
|
|
|
u64 disko = 0, diskl = 0;
|
|
|
|
|
u64 datao = 0, datal = 0;
|
|
|
|
|
u8 comp;
|
2014-06-01 04:50:28 +04:00
|
|
|
u64 drop_start;
|
2008-09-23 21:14:14 +04:00
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
extent = btrfs_item_ptr(leaf, slot,
|
|
|
|
|
struct btrfs_file_extent_item);
|
|
|
|
|
comp = btrfs_file_extent_compression(leaf, extent);
|
|
|
|
|
type = btrfs_file_extent_type(leaf, extent);
|
2009-06-28 05:07:03 +04:00
|
|
|
if (type == BTRFS_FILE_EXTENT_REG ||
|
|
|
|
|
type == BTRFS_FILE_EXTENT_PREALLOC) {
|
2009-01-06 05:25:51 +03:00
|
|
|
disko = btrfs_file_extent_disk_bytenr(leaf,
|
|
|
|
|
extent);
|
|
|
|
|
diskl = btrfs_file_extent_disk_num_bytes(leaf,
|
|
|
|
|
extent);
|
2008-11-12 22:32:25 +03:00
|
|
|
datao = btrfs_file_extent_offset(leaf, extent);
|
2009-01-06 05:25:51 +03:00
|
|
|
datal = btrfs_file_extent_num_bytes(leaf,
|
|
|
|
|
extent);
|
2008-11-12 22:32:25 +03:00
|
|
|
} else if (type == BTRFS_FILE_EXTENT_INLINE) {
|
|
|
|
|
/* take upper bound, may be compressed */
|
|
|
|
|
datal = btrfs_file_extent_ram_bytes(leaf,
|
|
|
|
|
extent);
|
|
|
|
|
}
|
2008-09-23 21:14:14 +04:00
|
|
|
|
2014-05-31 05:31:05 +04:00
|
|
|
/*
|
|
|
|
|
* The first search might have left us at an extent
|
|
|
|
|
* item that ends before our target range's start, can
|
|
|
|
|
* happen if we have holes and NO_HOLES feature enabled.
|
|
|
|
|
*/
|
|
|
|
|
if (key.offset + datal <= off) {
|
2014-01-13 23:35:01 +04:00
|
|
|
path->slots[0]++;
|
|
|
|
|
goto process_slot;
|
2014-05-31 05:31:05 +04:00
|
|
|
} else if (key.offset >= off + len) {
|
|
|
|
|
break;
|
2014-01-13 23:35:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size = btrfs_item_size_nr(leaf, slot);
|
|
|
|
|
read_extent_buffer(leaf, buf,
|
|
|
|
|
btrfs_item_ptr_offset(leaf, slot),
|
|
|
|
|
size);
|
|
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
path->leave_spinning = 0;
|
2008-11-12 22:32:25 +03:00
|
|
|
|
2008-09-23 21:14:14 +04:00
|
|
|
memcpy(&new_key, &key, sizeof(new_key));
|
2011-04-20 06:31:50 +04:00
|
|
|
new_key.objectid = btrfs_ino(inode);
|
2011-01-26 09:10:43 +03:00
|
|
|
if (off <= key.offset)
|
|
|
|
|
new_key.offset = key.offset + destoff - off;
|
|
|
|
|
else
|
|
|
|
|
new_key.offset = destoff;
|
2008-09-23 21:14:14 +04:00
|
|
|
|
2014-06-01 04:50:28 +04:00
|
|
|
/*
|
|
|
|
|
* Deal with a hole that doesn't have an extent item
|
|
|
|
|
* that represents it (NO_HOLES feature enabled).
|
|
|
|
|
* This hole is either in the middle of the cloning
|
|
|
|
|
* range or at the beginning (fully overlaps it or
|
|
|
|
|
* partially overlaps it).
|
|
|
|
|
*/
|
|
|
|
|
if (new_key.offset != last_dest_end)
|
|
|
|
|
drop_start = last_dest_end;
|
|
|
|
|
else
|
|
|
|
|
drop_start = new_key.offset;
|
|
|
|
|
|
2011-09-20 22:48:51 +04:00
|
|
|
/*
|
|
|
|
|
* 1 - adjusting old extent (we may have to split it)
|
|
|
|
|
* 1 - add new extent
|
|
|
|
|
* 1 - inode update
|
|
|
|
|
*/
|
|
|
|
|
trans = btrfs_start_transaction(root, 3);
|
2010-05-16 18:48:46 +04:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-28 05:07:03 +04:00
|
|
|
if (type == BTRFS_FILE_EXTENT_REG ||
|
|
|
|
|
type == BTRFS_FILE_EXTENT_PREALLOC) {
|
2011-09-11 18:52:25 +04:00
|
|
|
/*
|
|
|
|
|
* a | --- range to clone ---| b
|
|
|
|
|
* | ------------- extent ------------- |
|
|
|
|
|
*/
|
|
|
|
|
|
2014-06-04 16:03:48 +04:00
|
|
|
/* subtract range b */
|
2011-09-11 18:52:25 +04:00
|
|
|
if (key.offset + datal > off + len)
|
|
|
|
|
datal = off + len - key.offset;
|
|
|
|
|
|
2014-06-04 16:03:48 +04:00
|
|
|
/* subtract range a */
|
2010-05-16 18:48:46 +04:00
|
|
|
if (off > key.offset) {
|
|
|
|
|
datao += off - key.offset;
|
|
|
|
|
datal -= off - key.offset;
|
|
|
|
|
}
|
|
|
|
|
|
Btrfs: turbo charge fsync
At least for the vm workload. Currently on fsync we will
1) Truncate all items in the log tree for the given inode if they exist
and
2) Copy all items for a given inode into the log
The problem with this is that for things like VMs you can have lots of
extents from the fragmented writing behavior, and worst yet you may have
only modified a few extents, not the entire thing. This patch fixes this
problem by tracking which transid modified our extent, and then when we do
the tree logging we find all of the extents we've modified in our current
transaction, sort them and commit them. We also only truncate up to the
xattrs of the inode and copy that stuff in normally, and then just drop any
extents in the range we have that exist in the log already. Here are some
numbers of a 50 meg fio job that does random writes and fsync()s after every
write
Original Patched
SATA drive 82KB/s 140KB/s
Fusion drive 431KB/s 2532KB/s
So around 2-6 times faster depending on your hardware. There are a few
corner cases, for example if you truncate at all we have to do it the old
way since there is no way to be sure what is in the log is ok. This
probably could be done smarter, but if you write-fsync-truncate-write-fsync
you deserve what you get. All this work is in RAM of course so if your
inode gets evicted from cache and you read it in and fsync it we'll do it
the slow way if we are still in the same transaction that we last modified
the inode in.
The biggest cool part of this is that it requires no changes to the recovery
code, so if you fsync with this patch and crash and load an old kernel, it
will run the recovery and be a-ok. I have tested this pretty thoroughly
with an fsync tester and everything comes back fine, as well as xfstests.
Thanks,
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2012-08-17 21:14:17 +04:00
|
|
|
ret = btrfs_drop_extents(trans, root, inode,
|
2014-06-01 04:50:28 +04:00
|
|
|
drop_start,
|
2010-05-16 18:48:46 +04:00
|
|
|
new_key.offset + datal,
|
2012-08-29 20:24:27 +04:00
|
|
|
1);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
2014-04-15 20:50:17 +04:00
|
|
|
if (ret != -EOPNOTSUPP)
|
2014-03-10 14:56:07 +04:00
|
|
|
btrfs_abort_transaction(trans,
|
|
|
|
|
root, ret);
|
2012-03-12 19:03:00 +04:00
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2010-05-16 18:48:46 +04:00
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
ret = btrfs_insert_empty_item(trans, root, path,
|
|
|
|
|
&new_key, size);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
|
|
|
|
btrfs_abort_transaction(trans, root,
|
|
|
|
|
ret);
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2008-11-12 22:32:25 +03:00
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
write_extent_buffer(leaf, buf,
|
2008-09-23 21:14:14 +04:00
|
|
|
btrfs_item_ptr_offset(leaf, slot),
|
|
|
|
|
size);
|
2008-08-05 07:23:47 +04:00
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
extent = btrfs_item_ptr(leaf, slot,
|
2008-06-12 05:53:53 +04:00
|
|
|
struct btrfs_file_extent_item);
|
2008-11-12 22:32:25 +03:00
|
|
|
|
|
|
|
|
/* disko == 0 means it's a hole */
|
|
|
|
|
if (!disko)
|
|
|
|
|
datao = 0;
|
|
|
|
|
|
|
|
|
|
btrfs_set_file_extent_offset(leaf, extent,
|
|
|
|
|
datao);
|
|
|
|
|
btrfs_set_file_extent_num_bytes(leaf, extent,
|
|
|
|
|
datal);
|
2014-05-14 04:30:47 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We need to look up the roots that point at
|
|
|
|
|
* this bytenr and see if the new root does. If
|
|
|
|
|
* it does not we need to make sure we update
|
|
|
|
|
* quotas appropriately.
|
|
|
|
|
*/
|
|
|
|
|
if (disko && root != BTRFS_I(src)->root &&
|
|
|
|
|
disko != last_disko) {
|
|
|
|
|
no_quota = check_ref(trans, root,
|
|
|
|
|
disko);
|
|
|
|
|
if (no_quota < 0) {
|
|
|
|
|
btrfs_abort_transaction(trans,
|
|
|
|
|
root,
|
|
|
|
|
ret);
|
|
|
|
|
btrfs_end_transaction(trans,
|
|
|
|
|
root);
|
|
|
|
|
ret = no_quota;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
if (disko) {
|
|
|
|
|
inode_add_bytes(inode, datal);
|
2008-08-05 07:23:47 +04:00
|
|
|
ret = btrfs_inc_extent_ref(trans, root,
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 18:45:14 +04:00
|
|
|
disko, diskl, 0,
|
|
|
|
|
root->root_key.objectid,
|
2011-04-20 06:31:50 +04:00
|
|
|
btrfs_ino(inode),
|
2011-09-12 17:26:38 +04:00
|
|
|
new_key.offset - datao,
|
2014-05-14 04:30:47 +04:00
|
|
|
no_quota);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
|
|
|
|
btrfs_abort_transaction(trans,
|
|
|
|
|
root,
|
|
|
|
|
ret);
|
|
|
|
|
btrfs_end_transaction(trans,
|
|
|
|
|
root);
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
2008-11-12 22:32:25 +03:00
|
|
|
} else if (type == BTRFS_FILE_EXTENT_INLINE) {
|
|
|
|
|
u64 skip = 0;
|
|
|
|
|
u64 trim = 0;
|
2014-05-09 06:01:02 +04:00
|
|
|
u64 aligned_end = 0;
|
|
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
if (off > key.offset) {
|
|
|
|
|
skip = off - key.offset;
|
|
|
|
|
new_key.offset += skip;
|
|
|
|
|
}
|
2009-01-06 05:25:51 +03:00
|
|
|
|
2012-09-18 13:52:23 +04:00
|
|
|
if (key.offset + datal > off + len)
|
|
|
|
|
trim = key.offset + datal - (off + len);
|
2009-01-06 05:25:51 +03:00
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
if (comp && (skip || trim)) {
|
|
|
|
|
ret = -EINVAL;
|
2010-05-16 18:48:46 +04:00
|
|
|
btrfs_end_transaction(trans, root);
|
2008-11-12 22:32:25 +03:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
size -= skip + trim;
|
|
|
|
|
datal -= skip + trim;
|
2010-05-16 18:48:46 +04:00
|
|
|
|
2014-05-09 06:01:02 +04:00
|
|
|
aligned_end = ALIGN(new_key.offset + datal,
|
|
|
|
|
root->sectorsize);
|
Btrfs: turbo charge fsync
At least for the vm workload. Currently on fsync we will
1) Truncate all items in the log tree for the given inode if they exist
and
2) Copy all items for a given inode into the log
The problem with this is that for things like VMs you can have lots of
extents from the fragmented writing behavior, and worst yet you may have
only modified a few extents, not the entire thing. This patch fixes this
problem by tracking which transid modified our extent, and then when we do
the tree logging we find all of the extents we've modified in our current
transaction, sort them and commit them. We also only truncate up to the
xattrs of the inode and copy that stuff in normally, and then just drop any
extents in the range we have that exist in the log already. Here are some
numbers of a 50 meg fio job that does random writes and fsync()s after every
write
Original Patched
SATA drive 82KB/s 140KB/s
Fusion drive 431KB/s 2532KB/s
So around 2-6 times faster depending on your hardware. There are a few
corner cases, for example if you truncate at all we have to do it the old
way since there is no way to be sure what is in the log is ok. This
probably could be done smarter, but if you write-fsync-truncate-write-fsync
you deserve what you get. All this work is in RAM of course so if your
inode gets evicted from cache and you read it in and fsync it we'll do it
the slow way if we are still in the same transaction that we last modified
the inode in.
The biggest cool part of this is that it requires no changes to the recovery
code, so if you fsync with this patch and crash and load an old kernel, it
will run the recovery and be a-ok. I have tested this pretty thoroughly
with an fsync tester and everything comes back fine, as well as xfstests.
Thanks,
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2012-08-17 21:14:17 +04:00
|
|
|
ret = btrfs_drop_extents(trans, root, inode,
|
2014-06-01 04:50:28 +04:00
|
|
|
drop_start,
|
2014-05-09 06:01:02 +04:00
|
|
|
aligned_end,
|
2012-08-29 20:24:27 +04:00
|
|
|
1);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
2014-04-15 20:50:17 +04:00
|
|
|
if (ret != -EOPNOTSUPP)
|
2014-04-07 18:10:40 +04:00
|
|
|
btrfs_abort_transaction(trans,
|
|
|
|
|
root, ret);
|
2012-03-12 19:03:00 +04:00
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2010-05-16 18:48:46 +04:00
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
ret = btrfs_insert_empty_item(trans, root, path,
|
|
|
|
|
&new_key, size);
|
2012-03-12 19:03:00 +04:00
|
|
|
if (ret) {
|
|
|
|
|
btrfs_abort_transaction(trans, root,
|
|
|
|
|
ret);
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2008-11-12 22:32:25 +03:00
|
|
|
|
|
|
|
|
if (skip) {
|
2009-01-06 05:25:51 +03:00
|
|
|
u32 start =
|
|
|
|
|
btrfs_file_extent_calc_inline_size(0);
|
2008-11-12 22:32:25 +03:00
|
|
|
memmove(buf+start, buf+start+skip,
|
|
|
|
|
datal);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
write_extent_buffer(leaf, buf,
|
|
|
|
|
btrfs_item_ptr_offset(leaf, slot),
|
|
|
|
|
size);
|
|
|
|
|
inode_add_bytes(inode, datal);
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
2008-11-12 22:32:25 +03:00
|
|
|
|
2014-06-09 06:48:05 +04:00
|
|
|
/* If we have an implicit hole (NO_HOLES feature). */
|
|
|
|
|
if (drop_start < new_key.offset)
|
|
|
|
|
clone_update_extent_map(inode, trans,
|
2014-06-30 00:45:40 +04:00
|
|
|
NULL, drop_start,
|
2014-06-09 06:48:05 +04:00
|
|
|
new_key.offset - drop_start);
|
|
|
|
|
|
2014-06-30 00:45:40 +04:00
|
|
|
clone_update_extent_map(inode, trans, path, 0, 0);
|
2014-06-09 06:48:05 +04:00
|
|
|
|
2008-11-12 22:32:25 +03:00
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
2011-04-21 03:20:15 +04:00
|
|
|
btrfs_release_path(path);
|
2008-11-12 22:32:25 +03:00
|
|
|
|
2014-08-08 05:47:06 +04:00
|
|
|
last_dest_end = ALIGN(new_key.offset + datal,
|
|
|
|
|
root->sectorsize);
|
2014-06-01 04:50:28 +04:00
|
|
|
ret = clone_finish_inode_update(trans, inode,
|
|
|
|
|
last_dest_end,
|
|
|
|
|
destoff, olen);
|
|
|
|
|
if (ret)
|
2012-03-12 19:03:00 +04:00
|
|
|
goto out;
|
2014-05-31 05:31:05 +04:00
|
|
|
if (new_key.offset + datal >= destoff + len)
|
|
|
|
|
break;
|
2010-05-16 18:48:46 +04:00
|
|
|
}
|
2011-04-21 03:20:15 +04:00
|
|
|
btrfs_release_path(path);
|
2008-06-12 05:53:53 +04:00
|
|
|
key.offset++;
|
|
|
|
|
}
|
|
|
|
|
ret = 0;
|
2013-08-06 22:42:49 +04:00
|
|
|
|
2014-06-01 04:50:28 +04:00
|
|
|
if (last_dest_end < destoff + len) {
|
|
|
|
|
/*
|
|
|
|
|
* We have an implicit hole (NO_HOLES feature is enabled) that
|
|
|
|
|
* fully or partially overlaps our cloning range at its end.
|
|
|
|
|
*/
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 1 - remove extent(s)
|
|
|
|
|
* 1 - inode update
|
|
|
|
|
*/
|
|
|
|
|
trans = btrfs_start_transaction(root, 2);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
ret = btrfs_drop_extents(trans, root, inode,
|
|
|
|
|
last_dest_end, destoff + len, 1);
|
|
|
|
|
if (ret) {
|
|
|
|
|
if (ret != -EOPNOTSUPP)
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2014-06-30 00:45:40 +04:00
|
|
|
clone_update_extent_map(inode, trans, NULL, last_dest_end,
|
|
|
|
|
destoff + len - last_dest_end);
|
2014-06-01 04:50:28 +04:00
|
|
|
ret = clone_finish_inode_update(trans, inode, destoff + len,
|
|
|
|
|
destoff, olen);
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
out:
|
2013-08-06 22:42:49 +04:00
|
|
|
btrfs_free_path(path);
|
|
|
|
|
vfree(buf);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
|
|
|
|
|
u64 off, u64 olen, u64 destoff)
|
|
|
|
|
{
|
2013-09-01 23:57:51 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2013-08-06 22:42:49 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
struct fd src_file;
|
|
|
|
|
struct inode *src;
|
|
|
|
|
int ret;
|
|
|
|
|
u64 len = olen;
|
|
|
|
|
u64 bs = root->fs_info->sb->s_blocksize;
|
|
|
|
|
int same_inode = 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* TODO:
|
|
|
|
|
* - split compressed inline extents. annoying: we need to
|
|
|
|
|
* decompress into destination's address_space (the file offset
|
|
|
|
|
* may change, so source mapping won't do), then recompress (or
|
|
|
|
|
* otherwise reinsert) a subrange.
|
2014-03-10 14:56:07 +04:00
|
|
|
*
|
|
|
|
|
* - split destination inode's inline extents. The inline extents can
|
|
|
|
|
* be either compressed or non-compressed.
|
2013-08-06 22:42:49 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* the destination must be opened for writing */
|
|
|
|
|
if (!(file->f_mode & FMODE_WRITE) || (file->f_flags & O_APPEND))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (btrfs_root_readonly(root))
|
|
|
|
|
return -EROFS;
|
|
|
|
|
|
|
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
src_file = fdget(srcfd);
|
|
|
|
|
if (!src_file.file) {
|
|
|
|
|
ret = -EBADF;
|
|
|
|
|
goto out_drop_write;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = -EXDEV;
|
|
|
|
|
if (src_file.file->f_path.mnt != file->f_path.mnt)
|
|
|
|
|
goto out_fput;
|
|
|
|
|
|
|
|
|
|
src = file_inode(src_file.file);
|
|
|
|
|
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
if (src == inode)
|
|
|
|
|
same_inode = 1;
|
|
|
|
|
|
|
|
|
|
/* the src must be open for reading */
|
|
|
|
|
if (!(src_file.file->f_mode & FMODE_READ))
|
|
|
|
|
goto out_fput;
|
|
|
|
|
|
|
|
|
|
/* don't make the dst file partly checksummed */
|
|
|
|
|
if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) !=
|
|
|
|
|
(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM))
|
|
|
|
|
goto out_fput;
|
|
|
|
|
|
|
|
|
|
ret = -EISDIR;
|
|
|
|
|
if (S_ISDIR(src->i_mode) || S_ISDIR(inode->i_mode))
|
|
|
|
|
goto out_fput;
|
|
|
|
|
|
|
|
|
|
ret = -EXDEV;
|
|
|
|
|
if (src->i_sb != inode->i_sb)
|
|
|
|
|
goto out_fput;
|
|
|
|
|
|
|
|
|
|
if (!same_inode) {
|
|
|
|
|
if (inode < src) {
|
|
|
|
|
mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT);
|
|
|
|
|
mutex_lock_nested(&src->i_mutex, I_MUTEX_CHILD);
|
|
|
|
|
} else {
|
|
|
|
|
mutex_lock_nested(&src->i_mutex, I_MUTEX_PARENT);
|
|
|
|
|
mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
mutex_lock(&src->i_mutex);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* determine range to clone */
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
if (off + len > src->i_size || off + len < off)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
if (len == 0)
|
|
|
|
|
olen = len = src->i_size - off;
|
|
|
|
|
/* if we extend to eof, continue to block boundary */
|
|
|
|
|
if (off + len == src->i_size)
|
|
|
|
|
len = ALIGN(src->i_size, bs) - off;
|
|
|
|
|
|
|
|
|
|
/* verify the end result is block aligned */
|
|
|
|
|
if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs) ||
|
|
|
|
|
!IS_ALIGNED(destoff, bs))
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
/* verify if ranges are overlapped within the same file */
|
|
|
|
|
if (same_inode) {
|
|
|
|
|
if (destoff + len > off && destoff < off + len)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (destoff > inode->i_size) {
|
|
|
|
|
ret = btrfs_cont_expand(inode, inode->i_size, destoff);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
}
|
|
|
|
|
|
Btrfs: ensure readers see new data after a clone operation
We were cleaning the clone target file range from the page cache before
we did replace the file extent items in the fs tree. This was racy,
as right after cleaning the relevant range from the page cache and before
replacing the file extent items, a read against that range could be
performed by another task and populate again the page cache with stale
data (stale after the cloning finishes). This would result in reads after
the clone operation successfully finishes to get old data (and potentially
for a very long time). Therefore evict the pages after replacing the file
extent items, so that subsequent reads will always get the new data.
Similarly, we were prone to races while cloning the file extent items
because we weren't locking the target range and wait for any existing
ordered extents against that range to complete. It was possible that
after cloning the extent items, a write operation that was performed
before the clone operation and overlaps the same range, would end up
undoing all or part of the work the clone operation did (a worker task
running inode.c:btrfs_finish_ordered_io). Therefore lock the target
range in the io tree, wait for all pending ordered extents against that
range to finish and then safely perform the cloning.
The issue of reading stale data after the clone operation is easy to
reproduce by running the following C program in a loop until it exits
with return value 1.
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <assert.h>
#include <asm/types.h>
#include <linux/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#define SRC_FILE "/mnt/sdd/foo"
#define DST_FILE "/mnt/sdd/bar"
#define FILE_SIZE (16 * 1024)
#define PATTERN_SRC 'X'
#define PATTERN_DST 'Y'
struct btrfs_ioctl_clone_range_args {
__s64 src_fd;
__u64 src_offset, src_length;
__u64 dest_offset;
};
#define BTRFS_IOCTL_MAGIC 0x94
#define BTRFS_IOC_CLONE_RANGE _IOW(BTRFS_IOCTL_MAGIC, 13, \
struct btrfs_ioctl_clone_range_args)
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int clone_done = 0;
static int reader_ready = 0;
static int stale_data = 0;
static void *reader_loop(void *arg)
{
char buf[4096], want_buf[4096];
memset(want_buf, PATTERN_SRC, 4096);
pthread_mutex_lock(&mutex);
reader_ready = 1;
pthread_mutex_unlock(&mutex);
while (1) {
int done, fd, ret;
fd = open(DST_FILE, O_RDONLY);
assert(fd != -1);
pthread_mutex_lock(&mutex);
done = clone_done;
pthread_mutex_unlock(&mutex);
ret = read(fd, buf, 4096);
assert(ret == 4096);
close(fd);
if (done) {
ret = memcmp(buf, want_buf, 4096);
if (ret == 0) {
printf("Found new content\n");
} else {
printf("Found old content\n");
pthread_mutex_lock(&mutex);
stale_data = 1;
pthread_mutex_unlock(&mutex);
}
break;
}
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t reader;
int ret, i, fd;
struct btrfs_ioctl_clone_range_args clone_args;
int fd1, fd2;
ret = remove(SRC_FILE);
if (ret == -1 && errno != ENOENT) {
fprintf(stderr, "Error deleting src file: %s\n", strerror(errno));
return 1;
}
ret = remove(DST_FILE);
if (ret == -1 && errno != ENOENT) {
fprintf(stderr, "Error deleting dst file: %s\n", strerror(errno));
return 1;
}
fd = open(SRC_FILE, O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
assert(fd != -1);
for (i = 0; i < FILE_SIZE; i++) {
char c = PATTERN_SRC;
ret = write(fd, &c, 1);
assert(ret == 1);
}
close(fd);
fd = open(DST_FILE, O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
assert(fd != -1);
for (i = 0; i < FILE_SIZE; i++) {
char c = PATTERN_DST;
ret = write(fd, &c, 1);
assert(ret == 1);
}
close(fd);
sync();
ret = pthread_create(&reader, NULL, reader_loop, NULL);
assert(ret == 0);
while (1) {
int r;
pthread_mutex_lock(&mutex);
r = reader_ready;
pthread_mutex_unlock(&mutex);
if (r) break;
}
fd1 = open(SRC_FILE, O_RDONLY);
if (fd1 < 0) {
fprintf(stderr, "Error open src file: %s\n", strerror(errno));
return 1;
}
fd2 = open(DST_FILE, O_RDWR);
if (fd2 < 0) {
fprintf(stderr, "Error open dst file: %s\n", strerror(errno));
return 1;
}
clone_args.src_fd = fd1;
clone_args.src_offset = 0;
clone_args.src_length = 4096;
clone_args.dest_offset = 0;
ret = ioctl(fd2, BTRFS_IOC_CLONE_RANGE, &clone_args);
assert(ret == 0);
close(fd1);
close(fd2);
pthread_mutex_lock(&mutex);
clone_done = 1;
pthread_mutex_unlock(&mutex);
ret = pthread_join(reader, NULL);
assert(ret == 0);
pthread_mutex_lock(&mutex);
ret = stale_data ? 1 : 0;
pthread_mutex_unlock(&mutex);
return ret;
}
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-05-23 08:03:34 +04:00
|
|
|
/*
|
|
|
|
|
* Lock the target range too. Right after we replace the file extent
|
|
|
|
|
* items in the fs tree (which now point to the cloned data), we might
|
|
|
|
|
* have a worker replace them with extent items relative to a write
|
|
|
|
|
* operation that was issued before this clone operation (i.e. confront
|
|
|
|
|
* with inode.c:btrfs_finish_ordered_io).
|
|
|
|
|
*/
|
|
|
|
|
if (same_inode) {
|
|
|
|
|
u64 lock_start = min_t(u64, off, destoff);
|
|
|
|
|
u64 lock_len = max_t(u64, off, destoff) + len - lock_start;
|
2013-08-06 22:42:49 +04:00
|
|
|
|
Btrfs: ensure readers see new data after a clone operation
We were cleaning the clone target file range from the page cache before
we did replace the file extent items in the fs tree. This was racy,
as right after cleaning the relevant range from the page cache and before
replacing the file extent items, a read against that range could be
performed by another task and populate again the page cache with stale
data (stale after the cloning finishes). This would result in reads after
the clone operation successfully finishes to get old data (and potentially
for a very long time). Therefore evict the pages after replacing the file
extent items, so that subsequent reads will always get the new data.
Similarly, we were prone to races while cloning the file extent items
because we weren't locking the target range and wait for any existing
ordered extents against that range to complete. It was possible that
after cloning the extent items, a write operation that was performed
before the clone operation and overlaps the same range, would end up
undoing all or part of the work the clone operation did (a worker task
running inode.c:btrfs_finish_ordered_io). Therefore lock the target
range in the io tree, wait for all pending ordered extents against that
range to finish and then safely perform the cloning.
The issue of reading stale data after the clone operation is easy to
reproduce by running the following C program in a loop until it exits
with return value 1.
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <assert.h>
#include <asm/types.h>
#include <linux/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#define SRC_FILE "/mnt/sdd/foo"
#define DST_FILE "/mnt/sdd/bar"
#define FILE_SIZE (16 * 1024)
#define PATTERN_SRC 'X'
#define PATTERN_DST 'Y'
struct btrfs_ioctl_clone_range_args {
__s64 src_fd;
__u64 src_offset, src_length;
__u64 dest_offset;
};
#define BTRFS_IOCTL_MAGIC 0x94
#define BTRFS_IOC_CLONE_RANGE _IOW(BTRFS_IOCTL_MAGIC, 13, \
struct btrfs_ioctl_clone_range_args)
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int clone_done = 0;
static int reader_ready = 0;
static int stale_data = 0;
static void *reader_loop(void *arg)
{
char buf[4096], want_buf[4096];
memset(want_buf, PATTERN_SRC, 4096);
pthread_mutex_lock(&mutex);
reader_ready = 1;
pthread_mutex_unlock(&mutex);
while (1) {
int done, fd, ret;
fd = open(DST_FILE, O_RDONLY);
assert(fd != -1);
pthread_mutex_lock(&mutex);
done = clone_done;
pthread_mutex_unlock(&mutex);
ret = read(fd, buf, 4096);
assert(ret == 4096);
close(fd);
if (done) {
ret = memcmp(buf, want_buf, 4096);
if (ret == 0) {
printf("Found new content\n");
} else {
printf("Found old content\n");
pthread_mutex_lock(&mutex);
stale_data = 1;
pthread_mutex_unlock(&mutex);
}
break;
}
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t reader;
int ret, i, fd;
struct btrfs_ioctl_clone_range_args clone_args;
int fd1, fd2;
ret = remove(SRC_FILE);
if (ret == -1 && errno != ENOENT) {
fprintf(stderr, "Error deleting src file: %s\n", strerror(errno));
return 1;
}
ret = remove(DST_FILE);
if (ret == -1 && errno != ENOENT) {
fprintf(stderr, "Error deleting dst file: %s\n", strerror(errno));
return 1;
}
fd = open(SRC_FILE, O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
assert(fd != -1);
for (i = 0; i < FILE_SIZE; i++) {
char c = PATTERN_SRC;
ret = write(fd, &c, 1);
assert(ret == 1);
}
close(fd);
fd = open(DST_FILE, O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
assert(fd != -1);
for (i = 0; i < FILE_SIZE; i++) {
char c = PATTERN_DST;
ret = write(fd, &c, 1);
assert(ret == 1);
}
close(fd);
sync();
ret = pthread_create(&reader, NULL, reader_loop, NULL);
assert(ret == 0);
while (1) {
int r;
pthread_mutex_lock(&mutex);
r = reader_ready;
pthread_mutex_unlock(&mutex);
if (r) break;
}
fd1 = open(SRC_FILE, O_RDONLY);
if (fd1 < 0) {
fprintf(stderr, "Error open src file: %s\n", strerror(errno));
return 1;
}
fd2 = open(DST_FILE, O_RDWR);
if (fd2 < 0) {
fprintf(stderr, "Error open dst file: %s\n", strerror(errno));
return 1;
}
clone_args.src_fd = fd1;
clone_args.src_offset = 0;
clone_args.src_length = 4096;
clone_args.dest_offset = 0;
ret = ioctl(fd2, BTRFS_IOC_CLONE_RANGE, &clone_args);
assert(ret == 0);
close(fd1);
close(fd2);
pthread_mutex_lock(&mutex);
clone_done = 1;
pthread_mutex_unlock(&mutex);
ret = pthread_join(reader, NULL);
assert(ret == 0);
pthread_mutex_lock(&mutex);
ret = stale_data ? 1 : 0;
pthread_mutex_unlock(&mutex);
return ret;
}
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-05-23 08:03:34 +04:00
|
|
|
lock_extent_range(src, lock_start, lock_len);
|
|
|
|
|
} else {
|
|
|
|
|
lock_extent_range(src, off, len);
|
|
|
|
|
lock_extent_range(inode, destoff, len);
|
|
|
|
|
}
|
2013-08-06 22:42:49 +04:00
|
|
|
|
|
|
|
|
ret = btrfs_clone(src, inode, off, olen, len, destoff);
|
|
|
|
|
|
Btrfs: ensure readers see new data after a clone operation
We were cleaning the clone target file range from the page cache before
we did replace the file extent items in the fs tree. This was racy,
as right after cleaning the relevant range from the page cache and before
replacing the file extent items, a read against that range could be
performed by another task and populate again the page cache with stale
data (stale after the cloning finishes). This would result in reads after
the clone operation successfully finishes to get old data (and potentially
for a very long time). Therefore evict the pages after replacing the file
extent items, so that subsequent reads will always get the new data.
Similarly, we were prone to races while cloning the file extent items
because we weren't locking the target range and wait for any existing
ordered extents against that range to complete. It was possible that
after cloning the extent items, a write operation that was performed
before the clone operation and overlaps the same range, would end up
undoing all or part of the work the clone operation did (a worker task
running inode.c:btrfs_finish_ordered_io). Therefore lock the target
range in the io tree, wait for all pending ordered extents against that
range to finish and then safely perform the cloning.
The issue of reading stale data after the clone operation is easy to
reproduce by running the following C program in a loop until it exits
with return value 1.
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <assert.h>
#include <asm/types.h>
#include <linux/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#define SRC_FILE "/mnt/sdd/foo"
#define DST_FILE "/mnt/sdd/bar"
#define FILE_SIZE (16 * 1024)
#define PATTERN_SRC 'X'
#define PATTERN_DST 'Y'
struct btrfs_ioctl_clone_range_args {
__s64 src_fd;
__u64 src_offset, src_length;
__u64 dest_offset;
};
#define BTRFS_IOCTL_MAGIC 0x94
#define BTRFS_IOC_CLONE_RANGE _IOW(BTRFS_IOCTL_MAGIC, 13, \
struct btrfs_ioctl_clone_range_args)
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int clone_done = 0;
static int reader_ready = 0;
static int stale_data = 0;
static void *reader_loop(void *arg)
{
char buf[4096], want_buf[4096];
memset(want_buf, PATTERN_SRC, 4096);
pthread_mutex_lock(&mutex);
reader_ready = 1;
pthread_mutex_unlock(&mutex);
while (1) {
int done, fd, ret;
fd = open(DST_FILE, O_RDONLY);
assert(fd != -1);
pthread_mutex_lock(&mutex);
done = clone_done;
pthread_mutex_unlock(&mutex);
ret = read(fd, buf, 4096);
assert(ret == 4096);
close(fd);
if (done) {
ret = memcmp(buf, want_buf, 4096);
if (ret == 0) {
printf("Found new content\n");
} else {
printf("Found old content\n");
pthread_mutex_lock(&mutex);
stale_data = 1;
pthread_mutex_unlock(&mutex);
}
break;
}
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t reader;
int ret, i, fd;
struct btrfs_ioctl_clone_range_args clone_args;
int fd1, fd2;
ret = remove(SRC_FILE);
if (ret == -1 && errno != ENOENT) {
fprintf(stderr, "Error deleting src file: %s\n", strerror(errno));
return 1;
}
ret = remove(DST_FILE);
if (ret == -1 && errno != ENOENT) {
fprintf(stderr, "Error deleting dst file: %s\n", strerror(errno));
return 1;
}
fd = open(SRC_FILE, O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
assert(fd != -1);
for (i = 0; i < FILE_SIZE; i++) {
char c = PATTERN_SRC;
ret = write(fd, &c, 1);
assert(ret == 1);
}
close(fd);
fd = open(DST_FILE, O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
assert(fd != -1);
for (i = 0; i < FILE_SIZE; i++) {
char c = PATTERN_DST;
ret = write(fd, &c, 1);
assert(ret == 1);
}
close(fd);
sync();
ret = pthread_create(&reader, NULL, reader_loop, NULL);
assert(ret == 0);
while (1) {
int r;
pthread_mutex_lock(&mutex);
r = reader_ready;
pthread_mutex_unlock(&mutex);
if (r) break;
}
fd1 = open(SRC_FILE, O_RDONLY);
if (fd1 < 0) {
fprintf(stderr, "Error open src file: %s\n", strerror(errno));
return 1;
}
fd2 = open(DST_FILE, O_RDWR);
if (fd2 < 0) {
fprintf(stderr, "Error open dst file: %s\n", strerror(errno));
return 1;
}
clone_args.src_fd = fd1;
clone_args.src_offset = 0;
clone_args.src_length = 4096;
clone_args.dest_offset = 0;
ret = ioctl(fd2, BTRFS_IOC_CLONE_RANGE, &clone_args);
assert(ret == 0);
close(fd1);
close(fd2);
pthread_mutex_lock(&mutex);
clone_done = 1;
pthread_mutex_unlock(&mutex);
ret = pthread_join(reader, NULL);
assert(ret == 0);
pthread_mutex_lock(&mutex);
ret = stale_data ? 1 : 0;
pthread_mutex_unlock(&mutex);
return ret;
}
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-05-23 08:03:34 +04:00
|
|
|
if (same_inode) {
|
|
|
|
|
u64 lock_start = min_t(u64, off, destoff);
|
|
|
|
|
u64 lock_end = max_t(u64, off, destoff) + len - 1;
|
|
|
|
|
|
|
|
|
|
unlock_extent(&BTRFS_I(src)->io_tree, lock_start, lock_end);
|
|
|
|
|
} else {
|
|
|
|
|
unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
|
|
|
|
|
unlock_extent(&BTRFS_I(inode)->io_tree, destoff,
|
|
|
|
|
destoff + len - 1);
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* Truncate page cache pages so that future reads will see the cloned
|
|
|
|
|
* data immediately and not the previous data.
|
|
|
|
|
*/
|
|
|
|
|
truncate_inode_pages_range(&inode->i_data, destoff,
|
|
|
|
|
PAGE_CACHE_ALIGN(destoff + len) - 1);
|
2008-06-12 05:53:53 +04:00
|
|
|
out_unlock:
|
2014-01-12 01:31:25 +04:00
|
|
|
if (!same_inode) {
|
|
|
|
|
if (inode < src) {
|
|
|
|
|
mutex_unlock(&src->i_mutex);
|
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
|
} else {
|
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
|
mutex_unlock(&src->i_mutex);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
mutex_unlock(&src->i_mutex);
|
|
|
|
|
}
|
2008-06-12 05:53:53 +04:00
|
|
|
out_fput:
|
2012-08-28 20:52:22 +04:00
|
|
|
fdput(src_file);
|
2008-12-19 18:58:39 +03:00
|
|
|
out_drop_write:
|
2011-12-09 17:06:57 +04:00
|
|
|
mnt_drop_write_file(file);
|
2008-06-12 05:53:53 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-02 17:52:24 +03:00
|
|
|
static long btrfs_ioctl_clone_range(struct file *file, void __user *argp)
|
2008-11-12 22:32:25 +03:00
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_clone_range_args args;
|
|
|
|
|
|
2008-12-02 17:52:24 +03:00
|
|
|
if (copy_from_user(&args, argp, sizeof(args)))
|
2008-11-12 22:32:25 +03:00
|
|
|
return -EFAULT;
|
|
|
|
|
return btrfs_ioctl_clone(file, args.src_fd, args.src_offset,
|
|
|
|
|
args.src_length, args.dest_offset);
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
/*
|
|
|
|
|
* there are many ways the trans_start and trans_end ioctls can lead
|
|
|
|
|
* to deadlocks. They should only be used by applications that
|
|
|
|
|
* basically own the machine, and have a very in depth understanding
|
|
|
|
|
* of all the possible deadlocks and enospc problems.
|
|
|
|
|
*/
|
2008-12-02 17:54:17 +03:00
|
|
|
static long btrfs_ioctl_trans_start(struct file *file)
|
2008-06-12 05:53:53 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2008-06-12 05:53:53 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
2009-09-30 02:38:44 +04:00
|
|
|
int ret;
|
2008-06-12 05:53:53 +04:00
|
|
|
|
2009-09-30 02:38:44 +04:00
|
|
|
ret = -EPERM;
|
2008-06-12 05:53:58 +04:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
2009-09-30 02:38:44 +04:00
|
|
|
goto out;
|
2008-06-12 05:53:58 +04:00
|
|
|
|
2009-09-30 02:38:44 +04:00
|
|
|
ret = -EINPROGRESS;
|
|
|
|
|
if (file->private_data)
|
2008-06-12 05:53:53 +04:00
|
|
|
goto out;
|
2008-08-04 18:41:27 +04:00
|
|
|
|
2010-12-20 11:04:08 +03:00
|
|
|
ret = -EROFS;
|
|
|
|
|
if (btrfs_root_readonly(root))
|
|
|
|
|
goto out;
|
|
|
|
|
|
2011-11-23 20:57:51 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
2008-11-12 22:34:12 +03:00
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2011-04-12 01:25:13 +04:00
|
|
|
atomic_inc(&root->fs_info->open_ioctl_trans);
|
2008-08-04 18:41:27 +04:00
|
|
|
|
2009-09-30 02:38:44 +04:00
|
|
|
ret = -ENOMEM;
|
2011-04-13 20:54:33 +04:00
|
|
|
trans = btrfs_start_ioctl_transaction(root);
|
2011-01-24 03:57:10 +03:00
|
|
|
if (IS_ERR(trans))
|
2009-09-30 02:38:44 +04:00
|
|
|
goto out_drop;
|
|
|
|
|
|
|
|
|
|
file->private_data = trans;
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
out_drop:
|
2011-04-12 01:25:13 +04:00
|
|
|
atomic_dec(&root->fs_info->open_ioctl_trans);
|
2011-12-09 17:06:57 +04:00
|
|
|
mnt_drop_write_file(file);
|
2008-06-12 05:53:53 +04:00
|
|
|
out:
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-12 00:11:29 +03:00
|
|
|
static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
|
|
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2009-12-12 00:11:29 +03:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
struct btrfs_root *new_root;
|
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
struct btrfs_path *path;
|
|
|
|
|
struct btrfs_key location;
|
|
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
u64 objectid = 0;
|
|
|
|
|
u64 dir_id;
|
2012-11-26 12:43:07 +04:00
|
|
|
int ret;
|
2009-12-12 00:11:29 +03:00
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-26 12:43:07 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&objectid, argp, sizeof(objectid))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2009-12-12 00:11:29 +03:00
|
|
|
|
|
|
|
|
if (!objectid)
|
2013-09-13 18:04:10 +04:00
|
|
|
objectid = BTRFS_FS_TREE_OBJECTID;
|
2009-12-12 00:11:29 +03:00
|
|
|
|
|
|
|
|
location.objectid = objectid;
|
|
|
|
|
location.type = BTRFS_ROOT_ITEM_KEY;
|
|
|
|
|
location.offset = (u64)-1;
|
|
|
|
|
|
|
|
|
|
new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
|
2012-11-26 12:43:07 +04:00
|
|
|
if (IS_ERR(new_root)) {
|
|
|
|
|
ret = PTR_ERR(new_root);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2009-12-12 00:11:29 +03:00
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2012-11-26 12:43:07 +04:00
|
|
|
if (!path) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2009-12-12 00:11:29 +03:00
|
|
|
path->leave_spinning = 1;
|
|
|
|
|
|
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
2011-01-20 09:19:37 +03:00
|
|
|
if (IS_ERR(trans)) {
|
2009-12-12 00:11:29 +03:00
|
|
|
btrfs_free_path(path);
|
2012-11-26 12:43:07 +04:00
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out;
|
2009-12-12 00:11:29 +03:00
|
|
|
}
|
|
|
|
|
|
2011-04-13 17:41:04 +04:00
|
|
|
dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
|
2009-12-12 00:11:29 +03:00
|
|
|
di = btrfs_lookup_dir_item(trans, root->fs_info->tree_root, path,
|
|
|
|
|
dir_id, "default", 7, 1);
|
2010-05-29 13:47:24 +04:00
|
|
|
if (IS_ERR_OR_NULL(di)) {
|
2009-12-12 00:11:29 +03:00
|
|
|
btrfs_free_path(path);
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
2013-12-20 20:37:06 +04:00
|
|
|
btrfs_err(new_root->fs_info, "Umm, you don't have the default dir"
|
|
|
|
|
"item, this isn't going to work");
|
2012-11-26 12:43:07 +04:00
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto out;
|
2009-12-12 00:11:29 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key);
|
|
|
|
|
btrfs_set_dir_item_key(path->nodes[0], di, &disk_key);
|
|
|
|
|
btrfs_mark_buffer_dirty(path->nodes[0]);
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
|
2012-07-24 21:58:43 +04:00
|
|
|
btrfs_set_fs_incompat(root->fs_info, DEFAULT_SUBVOL);
|
2009-12-12 00:11:29 +03:00
|
|
|
btrfs_end_transaction(trans, root);
|
2012-11-26 12:43:07 +04:00
|
|
|
out:
|
|
|
|
|
mnt_drop_write_file(file);
|
|
|
|
|
return ret;
|
2009-12-12 00:11:29 +03:00
|
|
|
}
|
|
|
|
|
|
2012-08-01 20:56:49 +04:00
|
|
|
void btrfs_get_block_group_info(struct list_head *groups_list,
|
|
|
|
|
struct btrfs_ioctl_space_info *space)
|
2010-09-29 19:22:36 +04:00
|
|
|
{
|
|
|
|
|
struct btrfs_block_group_cache *block_group;
|
|
|
|
|
|
|
|
|
|
space->total_bytes = 0;
|
|
|
|
|
space->used_bytes = 0;
|
|
|
|
|
space->flags = 0;
|
|
|
|
|
list_for_each_entry(block_group, groups_list, list) {
|
|
|
|
|
space->flags = block_group->flags;
|
|
|
|
|
space->total_bytes += block_group->key.offset;
|
|
|
|
|
space->used_bytes +=
|
|
|
|
|
btrfs_block_group_used(&block_group->item);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-26 00:41:01 +04:00
|
|
|
static long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg)
|
2010-01-13 21:19:06 +03:00
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_space_args space_args;
|
|
|
|
|
struct btrfs_ioctl_space_info space;
|
|
|
|
|
struct btrfs_ioctl_space_info *dest;
|
2010-03-16 22:40:10 +03:00
|
|
|
struct btrfs_ioctl_space_info *dest_orig;
|
2011-04-11 19:56:31 +04:00
|
|
|
struct btrfs_ioctl_space_info __user *user_dest;
|
2010-01-13 21:19:06 +03:00
|
|
|
struct btrfs_space_info *info;
|
2010-09-29 19:22:36 +04:00
|
|
|
u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
|
|
|
|
|
BTRFS_BLOCK_GROUP_SYSTEM,
|
|
|
|
|
BTRFS_BLOCK_GROUP_METADATA,
|
|
|
|
|
BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
|
|
|
|
|
int num_types = 4;
|
2010-03-16 22:40:10 +03:00
|
|
|
int alloc_size;
|
2010-01-13 21:19:06 +03:00
|
|
|
int ret = 0;
|
2011-02-15 00:04:23 +03:00
|
|
|
u64 slot_count = 0;
|
2010-09-29 19:22:36 +04:00
|
|
|
int i, c;
|
2010-01-13 21:19:06 +03:00
|
|
|
|
|
|
|
|
if (copy_from_user(&space_args,
|
|
|
|
|
(struct btrfs_ioctl_space_args __user *)arg,
|
|
|
|
|
sizeof(space_args)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2010-09-29 19:22:36 +04:00
|
|
|
for (i = 0; i < num_types; i++) {
|
|
|
|
|
struct btrfs_space_info *tmp;
|
|
|
|
|
|
|
|
|
|
info = NULL;
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
|
|
|
|
|
list) {
|
|
|
|
|
if (tmp->flags == types[i]) {
|
|
|
|
|
info = tmp;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
|
|
if (!info)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
down_read(&info->groups_sem);
|
|
|
|
|
for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
|
|
|
|
|
if (!list_empty(&info->block_groups[c]))
|
|
|
|
|
slot_count++;
|
|
|
|
|
}
|
|
|
|
|
up_read(&info->groups_sem);
|
|
|
|
|
}
|
2010-03-16 22:40:10 +03:00
|
|
|
|
2014-02-07 17:34:12 +04:00
|
|
|
/*
|
|
|
|
|
* Global block reserve, exported as a space_info
|
|
|
|
|
*/
|
|
|
|
|
slot_count++;
|
|
|
|
|
|
2010-03-16 22:40:10 +03:00
|
|
|
/* space_slots == 0 means they are asking for a count */
|
|
|
|
|
if (space_args.space_slots == 0) {
|
|
|
|
|
space_args.total_spaces = slot_count;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2010-09-29 19:22:36 +04:00
|
|
|
|
2011-02-15 00:04:23 +03:00
|
|
|
slot_count = min_t(u64, space_args.space_slots, slot_count);
|
2010-09-29 19:22:36 +04:00
|
|
|
|
2010-03-16 22:40:10 +03:00
|
|
|
alloc_size = sizeof(*dest) * slot_count;
|
2010-09-29 19:22:36 +04:00
|
|
|
|
2010-03-16 22:40:10 +03:00
|
|
|
/* we generally have at most 6 or so space infos, one for each raid
|
|
|
|
|
* level. So, a whole page should be more than enough for everyone
|
|
|
|
|
*/
|
|
|
|
|
if (alloc_size > PAGE_CACHE_SIZE)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2010-01-13 21:19:06 +03:00
|
|
|
space_args.total_spaces = 0;
|
2010-03-16 22:40:10 +03:00
|
|
|
dest = kmalloc(alloc_size, GFP_NOFS);
|
|
|
|
|
if (!dest)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
dest_orig = dest;
|
2010-01-13 21:19:06 +03:00
|
|
|
|
2010-03-16 22:40:10 +03:00
|
|
|
/* now we have a buffer to copy into */
|
2010-09-29 19:22:36 +04:00
|
|
|
for (i = 0; i < num_types; i++) {
|
|
|
|
|
struct btrfs_space_info *tmp;
|
|
|
|
|
|
2011-02-15 00:04:23 +03:00
|
|
|
if (!slot_count)
|
|
|
|
|
break;
|
|
|
|
|
|
2010-09-29 19:22:36 +04:00
|
|
|
info = NULL;
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
|
|
|
|
|
list) {
|
|
|
|
|
if (tmp->flags == types[i]) {
|
|
|
|
|
info = tmp;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
rcu_read_unlock();
|
2010-03-16 22:40:10 +03:00
|
|
|
|
2010-09-29 19:22:36 +04:00
|
|
|
if (!info)
|
|
|
|
|
continue;
|
|
|
|
|
down_read(&info->groups_sem);
|
|
|
|
|
for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
|
|
|
|
|
if (!list_empty(&info->block_groups[c])) {
|
2012-08-01 20:56:49 +04:00
|
|
|
btrfs_get_block_group_info(
|
|
|
|
|
&info->block_groups[c], &space);
|
2010-09-29 19:22:36 +04:00
|
|
|
memcpy(dest, &space, sizeof(space));
|
|
|
|
|
dest++;
|
|
|
|
|
space_args.total_spaces++;
|
2011-02-15 00:04:23 +03:00
|
|
|
slot_count--;
|
2010-09-29 19:22:36 +04:00
|
|
|
}
|
2011-02-15 00:04:23 +03:00
|
|
|
if (!slot_count)
|
|
|
|
|
break;
|
2010-09-29 19:22:36 +04:00
|
|
|
}
|
|
|
|
|
up_read(&info->groups_sem);
|
2010-01-13 21:19:06 +03:00
|
|
|
}
|
|
|
|
|
|
2014-02-07 17:34:12 +04:00
|
|
|
/*
|
|
|
|
|
* Add global block reserve
|
|
|
|
|
*/
|
|
|
|
|
if (slot_count) {
|
|
|
|
|
struct btrfs_block_rsv *block_rsv = &root->fs_info->global_block_rsv;
|
|
|
|
|
|
|
|
|
|
spin_lock(&block_rsv->lock);
|
|
|
|
|
space.total_bytes = block_rsv->size;
|
|
|
|
|
space.used_bytes = block_rsv->size - block_rsv->reserved;
|
|
|
|
|
spin_unlock(&block_rsv->lock);
|
|
|
|
|
space.flags = BTRFS_SPACE_INFO_GLOBAL_RSV;
|
|
|
|
|
memcpy(dest, &space, sizeof(space));
|
|
|
|
|
space_args.total_spaces++;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-25 20:37:14 +04:00
|
|
|
user_dest = (struct btrfs_ioctl_space_info __user *)
|
2010-03-16 22:40:10 +03:00
|
|
|
(arg + sizeof(struct btrfs_ioctl_space_args));
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(user_dest, dest_orig, alloc_size))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
kfree(dest_orig);
|
|
|
|
|
out:
|
|
|
|
|
if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args)))
|
2010-01-13 21:19:06 +03:00
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
/*
|
|
|
|
|
* there are many ways the trans_start and trans_end ioctls can lead
|
|
|
|
|
* to deadlocks. They should only be used by applications that
|
|
|
|
|
* basically own the machine, and have a very in depth understanding
|
|
|
|
|
* of all the possible deadlocks and enospc problems.
|
|
|
|
|
*/
|
|
|
|
|
long btrfs_ioctl_trans_end(struct file *file)
|
|
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2008-06-12 05:53:53 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
|
|
|
|
|
trans = file->private_data;
|
2009-09-30 02:38:44 +04:00
|
|
|
if (!trans)
|
|
|
|
|
return -EINVAL;
|
2008-09-06 00:43:31 +04:00
|
|
|
file->private_data = NULL;
|
2008-08-04 18:41:27 +04:00
|
|
|
|
2009-09-30 02:38:44 +04:00
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
|
|
2011-04-12 01:25:13 +04:00
|
|
|
atomic_dec(&root->fs_info->open_ioctl_trans);
|
2008-08-04 18:41:27 +04:00
|
|
|
|
2011-12-09 17:06:57 +04:00
|
|
|
mnt_drop_write_file(file);
|
2009-09-30 02:38:44 +04:00
|
|
|
return 0;
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:40:43 +04:00
|
|
|
static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root,
|
|
|
|
|
void __user *argp)
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-29 23:41:32 +04:00
|
|
|
{
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
u64 transid;
|
2011-03-23 11:14:16 +03:00
|
|
|
int ret;
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-29 23:41:32 +04:00
|
|
|
|
Btrfs: fix uncompleted transaction
In some cases, we need commit the current transaction, but don't want
to start a new one if there is no running transaction, so we introduce
the function - btrfs_attach_transaction(), which can catch the current
transaction, and return -ENOENT if there is no running transaction.
But no running transaction doesn't mean the current transction completely,
because we removed the running transaction before it completes. In some
cases, it doesn't matter. But in some special cases, such as freeze fs, we
hope the transaction is fully on disk, it will introduce some bugs, for
example, we may feeze the fs and dump the data in the disk, if the transction
doesn't complete, we would dump inconsistent data. So we need fix the above
problem for those cases.
We fixes this problem by introducing a function:
btrfs_attach_transaction_barrier()
if we hope all the transaction is fully on the disk, even they are not
running, we can use this function.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2013-02-20 13:17:06 +04:00
|
|
|
trans = btrfs_attach_transaction_barrier(root);
|
2012-11-26 12:41:29 +04:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
if (PTR_ERR(trans) != -ENOENT)
|
|
|
|
|
return PTR_ERR(trans);
|
|
|
|
|
|
|
|
|
|
/* No running transaction, don't bother */
|
|
|
|
|
transid = root->fs_info->last_trans_committed;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-29 23:41:32 +04:00
|
|
|
transid = trans->transid;
|
2011-03-23 11:14:16 +03:00
|
|
|
ret = btrfs_commit_transaction_async(trans, root, 0);
|
2011-04-04 05:52:13 +04:00
|
|
|
if (ret) {
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
2011-03-23 11:14:16 +03:00
|
|
|
return ret;
|
2011-04-04 05:52:13 +04:00
|
|
|
}
|
2012-11-26 12:41:29 +04:00
|
|
|
out:
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-29 23:41:32 +04:00
|
|
|
if (argp)
|
|
|
|
|
if (copy_to_user(argp, &transid, sizeof(transid)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:40:43 +04:00
|
|
|
static noinline long btrfs_ioctl_wait_sync(struct btrfs_root *root,
|
|
|
|
|
void __user *argp)
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-29 23:41:32 +04:00
|
|
|
{
|
|
|
|
|
u64 transid;
|
|
|
|
|
|
|
|
|
|
if (argp) {
|
|
|
|
|
if (copy_from_user(&transid, argp, sizeof(transid)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
} else {
|
|
|
|
|
transid = 0; /* current trans */
|
|
|
|
|
}
|
|
|
|
|
return btrfs_wait_for_commit(root, transid);
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:48:01 +04:00
|
|
|
static long btrfs_ioctl_scrub(struct file *file, void __user *arg)
|
2011-03-11 17:41:01 +03:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2011-03-11 17:41:01 +03:00
|
|
|
struct btrfs_ioctl_scrub_args *sa;
|
2012-11-26 12:48:01 +04:00
|
|
|
int ret;
|
2011-03-11 17:41:01 +03:00
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
sa = memdup_user(arg, sizeof(*sa));
|
|
|
|
|
if (IS_ERR(sa))
|
|
|
|
|
return PTR_ERR(sa);
|
|
|
|
|
|
2012-11-26 12:48:01 +04:00
|
|
|
if (!(sa->flags & BTRFS_SCRUB_READONLY)) {
|
|
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-05 20:03:39 +04:00
|
|
|
ret = btrfs_scrub_dev(root->fs_info, sa->devid, sa->start, sa->end,
|
2012-11-05 21:29:28 +04:00
|
|
|
&sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
|
|
|
|
|
0);
|
2011-03-11 17:41:01 +03:00
|
|
|
|
|
|
|
|
if (copy_to_user(arg, sa, sizeof(*sa)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
2012-11-26 12:48:01 +04:00
|
|
|
if (!(sa->flags & BTRFS_SCRUB_READONLY))
|
|
|
|
|
mnt_drop_write_file(file);
|
|
|
|
|
out:
|
2011-03-11 17:41:01 +03:00
|
|
|
kfree(sa);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long btrfs_ioctl_scrub_cancel(struct btrfs_root *root, void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-05 20:03:39 +04:00
|
|
|
return btrfs_scrub_cancel(root->fs_info);
|
2011-03-11 17:41:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long btrfs_ioctl_scrub_progress(struct btrfs_root *root,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_scrub_args *sa;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
sa = memdup_user(arg, sizeof(*sa));
|
|
|
|
|
if (IS_ERR(sa))
|
|
|
|
|
return PTR_ERR(sa);
|
|
|
|
|
|
|
|
|
|
ret = btrfs_scrub_progress(root, sa->devid, &sa->progress);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, sa, sizeof(*sa)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
kfree(sa);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-25 18:06:09 +04:00
|
|
|
static long btrfs_ioctl_get_dev_stats(struct btrfs_root *root,
|
2012-06-22 16:30:39 +04:00
|
|
|
void __user *arg)
|
2012-05-25 18:06:09 +04:00
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_get_dev_stats *sa;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
sa = memdup_user(arg, sizeof(*sa));
|
|
|
|
|
if (IS_ERR(sa))
|
|
|
|
|
return PTR_ERR(sa);
|
|
|
|
|
|
2012-06-22 16:30:39 +04:00
|
|
|
if ((sa->flags & BTRFS_DEV_STATS_RESET) && !capable(CAP_SYS_ADMIN)) {
|
|
|
|
|
kfree(sa);
|
|
|
|
|
return -EPERM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = btrfs_get_dev_stats(root, sa);
|
2012-05-25 18:06:09 +04:00
|
|
|
|
|
|
|
|
if (copy_to_user(arg, sa, sizeof(*sa)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
kfree(sa);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-06 18:08:53 +04:00
|
|
|
static long btrfs_ioctl_dev_replace(struct btrfs_root *root, void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_dev_replace_args *p;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
p = memdup_user(arg, sizeof(*p));
|
|
|
|
|
if (IS_ERR(p))
|
|
|
|
|
return PTR_ERR(p);
|
|
|
|
|
|
|
|
|
|
switch (p->cmd) {
|
|
|
|
|
case BTRFS_IOCTL_DEV_REPLACE_CMD_START:
|
2013-10-10 21:39:28 +04:00
|
|
|
if (root->fs_info->sb->s_flags & MS_RDONLY) {
|
|
|
|
|
ret = -EROFS;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2012-11-06 18:08:53 +04:00
|
|
|
if (atomic_xchg(
|
|
|
|
|
&root->fs_info->mutually_exclusive_operation_running,
|
|
|
|
|
1)) {
|
2013-08-21 07:44:48 +04:00
|
|
|
ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
|
2012-11-06 18:08:53 +04:00
|
|
|
} else {
|
|
|
|
|
ret = btrfs_dev_replace_start(root, p);
|
|
|
|
|
atomic_set(
|
|
|
|
|
&root->fs_info->mutually_exclusive_operation_running,
|
|
|
|
|
0);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS:
|
|
|
|
|
btrfs_dev_replace_status(root->fs_info, p);
|
|
|
|
|
ret = 0;
|
|
|
|
|
break;
|
|
|
|
|
case BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL:
|
|
|
|
|
ret = btrfs_dev_replace_cancel(root->fs_info, p);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, p, sizeof(*p)))
|
|
|
|
|
ret = -EFAULT;
|
2013-10-10 21:39:28 +04:00
|
|
|
out:
|
2012-11-06 18:08:53 +04:00
|
|
|
kfree(p);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-07 18:48:38 +04:00
|
|
|
static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int i;
|
2011-11-02 23:48:34 +04:00
|
|
|
u64 rel_ptr;
|
2011-07-07 18:48:38 +04:00
|
|
|
int size;
|
2011-11-06 12:07:10 +04:00
|
|
|
struct btrfs_ioctl_ino_path_args *ipa = NULL;
|
2011-07-07 18:48:38 +04:00
|
|
|
struct inode_fs_paths *ipath = NULL;
|
|
|
|
|
struct btrfs_path *path;
|
|
|
|
|
|
2013-01-28 15:33:31 +04:00
|
|
|
if (!capable(CAP_DAC_READ_SEARCH))
|
2011-07-07 18:48:38 +04:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
if (!path) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ipa = memdup_user(arg, sizeof(*ipa));
|
|
|
|
|
if (IS_ERR(ipa)) {
|
|
|
|
|
ret = PTR_ERR(ipa);
|
|
|
|
|
ipa = NULL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size = min_t(u32, ipa->size, 4096);
|
|
|
|
|
ipath = init_ipath(size, root, path);
|
|
|
|
|
if (IS_ERR(ipath)) {
|
|
|
|
|
ret = PTR_ERR(ipath);
|
|
|
|
|
ipath = NULL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = paths_from_inode(ipa->inum, ipath);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < ipath->fspath->elem_cnt; ++i) {
|
2011-11-20 16:31:57 +04:00
|
|
|
rel_ptr = ipath->fspath->val[i] -
|
|
|
|
|
(u64)(unsigned long)ipath->fspath->val;
|
2011-11-02 23:48:34 +04:00
|
|
|
ipath->fspath->val[i] = rel_ptr;
|
2011-07-07 18:48:38 +04:00
|
|
|
}
|
|
|
|
|
|
2011-11-20 16:31:57 +04:00
|
|
|
ret = copy_to_user((void *)(unsigned long)ipa->fspath,
|
|
|
|
|
(void *)(unsigned long)ipath->fspath, size);
|
2011-07-07 18:48:38 +04:00
|
|
|
if (ret) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
free_ipath(ipath);
|
|
|
|
|
kfree(ipa);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int build_ino_list(u64 inum, u64 offset, u64 root, void *ctx)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_data_container *inodes = ctx;
|
|
|
|
|
const size_t c = 3 * sizeof(u64);
|
|
|
|
|
|
|
|
|
|
if (inodes->bytes_left >= c) {
|
|
|
|
|
inodes->bytes_left -= c;
|
|
|
|
|
inodes->val[inodes->elem_cnt] = inum;
|
|
|
|
|
inodes->val[inodes->elem_cnt + 1] = offset;
|
|
|
|
|
inodes->val[inodes->elem_cnt + 2] = root;
|
|
|
|
|
inodes->elem_cnt += 3;
|
|
|
|
|
} else {
|
|
|
|
|
inodes->bytes_missing += c - inodes->bytes_left;
|
|
|
|
|
inodes->bytes_left = 0;
|
|
|
|
|
inodes->elem_missed += 3;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int size;
|
|
|
|
|
struct btrfs_ioctl_logical_ino_args *loi;
|
|
|
|
|
struct btrfs_data_container *inodes = NULL;
|
|
|
|
|
struct btrfs_path *path = NULL;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
loi = memdup_user(arg, sizeof(*loi));
|
|
|
|
|
if (IS_ERR(loi)) {
|
|
|
|
|
ret = PTR_ERR(loi);
|
|
|
|
|
loi = NULL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
if (!path) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-08 06:01:30 +04:00
|
|
|
size = min_t(u32, loi->size, 64 * 1024);
|
2011-07-07 18:48:38 +04:00
|
|
|
inodes = init_data_container(size);
|
|
|
|
|
if (IS_ERR(inodes)) {
|
|
|
|
|
ret = PTR_ERR(inodes);
|
|
|
|
|
inodes = NULL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-08 06:01:29 +04:00
|
|
|
ret = iterate_inodes_from_logical(loi->logical, root->fs_info, path,
|
|
|
|
|
build_ino_list, inodes);
|
|
|
|
|
if (ret == -EINVAL)
|
2011-07-07 18:48:38 +04:00
|
|
|
ret = -ENOENT;
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2011-11-20 16:31:57 +04:00
|
|
|
ret = copy_to_user((void *)(unsigned long)loi->inodes,
|
|
|
|
|
(void *)(unsigned long)inodes, size);
|
2011-07-07 18:48:38 +04:00
|
|
|
if (ret)
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
btrfs_free_path(path);
|
2012-09-08 06:01:30 +04:00
|
|
|
vfree(inodes);
|
2011-07-07 18:48:38 +04:00
|
|
|
kfree(loi);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-17 00:04:49 +04:00
|
|
|
void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
|
2012-01-17 00:04:47 +04:00
|
|
|
struct btrfs_ioctl_balance_args *bargs)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_balance_control *bctl = fs_info->balance_ctl;
|
|
|
|
|
|
|
|
|
|
bargs->flags = bctl->flags;
|
|
|
|
|
|
2012-01-17 00:04:49 +04:00
|
|
|
if (atomic_read(&fs_info->balance_running))
|
|
|
|
|
bargs->state |= BTRFS_BALANCE_STATE_RUNNING;
|
|
|
|
|
if (atomic_read(&fs_info->balance_pause_req))
|
|
|
|
|
bargs->state |= BTRFS_BALANCE_STATE_PAUSE_REQ;
|
2012-01-17 00:04:49 +04:00
|
|
|
if (atomic_read(&fs_info->balance_cancel_req))
|
|
|
|
|
bargs->state |= BTRFS_BALANCE_STATE_CANCEL_REQ;
|
2012-01-17 00:04:49 +04:00
|
|
|
|
2012-01-17 00:04:47 +04:00
|
|
|
memcpy(&bargs->data, &bctl->data, sizeof(bargs->data));
|
|
|
|
|
memcpy(&bargs->meta, &bctl->meta, sizeof(bargs->meta));
|
|
|
|
|
memcpy(&bargs->sys, &bctl->sys, sizeof(bargs->sys));
|
2012-01-17 00:04:49 +04:00
|
|
|
|
|
|
|
|
if (lock) {
|
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
|
|
|
memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
|
|
|
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
|
} else {
|
|
|
|
|
memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
|
|
|
|
|
}
|
2012-01-17 00:04:47 +04:00
|
|
|
}
|
|
|
|
|
|
2012-05-11 14:11:26 +04:00
|
|
|
static long btrfs_ioctl_balance(struct file *file, void __user *arg)
|
2012-01-17 00:04:47 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2012-01-17 00:04:47 +04:00
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
|
struct btrfs_ioctl_balance_args *bargs;
|
|
|
|
|
struct btrfs_balance_control *bctl;
|
2013-01-20 17:57:57 +04:00
|
|
|
bool need_unlock; /* for mut. excl. ops lock */
|
2012-01-17 00:04:47 +04:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-06-29 13:58:48 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
2012-05-11 14:11:26 +04:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2013-01-20 17:57:57 +04:00
|
|
|
again:
|
|
|
|
|
if (!atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1)) {
|
|
|
|
|
mutex_lock(&fs_info->volume_mutex);
|
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
|
|
|
need_unlock = true;
|
|
|
|
|
goto locked;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* mut. excl. ops lock is locked. Three possibilites:
|
|
|
|
|
* (1) some other op is running
|
|
|
|
|
* (2) balance is running
|
|
|
|
|
* (3) balance is paused -- special case (think resume)
|
|
|
|
|
*/
|
2012-01-17 00:04:47 +04:00
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
2013-01-20 17:57:57 +04:00
|
|
|
if (fs_info->balance_ctl) {
|
|
|
|
|
/* this is either (2) or (3) */
|
|
|
|
|
if (!atomic_read(&fs_info->balance_running)) {
|
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
|
if (!mutex_trylock(&fs_info->volume_mutex))
|
|
|
|
|
goto again;
|
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
|
|
|
|
|
|
|
|
if (fs_info->balance_ctl &&
|
|
|
|
|
!atomic_read(&fs_info->balance_running)) {
|
|
|
|
|
/* this is (3) */
|
|
|
|
|
need_unlock = false;
|
|
|
|
|
goto locked;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
|
mutex_unlock(&fs_info->volume_mutex);
|
|
|
|
|
goto again;
|
|
|
|
|
} else {
|
|
|
|
|
/* this is (2) */
|
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
|
ret = -EINPROGRESS;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* this is (1) */
|
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
2013-08-21 07:44:48 +04:00
|
|
|
ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
|
2013-01-20 17:57:57 +04:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
locked:
|
|
|
|
|
BUG_ON(!atomic_read(&fs_info->mutually_exclusive_operation_running));
|
2012-01-17 00:04:47 +04:00
|
|
|
|
|
|
|
|
if (arg) {
|
|
|
|
|
bargs = memdup_user(arg, sizeof(*bargs));
|
|
|
|
|
if (IS_ERR(bargs)) {
|
|
|
|
|
ret = PTR_ERR(bargs);
|
2013-01-20 17:57:57 +04:00
|
|
|
goto out_unlock;
|
2012-01-17 00:04:47 +04:00
|
|
|
}
|
2012-01-17 00:04:49 +04:00
|
|
|
|
|
|
|
|
if (bargs->flags & BTRFS_BALANCE_RESUME) {
|
|
|
|
|
if (!fs_info->balance_ctl) {
|
|
|
|
|
ret = -ENOTCONN;
|
|
|
|
|
goto out_bargs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bctl = fs_info->balance_ctl;
|
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
|
|
|
bctl->flags |= BTRFS_BALANCE_RESUME;
|
|
|
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
|
|
|
|
|
|
goto do_balance;
|
|
|
|
|
}
|
2012-01-17 00:04:47 +04:00
|
|
|
} else {
|
|
|
|
|
bargs = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-20 17:57:57 +04:00
|
|
|
if (fs_info->balance_ctl) {
|
2012-01-17 00:04:49 +04:00
|
|
|
ret = -EINPROGRESS;
|
|
|
|
|
goto out_bargs;
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-17 00:04:47 +04:00
|
|
|
bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
|
|
|
|
|
if (!bctl) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out_bargs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bctl->fs_info = fs_info;
|
|
|
|
|
if (arg) {
|
|
|
|
|
memcpy(&bctl->data, &bargs->data, sizeof(bctl->data));
|
|
|
|
|
memcpy(&bctl->meta, &bargs->meta, sizeof(bctl->meta));
|
|
|
|
|
memcpy(&bctl->sys, &bargs->sys, sizeof(bctl->sys));
|
|
|
|
|
|
|
|
|
|
bctl->flags = bargs->flags;
|
2012-01-17 00:04:47 +04:00
|
|
|
} else {
|
|
|
|
|
/* balance everything - no filters */
|
|
|
|
|
bctl->flags |= BTRFS_BALANCE_TYPE_MASK;
|
2012-01-17 00:04:47 +04:00
|
|
|
}
|
|
|
|
|
|
2012-01-17 00:04:49 +04:00
|
|
|
do_balance:
|
2012-01-17 00:04:47 +04:00
|
|
|
/*
|
2013-01-20 17:57:57 +04:00
|
|
|
* Ownership of bctl and mutually_exclusive_operation_running
|
|
|
|
|
* goes to to btrfs_balance. bctl is freed in __cancel_balance,
|
|
|
|
|
* or, if restriper was paused all the way until unmount, in
|
|
|
|
|
* free_fs_info. mutually_exclusive_operation_running is
|
|
|
|
|
* cleared in __cancel_balance.
|
2012-01-17 00:04:47 +04:00
|
|
|
*/
|
2013-01-20 17:57:57 +04:00
|
|
|
need_unlock = false;
|
|
|
|
|
|
|
|
|
|
ret = btrfs_balance(bctl, bargs);
|
|
|
|
|
|
2012-01-17 00:04:47 +04:00
|
|
|
if (arg) {
|
|
|
|
|
if (copy_to_user(arg, bargs, sizeof(*bargs)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out_bargs:
|
|
|
|
|
kfree(bargs);
|
2013-01-20 17:57:57 +04:00
|
|
|
out_unlock:
|
2012-01-17 00:04:47 +04:00
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
|
mutex_unlock(&fs_info->volume_mutex);
|
2013-01-20 17:57:57 +04:00
|
|
|
if (need_unlock)
|
|
|
|
|
atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
|
|
|
|
|
out:
|
2012-06-29 13:58:48 +04:00
|
|
|
mnt_drop_write_file(file);
|
2012-01-17 00:04:47 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-17 00:04:49 +04:00
|
|
|
static long btrfs_ioctl_balance_ctl(struct btrfs_root *root, int cmd)
|
|
|
|
|
{
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
|
case BTRFS_BALANCE_CTL_PAUSE:
|
|
|
|
|
return btrfs_pause_balance(root->fs_info);
|
2012-01-17 00:04:49 +04:00
|
|
|
case BTRFS_BALANCE_CTL_CANCEL:
|
|
|
|
|
return btrfs_cancel_balance(root->fs_info);
|
2012-01-17 00:04:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-17 00:04:49 +04:00
|
|
|
static long btrfs_ioctl_balance_progress(struct btrfs_root *root,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
|
struct btrfs_ioctl_balance_args *bargs;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
|
|
|
if (!fs_info->balance_ctl) {
|
|
|
|
|
ret = -ENOTCONN;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bargs = kzalloc(sizeof(*bargs), GFP_NOFS);
|
|
|
|
|
if (!bargs) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
update_ioctl_balance_args(fs_info, 1, bargs);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, bargs, sizeof(*bargs)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
kfree(bargs);
|
|
|
|
|
out:
|
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:50:11 +04:00
|
|
|
static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg)
|
2011-09-14 17:53:51 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2011-09-14 17:53:51 +04:00
|
|
|
struct btrfs_ioctl_quota_ctl_args *sa;
|
|
|
|
|
struct btrfs_trans_handle *trans = NULL;
|
|
|
|
|
int ret;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-26 12:50:11 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2011-09-14 17:53:51 +04:00
|
|
|
|
|
|
|
|
sa = memdup_user(arg, sizeof(*sa));
|
2012-11-26 12:50:11 +04:00
|
|
|
if (IS_ERR(sa)) {
|
|
|
|
|
ret = PTR_ERR(sa);
|
|
|
|
|
goto drop_write;
|
|
|
|
|
}
|
2011-09-14 17:53:51 +04:00
|
|
|
|
2013-04-07 14:24:57 +04:00
|
|
|
down_write(&root->fs_info->subvol_sem);
|
2013-04-25 20:04:51 +04:00
|
|
|
trans = btrfs_start_transaction(root->fs_info->tree_root, 2);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out;
|
2011-09-14 17:53:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (sa->cmd) {
|
|
|
|
|
case BTRFS_QUOTA_CTL_ENABLE:
|
|
|
|
|
ret = btrfs_quota_enable(trans, root->fs_info);
|
|
|
|
|
break;
|
|
|
|
|
case BTRFS_QUOTA_CTL_DISABLE:
|
|
|
|
|
ret = btrfs_quota_disable(trans, root->fs_info);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-25 20:04:51 +04:00
|
|
|
err = btrfs_commit_transaction(trans, root->fs_info->tree_root);
|
|
|
|
|
if (err && !ret)
|
|
|
|
|
ret = err;
|
2011-09-14 17:53:51 +04:00
|
|
|
out:
|
|
|
|
|
kfree(sa);
|
2013-04-07 14:24:57 +04:00
|
|
|
up_write(&root->fs_info->subvol_sem);
|
2012-11-26 12:50:11 +04:00
|
|
|
drop_write:
|
|
|
|
|
mnt_drop_write_file(file);
|
2011-09-14 17:53:51 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:50:11 +04:00
|
|
|
static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg)
|
2011-09-14 17:53:51 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2011-09-14 17:53:51 +04:00
|
|
|
struct btrfs_ioctl_qgroup_assign_args *sa;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
int ret;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-26 12:50:11 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2011-09-14 17:53:51 +04:00
|
|
|
|
|
|
|
|
sa = memdup_user(arg, sizeof(*sa));
|
2012-11-26 12:50:11 +04:00
|
|
|
if (IS_ERR(sa)) {
|
|
|
|
|
ret = PTR_ERR(sa);
|
|
|
|
|
goto drop_write;
|
|
|
|
|
}
|
2011-09-14 17:53:51 +04:00
|
|
|
|
|
|
|
|
trans = btrfs_join_transaction(root);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* FIXME: check if the IDs really exist */
|
|
|
|
|
if (sa->assign) {
|
|
|
|
|
ret = btrfs_add_qgroup_relation(trans, root->fs_info,
|
|
|
|
|
sa->src, sa->dst);
|
|
|
|
|
} else {
|
|
|
|
|
ret = btrfs_del_qgroup_relation(trans, root->fs_info,
|
|
|
|
|
sa->src, sa->dst);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = btrfs_end_transaction(trans, root);
|
|
|
|
|
if (err && !ret)
|
|
|
|
|
ret = err;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(sa);
|
2012-11-26 12:50:11 +04:00
|
|
|
drop_write:
|
|
|
|
|
mnt_drop_write_file(file);
|
2011-09-14 17:53:51 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:50:11 +04:00
|
|
|
static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg)
|
2011-09-14 17:53:51 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2011-09-14 17:53:51 +04:00
|
|
|
struct btrfs_ioctl_qgroup_create_args *sa;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
int ret;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-26 12:50:11 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2011-09-14 17:53:51 +04:00
|
|
|
|
|
|
|
|
sa = memdup_user(arg, sizeof(*sa));
|
2012-11-26 12:50:11 +04:00
|
|
|
if (IS_ERR(sa)) {
|
|
|
|
|
ret = PTR_ERR(sa);
|
|
|
|
|
goto drop_write;
|
|
|
|
|
}
|
2011-09-14 17:53:51 +04:00
|
|
|
|
2012-11-15 15:35:41 +04:00
|
|
|
if (!sa->qgroupid) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-14 17:53:51 +04:00
|
|
|
trans = btrfs_join_transaction(root);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* FIXME: check if the IDs really exist */
|
|
|
|
|
if (sa->create) {
|
|
|
|
|
ret = btrfs_create_qgroup(trans, root->fs_info, sa->qgroupid,
|
|
|
|
|
NULL);
|
|
|
|
|
} else {
|
|
|
|
|
ret = btrfs_remove_qgroup(trans, root->fs_info, sa->qgroupid);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = btrfs_end_transaction(trans, root);
|
|
|
|
|
if (err && !ret)
|
|
|
|
|
ret = err;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(sa);
|
2012-11-26 12:50:11 +04:00
|
|
|
drop_write:
|
|
|
|
|
mnt_drop_write_file(file);
|
2011-09-14 17:53:51 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-26 12:50:11 +04:00
|
|
|
static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg)
|
2011-09-14 17:53:51 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2011-09-14 17:53:51 +04:00
|
|
|
struct btrfs_ioctl_qgroup_limit_args *sa;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
int ret;
|
|
|
|
|
int err;
|
|
|
|
|
u64 qgroupid;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-11-26 12:50:11 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2011-09-14 17:53:51 +04:00
|
|
|
|
|
|
|
|
sa = memdup_user(arg, sizeof(*sa));
|
2012-11-26 12:50:11 +04:00
|
|
|
if (IS_ERR(sa)) {
|
|
|
|
|
ret = PTR_ERR(sa);
|
|
|
|
|
goto drop_write;
|
|
|
|
|
}
|
2011-09-14 17:53:51 +04:00
|
|
|
|
|
|
|
|
trans = btrfs_join_transaction(root);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
qgroupid = sa->qgroupid;
|
|
|
|
|
if (!qgroupid) {
|
|
|
|
|
/* take the current subvol as qgroup */
|
|
|
|
|
qgroupid = root->root_key.objectid;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* FIXME: check if the IDs really exist */
|
|
|
|
|
ret = btrfs_limit_qgroup(trans, root->fs_info, qgroupid, &sa->lim);
|
|
|
|
|
|
|
|
|
|
err = btrfs_end_transaction(trans, root);
|
|
|
|
|
if (err && !ret)
|
|
|
|
|
ret = err;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(sa);
|
2012-11-26 12:50:11 +04:00
|
|
|
drop_write:
|
|
|
|
|
mnt_drop_write_file(file);
|
2011-09-14 17:53:51 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-25 20:04:51 +04:00
|
|
|
static long btrfs_ioctl_quota_rescan(struct file *file, void __user *arg)
|
|
|
|
|
{
|
2013-06-16 19:32:35 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2013-04-25 20:04:51 +04:00
|
|
|
struct btrfs_ioctl_quota_rescan_args *qsa;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
qsa = memdup_user(arg, sizeof(*qsa));
|
|
|
|
|
if (IS_ERR(qsa)) {
|
|
|
|
|
ret = PTR_ERR(qsa);
|
|
|
|
|
goto drop_write;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (qsa->flags) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = btrfs_qgroup_rescan(root->fs_info);
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(qsa);
|
|
|
|
|
drop_write:
|
|
|
|
|
mnt_drop_write_file(file);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long btrfs_ioctl_quota_rescan_status(struct file *file, void __user *arg)
|
|
|
|
|
{
|
2013-06-16 19:32:35 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2013-04-25 20:04:51 +04:00
|
|
|
struct btrfs_ioctl_quota_rescan_args *qsa;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
qsa = kzalloc(sizeof(*qsa), GFP_NOFS);
|
|
|
|
|
if (!qsa)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
if (root->fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
|
|
|
|
|
qsa->flags = 1;
|
|
|
|
|
qsa->progress = root->fs_info->qgroup_rescan_progress.objectid;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, qsa, sizeof(*qsa)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
kfree(qsa);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-06 23:14:17 +04:00
|
|
|
static long btrfs_ioctl_quota_rescan_wait(struct file *file, void __user *arg)
|
|
|
|
|
{
|
2013-09-01 23:57:51 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2013-05-06 23:14:17 +04:00
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
return btrfs_qgroup_wait_for_completion(root->fs_info);
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-31 00:17:00 +04:00
|
|
|
static long _btrfs_ioctl_set_received_subvol(struct file *file,
|
|
|
|
|
struct btrfs_ioctl_received_subvol_args *sa)
|
2012-07-25 19:35:53 +04:00
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct inode *inode = file_inode(file);
|
2012-07-25 19:35:53 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
|
struct btrfs_root_item *root_item = &root->root_item;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
struct timespec ct = CURRENT_TIME;
|
|
|
|
|
int ret = 0;
|
2013-08-15 19:11:20 +04:00
|
|
|
int received_uuid_changed;
|
2012-07-25 19:35:53 +04:00
|
|
|
|
2014-01-16 18:50:22 +04:00
|
|
|
if (!inode_owner_or_capable(inode))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2012-07-25 19:35:53 +04:00
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
down_write(&root->fs_info->subvol_sem);
|
|
|
|
|
|
|
|
|
|
if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (btrfs_root_readonly(root)) {
|
|
|
|
|
ret = -EROFS;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-15 19:11:20 +04:00
|
|
|
/*
|
|
|
|
|
* 1 - root item
|
|
|
|
|
* 2 - uuid items (received uuid + subvol uuid)
|
|
|
|
|
*/
|
|
|
|
|
trans = btrfs_start_transaction(root, 3);
|
2012-07-25 19:35:53 +04:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
trans = NULL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sa->rtransid = trans->transid;
|
|
|
|
|
sa->rtime.sec = ct.tv_sec;
|
|
|
|
|
sa->rtime.nsec = ct.tv_nsec;
|
|
|
|
|
|
2013-08-15 19:11:20 +04:00
|
|
|
received_uuid_changed = memcmp(root_item->received_uuid, sa->uuid,
|
|
|
|
|
BTRFS_UUID_SIZE);
|
|
|
|
|
if (received_uuid_changed &&
|
|
|
|
|
!btrfs_is_empty_uuid(root_item->received_uuid))
|
|
|
|
|
btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root,
|
|
|
|
|
root_item->received_uuid,
|
|
|
|
|
BTRFS_UUID_KEY_RECEIVED_SUBVOL,
|
|
|
|
|
root->root_key.objectid);
|
2012-07-25 19:35:53 +04:00
|
|
|
memcpy(root_item->received_uuid, sa->uuid, BTRFS_UUID_SIZE);
|
|
|
|
|
btrfs_set_root_stransid(root_item, sa->stransid);
|
|
|
|
|
btrfs_set_root_rtransid(root_item, sa->rtransid);
|
2013-07-16 07:19:18 +04:00
|
|
|
btrfs_set_stack_timespec_sec(&root_item->stime, sa->stime.sec);
|
|
|
|
|
btrfs_set_stack_timespec_nsec(&root_item->stime, sa->stime.nsec);
|
|
|
|
|
btrfs_set_stack_timespec_sec(&root_item->rtime, sa->rtime.sec);
|
|
|
|
|
btrfs_set_stack_timespec_nsec(&root_item->rtime, sa->rtime.nsec);
|
2012-07-25 19:35:53 +04:00
|
|
|
|
|
|
|
|
ret = btrfs_update_root(trans, root->fs_info->tree_root,
|
|
|
|
|
&root->root_key, &root->root_item);
|
|
|
|
|
if (ret < 0) {
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
|
goto out;
|
2013-08-15 19:11:20 +04:00
|
|
|
}
|
|
|
|
|
if (received_uuid_changed && !btrfs_is_empty_uuid(sa->uuid)) {
|
|
|
|
|
ret = btrfs_uuid_tree_add(trans, root->fs_info->uuid_root,
|
|
|
|
|
sa->uuid,
|
|
|
|
|
BTRFS_UUID_KEY_RECEIVED_SUBVOL,
|
|
|
|
|
root->root_key.objectid);
|
|
|
|
|
if (ret < 0 && ret != -EEXIST) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2012-07-25 19:35:53 +04:00
|
|
|
goto out;
|
2013-08-15 19:11:20 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
ret = btrfs_commit_transaction(trans, root);
|
|
|
|
|
if (ret < 0) {
|
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
goto out;
|
2012-07-25 19:35:53 +04:00
|
|
|
}
|
|
|
|
|
|
2014-01-31 00:17:00 +04:00
|
|
|
out:
|
|
|
|
|
up_write(&root->fs_info->subvol_sem);
|
|
|
|
|
mnt_drop_write_file(file);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
|
static long btrfs_ioctl_set_received_subvol_32(struct file *file,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_received_subvol_args_32 *args32 = NULL;
|
|
|
|
|
struct btrfs_ioctl_received_subvol_args *args64 = NULL;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
args32 = memdup_user(arg, sizeof(*args32));
|
|
|
|
|
if (IS_ERR(args32)) {
|
|
|
|
|
ret = PTR_ERR(args32);
|
|
|
|
|
args32 = NULL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
args64 = kmalloc(sizeof(*args64), GFP_NOFS);
|
2014-03-28 12:06:00 +04:00
|
|
|
if (!args64) {
|
|
|
|
|
ret = -ENOMEM;
|
2014-01-31 00:17:00 +04:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
memcpy(args64->uuid, args32->uuid, BTRFS_UUID_SIZE);
|
|
|
|
|
args64->stransid = args32->stransid;
|
|
|
|
|
args64->rtransid = args32->rtransid;
|
|
|
|
|
args64->stime.sec = args32->stime.sec;
|
|
|
|
|
args64->stime.nsec = args32->stime.nsec;
|
|
|
|
|
args64->rtime.sec = args32->rtime.sec;
|
|
|
|
|
args64->rtime.nsec = args32->rtime.nsec;
|
|
|
|
|
args64->flags = args32->flags;
|
|
|
|
|
|
|
|
|
|
ret = _btrfs_ioctl_set_received_subvol(file, args64);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
memcpy(args32->uuid, args64->uuid, BTRFS_UUID_SIZE);
|
|
|
|
|
args32->stransid = args64->stransid;
|
|
|
|
|
args32->rtransid = args64->rtransid;
|
|
|
|
|
args32->stime.sec = args64->stime.sec;
|
|
|
|
|
args32->stime.nsec = args64->stime.nsec;
|
|
|
|
|
args32->rtime.sec = args64->rtime.sec;
|
|
|
|
|
args32->rtime.nsec = args64->rtime.nsec;
|
|
|
|
|
args32->flags = args64->flags;
|
|
|
|
|
|
|
|
|
|
ret = copy_to_user(arg, args32, sizeof(*args32));
|
|
|
|
|
if (ret)
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(args32);
|
|
|
|
|
kfree(args64);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static long btrfs_ioctl_set_received_subvol(struct file *file,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_ioctl_received_subvol_args *sa = NULL;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
sa = memdup_user(arg, sizeof(*sa));
|
|
|
|
|
if (IS_ERR(sa)) {
|
|
|
|
|
ret = PTR_ERR(sa);
|
|
|
|
|
sa = NULL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = _btrfs_ioctl_set_received_subvol(file, sa);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2012-07-25 19:35:53 +04:00
|
|
|
ret = copy_to_user(arg, sa, sizeof(*sa));
|
|
|
|
|
if (ret)
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(sa);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-05 06:48:01 +04:00
|
|
|
static int btrfs_ioctl_get_fslabel(struct file *file, void __user *arg)
|
|
|
|
|
{
|
2013-06-16 19:32:35 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2013-07-19 13:39:32 +04:00
|
|
|
size_t len;
|
2013-01-05 06:48:01 +04:00
|
|
|
int ret;
|
2013-07-19 13:39:32 +04:00
|
|
|
char label[BTRFS_LABEL_SIZE];
|
|
|
|
|
|
|
|
|
|
spin_lock(&root->fs_info->super_lock);
|
|
|
|
|
memcpy(label, root->fs_info->super_copy->label, BTRFS_LABEL_SIZE);
|
|
|
|
|
spin_unlock(&root->fs_info->super_lock);
|
|
|
|
|
|
|
|
|
|
len = strnlen(label, BTRFS_LABEL_SIZE);
|
2013-01-05 06:48:01 +04:00
|
|
|
|
|
|
|
|
if (len == BTRFS_LABEL_SIZE) {
|
2013-12-20 20:37:06 +04:00
|
|
|
btrfs_warn(root->fs_info,
|
|
|
|
|
"label is too long, return the first %zu bytes", --len);
|
2013-01-05 06:48:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = copy_to_user(arg, label, len);
|
|
|
|
|
|
|
|
|
|
return ret ? -EFAULT : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-05 06:48:08 +04:00
|
|
|
static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg)
|
|
|
|
|
{
|
2013-06-16 19:32:35 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2013-01-05 06:48:08 +04:00
|
|
|
struct btrfs_super_block *super_block = root->fs_info->super_copy;
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
char label[BTRFS_LABEL_SIZE];
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(label, arg, sizeof(label)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (strnlen(label, BTRFS_LABEL_SIZE) == BTRFS_LABEL_SIZE) {
|
2013-12-20 20:37:06 +04:00
|
|
|
btrfs_err(root->fs_info, "unable to set label with more than %d bytes",
|
2013-01-05 06:48:08 +04:00
|
|
|
BTRFS_LABEL_SIZE - 1);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = mnt_want_write_file(file);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
trans = btrfs_start_transaction(root, 0);
|
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-19 13:39:32 +04:00
|
|
|
spin_lock(&root->fs_info->super_lock);
|
2013-01-05 06:48:08 +04:00
|
|
|
strcpy(super_block->label, label);
|
2013-07-19 13:39:32 +04:00
|
|
|
spin_unlock(&root->fs_info->super_lock);
|
2014-02-07 17:33:57 +04:00
|
|
|
ret = btrfs_commit_transaction(trans, root);
|
2013-01-05 06:48:08 +04:00
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
|
mnt_drop_write_file(file);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-16 00:33:55 +04:00
|
|
|
#define INIT_FEATURE_FLAGS(suffix) \
|
|
|
|
|
{ .compat_flags = BTRFS_FEATURE_COMPAT_##suffix, \
|
|
|
|
|
.compat_ro_flags = BTRFS_FEATURE_COMPAT_RO_##suffix, \
|
|
|
|
|
.incompat_flags = BTRFS_FEATURE_INCOMPAT_##suffix }
|
|
|
|
|
|
|
|
|
|
static int btrfs_ioctl_get_supported_features(struct file *file,
|
|
|
|
|
void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
static struct btrfs_ioctl_feature_flags features[3] = {
|
|
|
|
|
INIT_FEATURE_FLAGS(SUPP),
|
|
|
|
|
INIT_FEATURE_FLAGS(SAFE_SET),
|
|
|
|
|
INIT_FEATURE_FLAGS(SAFE_CLEAR)
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &features, sizeof(features)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int btrfs_ioctl_get_features(struct file *file, void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
|
|
|
|
struct btrfs_super_block *super_block = root->fs_info->super_copy;
|
|
|
|
|
struct btrfs_ioctl_feature_flags features;
|
|
|
|
|
|
|
|
|
|
features.compat_flags = btrfs_super_compat_flags(super_block);
|
|
|
|
|
features.compat_ro_flags = btrfs_super_compat_ro_flags(super_block);
|
|
|
|
|
features.incompat_flags = btrfs_super_incompat_flags(super_block);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &features, sizeof(features)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-01 21:07:02 +04:00
|
|
|
static int check_feature_bits(struct btrfs_root *root,
|
|
|
|
|
enum btrfs_feature_set set,
|
2013-11-16 00:33:55 +04:00
|
|
|
u64 change_mask, u64 flags, u64 supported_flags,
|
|
|
|
|
u64 safe_set, u64 safe_clear)
|
|
|
|
|
{
|
2013-11-01 21:07:02 +04:00
|
|
|
const char *type = btrfs_feature_set_names[set];
|
|
|
|
|
char *names;
|
2013-11-16 00:33:55 +04:00
|
|
|
u64 disallowed, unsupported;
|
|
|
|
|
u64 set_mask = flags & change_mask;
|
|
|
|
|
u64 clear_mask = ~flags & change_mask;
|
|
|
|
|
|
|
|
|
|
unsupported = set_mask & ~supported_flags;
|
|
|
|
|
if (unsupported) {
|
2013-11-01 21:07:02 +04:00
|
|
|
names = btrfs_printable_features(set, unsupported);
|
|
|
|
|
if (names) {
|
|
|
|
|
btrfs_warn(root->fs_info,
|
|
|
|
|
"this kernel does not support the %s feature bit%s",
|
|
|
|
|
names, strchr(names, ',') ? "s" : "");
|
|
|
|
|
kfree(names);
|
|
|
|
|
} else
|
|
|
|
|
btrfs_warn(root->fs_info,
|
2013-11-16 00:33:55 +04:00
|
|
|
"this kernel does not support %s bits 0x%llx",
|
|
|
|
|
type, unsupported);
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
disallowed = set_mask & ~safe_set;
|
|
|
|
|
if (disallowed) {
|
2013-11-01 21:07:02 +04:00
|
|
|
names = btrfs_printable_features(set, disallowed);
|
|
|
|
|
if (names) {
|
|
|
|
|
btrfs_warn(root->fs_info,
|
|
|
|
|
"can't set the %s feature bit%s while mounted",
|
|
|
|
|
names, strchr(names, ',') ? "s" : "");
|
|
|
|
|
kfree(names);
|
|
|
|
|
} else
|
|
|
|
|
btrfs_warn(root->fs_info,
|
2013-11-16 00:33:55 +04:00
|
|
|
"can't set %s bits 0x%llx while mounted",
|
|
|
|
|
type, disallowed);
|
|
|
|
|
return -EPERM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
disallowed = clear_mask & ~safe_clear;
|
|
|
|
|
if (disallowed) {
|
2013-11-01 21:07:02 +04:00
|
|
|
names = btrfs_printable_features(set, disallowed);
|
|
|
|
|
if (names) {
|
|
|
|
|
btrfs_warn(root->fs_info,
|
|
|
|
|
"can't clear the %s feature bit%s while mounted",
|
|
|
|
|
names, strchr(names, ',') ? "s" : "");
|
|
|
|
|
kfree(names);
|
|
|
|
|
} else
|
|
|
|
|
btrfs_warn(root->fs_info,
|
2013-11-16 00:33:55 +04:00
|
|
|
"can't clear %s bits 0x%llx while mounted",
|
|
|
|
|
type, disallowed);
|
|
|
|
|
return -EPERM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define check_feature(root, change_mask, flags, mask_base) \
|
2013-11-01 21:07:02 +04:00
|
|
|
check_feature_bits(root, FEAT_##mask_base, change_mask, flags, \
|
2013-11-16 00:33:55 +04:00
|
|
|
BTRFS_FEATURE_ ## mask_base ## _SUPP, \
|
|
|
|
|
BTRFS_FEATURE_ ## mask_base ## _SAFE_SET, \
|
|
|
|
|
BTRFS_FEATURE_ ## mask_base ## _SAFE_CLEAR)
|
|
|
|
|
|
|
|
|
|
static int btrfs_ioctl_set_features(struct file *file, void __user *arg)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
|
|
|
|
struct btrfs_super_block *super_block = root->fs_info->super_copy;
|
|
|
|
|
struct btrfs_ioctl_feature_flags flags[2];
|
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
u64 newflags;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(flags, arg, sizeof(flags)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
/* Nothing to do */
|
|
|
|
|
if (!flags[0].compat_flags && !flags[0].compat_ro_flags &&
|
|
|
|
|
!flags[0].incompat_flags)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
ret = check_feature(root, flags[0].compat_flags,
|
|
|
|
|
flags[1].compat_flags, COMPAT);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = check_feature(root, flags[0].compat_ro_flags,
|
|
|
|
|
flags[1].compat_ro_flags, COMPAT_RO);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = check_feature(root, flags[0].incompat_flags,
|
|
|
|
|
flags[1].incompat_flags, INCOMPAT);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2014-02-07 17:34:04 +04:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2013-11-16 00:33:55 +04:00
|
|
|
if (IS_ERR(trans))
|
|
|
|
|
return PTR_ERR(trans);
|
|
|
|
|
|
|
|
|
|
spin_lock(&root->fs_info->super_lock);
|
|
|
|
|
newflags = btrfs_super_compat_flags(super_block);
|
|
|
|
|
newflags |= flags[0].compat_flags & flags[1].compat_flags;
|
|
|
|
|
newflags &= ~(flags[0].compat_flags & ~flags[1].compat_flags);
|
|
|
|
|
btrfs_set_super_compat_flags(super_block, newflags);
|
|
|
|
|
|
|
|
|
|
newflags = btrfs_super_compat_ro_flags(super_block);
|
|
|
|
|
newflags |= flags[0].compat_ro_flags & flags[1].compat_ro_flags;
|
|
|
|
|
newflags &= ~(flags[0].compat_ro_flags & ~flags[1].compat_ro_flags);
|
|
|
|
|
btrfs_set_super_compat_ro_flags(super_block, newflags);
|
|
|
|
|
|
|
|
|
|
newflags = btrfs_super_incompat_flags(super_block);
|
|
|
|
|
newflags |= flags[0].incompat_flags & flags[1].incompat_flags;
|
|
|
|
|
newflags &= ~(flags[0].incompat_flags & ~flags[1].incompat_flags);
|
|
|
|
|
btrfs_set_super_incompat_flags(super_block, newflags);
|
|
|
|
|
spin_unlock(&root->fs_info->super_lock);
|
|
|
|
|
|
2014-02-07 17:33:57 +04:00
|
|
|
return btrfs_commit_transaction(trans, root);
|
2013-11-16 00:33:55 +04:00
|
|
|
}
|
|
|
|
|
|
2008-06-12 05:53:53 +04:00
|
|
|
long btrfs_ioctl(struct file *file, unsigned int
|
|
|
|
|
cmd, unsigned long arg)
|
|
|
|
|
{
|
2013-01-24 02:07:38 +04:00
|
|
|
struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
|
2008-12-02 14:36:08 +03:00
|
|
|
void __user *argp = (void __user *)arg;
|
2008-06-12 05:53:53 +04:00
|
|
|
|
|
|
|
|
switch (cmd) {
|
2009-04-17 12:37:41 +04:00
|
|
|
case FS_IOC_GETFLAGS:
|
|
|
|
|
return btrfs_ioctl_getflags(file, argp);
|
|
|
|
|
case FS_IOC_SETFLAGS:
|
|
|
|
|
return btrfs_ioctl_setflags(file, argp);
|
|
|
|
|
case FS_IOC_GETVERSION:
|
|
|
|
|
return btrfs_ioctl_getversion(file, argp);
|
2011-03-24 13:24:28 +03:00
|
|
|
case FITRIM:
|
|
|
|
|
return btrfs_ioctl_fitrim(file, argp);
|
2008-06-12 05:53:53 +04:00
|
|
|
case BTRFS_IOC_SNAP_CREATE:
|
2010-12-20 10:53:28 +03:00
|
|
|
return btrfs_ioctl_snap_create(file, argp, 0);
|
2010-12-10 09:41:56 +03:00
|
|
|
case BTRFS_IOC_SNAP_CREATE_V2:
|
2010-12-20 10:53:28 +03:00
|
|
|
return btrfs_ioctl_snap_create_v2(file, argp, 0);
|
2008-11-18 05:02:50 +03:00
|
|
|
case BTRFS_IOC_SUBVOL_CREATE:
|
2010-12-20 10:53:28 +03:00
|
|
|
return btrfs_ioctl_snap_create(file, argp, 1);
|
2011-09-14 17:58:21 +04:00
|
|
|
case BTRFS_IOC_SUBVOL_CREATE_V2:
|
|
|
|
|
return btrfs_ioctl_snap_create_v2(file, argp, 1);
|
2009-09-22 00:00:26 +04:00
|
|
|
case BTRFS_IOC_SNAP_DESTROY:
|
|
|
|
|
return btrfs_ioctl_snap_destroy(file, argp);
|
2010-12-20 11:30:25 +03:00
|
|
|
case BTRFS_IOC_SUBVOL_GETFLAGS:
|
|
|
|
|
return btrfs_ioctl_subvol_getflags(file, argp);
|
|
|
|
|
case BTRFS_IOC_SUBVOL_SETFLAGS:
|
|
|
|
|
return btrfs_ioctl_subvol_setflags(file, argp);
|
2009-12-12 00:11:29 +03:00
|
|
|
case BTRFS_IOC_DEFAULT_SUBVOL:
|
|
|
|
|
return btrfs_ioctl_default_subvol(file, argp);
|
2008-06-12 05:53:53 +04:00
|
|
|
case BTRFS_IOC_DEFRAG:
|
2010-03-11 17:42:04 +03:00
|
|
|
return btrfs_ioctl_defrag(file, NULL);
|
|
|
|
|
case BTRFS_IOC_DEFRAG_RANGE:
|
|
|
|
|
return btrfs_ioctl_defrag(file, argp);
|
2008-06-12 05:53:53 +04:00
|
|
|
case BTRFS_IOC_RESIZE:
|
2012-11-26 12:43:45 +04:00
|
|
|
return btrfs_ioctl_resize(file, argp);
|
2008-06-12 05:53:53 +04:00
|
|
|
case BTRFS_IOC_ADD_DEV:
|
2008-12-02 14:36:08 +03:00
|
|
|
return btrfs_ioctl_add_dev(root, argp);
|
2008-06-12 05:53:53 +04:00
|
|
|
case BTRFS_IOC_RM_DEV:
|
2012-11-26 12:44:50 +04:00
|
|
|
return btrfs_ioctl_rm_dev(file, argp);
|
2011-03-11 17:41:01 +03:00
|
|
|
case BTRFS_IOC_FS_INFO:
|
|
|
|
|
return btrfs_ioctl_fs_info(root, argp);
|
|
|
|
|
case BTRFS_IOC_DEV_INFO:
|
|
|
|
|
return btrfs_ioctl_dev_info(root, argp);
|
2008-06-12 05:53:53 +04:00
|
|
|
case BTRFS_IOC_BALANCE:
|
2012-05-11 14:11:26 +04:00
|
|
|
return btrfs_ioctl_balance(file, NULL);
|
2008-06-12 05:53:53 +04:00
|
|
|
case BTRFS_IOC_CLONE:
|
2008-11-12 22:32:25 +03:00
|
|
|
return btrfs_ioctl_clone(file, arg, 0, 0, 0);
|
|
|
|
|
case BTRFS_IOC_CLONE_RANGE:
|
2008-12-02 17:52:24 +03:00
|
|
|
return btrfs_ioctl_clone_range(file, argp);
|
2008-06-12 05:53:53 +04:00
|
|
|
case BTRFS_IOC_TRANS_START:
|
|
|
|
|
return btrfs_ioctl_trans_start(file);
|
|
|
|
|
case BTRFS_IOC_TRANS_END:
|
|
|
|
|
return btrfs_ioctl_trans_end(file);
|
2010-02-28 23:39:26 +03:00
|
|
|
case BTRFS_IOC_TREE_SEARCH:
|
|
|
|
|
return btrfs_ioctl_tree_search(file, argp);
|
2014-01-30 19:24:03 +04:00
|
|
|
case BTRFS_IOC_TREE_SEARCH_V2:
|
|
|
|
|
return btrfs_ioctl_tree_search_v2(file, argp);
|
2010-02-28 23:39:26 +03:00
|
|
|
case BTRFS_IOC_INO_LOOKUP:
|
|
|
|
|
return btrfs_ioctl_ino_lookup(file, argp);
|
2011-07-07 18:48:38 +04:00
|
|
|
case BTRFS_IOC_INO_PATHS:
|
|
|
|
|
return btrfs_ioctl_ino_to_path(root, argp);
|
|
|
|
|
case BTRFS_IOC_LOGICAL_INO:
|
|
|
|
|
return btrfs_ioctl_logical_to_ino(root, argp);
|
2010-01-13 21:19:06 +03:00
|
|
|
case BTRFS_IOC_SPACE_INFO:
|
|
|
|
|
return btrfs_ioctl_space_info(root, argp);
|
2013-09-23 14:35:11 +04:00
|
|
|
case BTRFS_IOC_SYNC: {
|
|
|
|
|
int ret;
|
|
|
|
|
|
2014-03-06 09:55:01 +04:00
|
|
|
ret = btrfs_start_delalloc_roots(root->fs_info, 0, -1);
|
2013-09-23 14:35:11 +04:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
ret = btrfs_sync_fs(file->f_dentry->d_sb, 1);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-29 23:41:32 +04:00
|
|
|
case BTRFS_IOC_START_SYNC:
|
2012-11-26 12:40:43 +04:00
|
|
|
return btrfs_ioctl_start_sync(root, argp);
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-29 23:41:32 +04:00
|
|
|
case BTRFS_IOC_WAIT_SYNC:
|
2012-11-26 12:40:43 +04:00
|
|
|
return btrfs_ioctl_wait_sync(root, argp);
|
2011-03-11 17:41:01 +03:00
|
|
|
case BTRFS_IOC_SCRUB:
|
2012-11-26 12:48:01 +04:00
|
|
|
return btrfs_ioctl_scrub(file, argp);
|
2011-03-11 17:41:01 +03:00
|
|
|
case BTRFS_IOC_SCRUB_CANCEL:
|
|
|
|
|
return btrfs_ioctl_scrub_cancel(root, argp);
|
|
|
|
|
case BTRFS_IOC_SCRUB_PROGRESS:
|
|
|
|
|
return btrfs_ioctl_scrub_progress(root, argp);
|
2012-01-17 00:04:47 +04:00
|
|
|
case BTRFS_IOC_BALANCE_V2:
|
2012-05-11 14:11:26 +04:00
|
|
|
return btrfs_ioctl_balance(file, argp);
|
2012-01-17 00:04:49 +04:00
|
|
|
case BTRFS_IOC_BALANCE_CTL:
|
|
|
|
|
return btrfs_ioctl_balance_ctl(root, arg);
|
2012-01-17 00:04:49 +04:00
|
|
|
case BTRFS_IOC_BALANCE_PROGRESS:
|
|
|
|
|
return btrfs_ioctl_balance_progress(root, argp);
|
2012-07-25 19:35:53 +04:00
|
|
|
case BTRFS_IOC_SET_RECEIVED_SUBVOL:
|
|
|
|
|
return btrfs_ioctl_set_received_subvol(file, argp);
|
2014-01-31 00:17:00 +04:00
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
|
case BTRFS_IOC_SET_RECEIVED_SUBVOL_32:
|
|
|
|
|
return btrfs_ioctl_set_received_subvol_32(file, argp);
|
|
|
|
|
#endif
|
2012-07-26 01:19:24 +04:00
|
|
|
case BTRFS_IOC_SEND:
|
|
|
|
|
return btrfs_ioctl_send(file, argp);
|
2012-05-25 18:06:09 +04:00
|
|
|
case BTRFS_IOC_GET_DEV_STATS:
|
2012-06-22 16:30:39 +04:00
|
|
|
return btrfs_ioctl_get_dev_stats(root, argp);
|
2011-09-14 17:53:51 +04:00
|
|
|
case BTRFS_IOC_QUOTA_CTL:
|
2012-11-26 12:50:11 +04:00
|
|
|
return btrfs_ioctl_quota_ctl(file, argp);
|
2011-09-14 17:53:51 +04:00
|
|
|
case BTRFS_IOC_QGROUP_ASSIGN:
|
2012-11-26 12:50:11 +04:00
|
|
|
return btrfs_ioctl_qgroup_assign(file, argp);
|
2011-09-14 17:53:51 +04:00
|
|
|
case BTRFS_IOC_QGROUP_CREATE:
|
2012-11-26 12:50:11 +04:00
|
|
|
return btrfs_ioctl_qgroup_create(file, argp);
|
2011-09-14 17:53:51 +04:00
|
|
|
case BTRFS_IOC_QGROUP_LIMIT:
|
2012-11-26 12:50:11 +04:00
|
|
|
return btrfs_ioctl_qgroup_limit(file, argp);
|
2013-04-25 20:04:51 +04:00
|
|
|
case BTRFS_IOC_QUOTA_RESCAN:
|
|
|
|
|
return btrfs_ioctl_quota_rescan(file, argp);
|
|
|
|
|
case BTRFS_IOC_QUOTA_RESCAN_STATUS:
|
|
|
|
|
return btrfs_ioctl_quota_rescan_status(file, argp);
|
2013-05-06 23:14:17 +04:00
|
|
|
case BTRFS_IOC_QUOTA_RESCAN_WAIT:
|
|
|
|
|
return btrfs_ioctl_quota_rescan_wait(file, argp);
|
2012-11-06 18:08:53 +04:00
|
|
|
case BTRFS_IOC_DEV_REPLACE:
|
|
|
|
|
return btrfs_ioctl_dev_replace(root, argp);
|
2013-01-05 06:48:01 +04:00
|
|
|
case BTRFS_IOC_GET_FSLABEL:
|
|
|
|
|
return btrfs_ioctl_get_fslabel(file, argp);
|
2013-01-05 06:48:08 +04:00
|
|
|
case BTRFS_IOC_SET_FSLABEL:
|
|
|
|
|
return btrfs_ioctl_set_fslabel(file, argp);
|
2013-08-06 22:42:51 +04:00
|
|
|
case BTRFS_IOC_FILE_EXTENT_SAME:
|
|
|
|
|
return btrfs_ioctl_file_extent_same(file, argp);
|
2013-11-16 00:33:55 +04:00
|
|
|
case BTRFS_IOC_GET_SUPPORTED_FEATURES:
|
|
|
|
|
return btrfs_ioctl_get_supported_features(file, argp);
|
|
|
|
|
case BTRFS_IOC_GET_FEATURES:
|
|
|
|
|
return btrfs_ioctl_get_features(file, argp);
|
|
|
|
|
case BTRFS_IOC_SET_FEATURES:
|
|
|
|
|
return btrfs_ioctl_set_features(file, argp);
|
2008-06-12 05:53:53 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -ENOTTY;
|
|
|
|
|
}
|
