2008-09-05 22:13:11 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2008 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/sched.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 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2013-05-28 12:05:39 +02:00
|
|
|
#include <linux/blkdev.h>
|
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 19:14:17 +02:00
|
|
|
#include <linux/list_sort.h>
|
2014-04-02 13:51:06 +02:00
|
|
|
#include "tree-log.h"
|
2008-09-05 22:13:11 +02:00
|
|
|
#include "disk-io.h"
|
|
|
|
#include "locking.h"
|
|
|
|
#include "print-tree.h"
|
2012-08-08 20:32:27 +02:00
|
|
|
#include "backref.h"
|
|
|
|
#include "hash.h"
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* magic values for the inode_only field in btrfs_log_inode:
|
|
|
|
*
|
|
|
|
* LOG_INODE_ALL means to log everything
|
|
|
|
* LOG_INODE_EXISTS means to log just enough to recreate the inode
|
|
|
|
* during log replay
|
|
|
|
*/
|
|
|
|
#define LOG_INODE_ALL 0
|
|
|
|
#define LOG_INODE_EXISTS 1
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
/*
|
|
|
|
* directory trouble cases
|
|
|
|
*
|
|
|
|
* 1) on rename or unlink, if the inode being unlinked isn't in the fsync
|
|
|
|
* log, we must force a full commit before doing an fsync of the directory
|
|
|
|
* where the unlink was done.
|
|
|
|
* ---> record transid of last unlink/rename per directory
|
|
|
|
*
|
|
|
|
* mkdir foo/some_dir
|
|
|
|
* normal commit
|
|
|
|
* rename foo/some_dir foo2/some_dir
|
|
|
|
* mkdir foo/some_dir
|
|
|
|
* fsync foo/some_dir/some_file
|
|
|
|
*
|
|
|
|
* The fsync above will unlink the original some_dir without recording
|
|
|
|
* it in its new location (foo2). After a crash, some_dir will be gone
|
|
|
|
* unless the fsync of some_file forces a full commit
|
|
|
|
*
|
|
|
|
* 2) we must log any new names for any file or dir that is in the fsync
|
|
|
|
* log. ---> check inode while renaming/linking.
|
|
|
|
*
|
|
|
|
* 2a) we must log any new names for any file or dir during rename
|
|
|
|
* when the directory they are being removed from was logged.
|
|
|
|
* ---> check inode and old parent dir during rename
|
|
|
|
*
|
|
|
|
* 2a is actually the more important variant. With the extra logging
|
|
|
|
* a crash might unlink the old name without recreating the new one
|
|
|
|
*
|
|
|
|
* 3) after a crash, we must go through any directories with a link count
|
|
|
|
* of zero and redo the rm -rf
|
|
|
|
*
|
|
|
|
* mkdir f1/foo
|
|
|
|
* normal commit
|
|
|
|
* rm -rf f1/foo
|
|
|
|
* fsync(f1)
|
|
|
|
*
|
|
|
|
* The directory f1 was fully removed from the FS, but fsync was never
|
|
|
|
* called on f1, only its parent dir. After a crash the rm -rf must
|
|
|
|
* be replayed. This must be able to recurse down the entire
|
|
|
|
* directory tree. The inode link count fixup code takes care of the
|
|
|
|
* ugly details.
|
|
|
|
*/
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/*
|
|
|
|
* stages for the tree walking. The first
|
|
|
|
* stage (0) is to only pin down the blocks we find
|
|
|
|
* the second stage (1) is to make sure that all the inodes
|
|
|
|
* we find in the log are created in the subvolume.
|
|
|
|
*
|
|
|
|
* The last stage is to deal with directories and links and extents
|
|
|
|
* and all the other fun semantics
|
|
|
|
*/
|
|
|
|
#define LOG_WALK_PIN_ONLY 0
|
|
|
|
#define LOG_WALK_REPLAY_INODES 1
|
2013-09-11 17:57:23 +02:00
|
|
|
#define LOG_WALK_REPLAY_DIR_INDEX 2
|
|
|
|
#define LOG_WALK_REPLAY_ALL 3
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
static int btrfs_log_inode(struct btrfs_trans_handle *trans,
|
2014-09-06 23:34:39 +02:00
|
|
|
struct btrfs_root *root, struct inode *inode,
|
|
|
|
int inode_only,
|
|
|
|
const loff_t start,
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
const loff_t end,
|
|
|
|
struct btrfs_log_ctx *ctx);
|
2009-01-05 21:43:42 +01:00
|
|
|
static int link_to_fixup_dir(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path, u64 objectid);
|
2009-03-24 15:24:20 +01:00
|
|
|
static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_root *log,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
u64 dirid, int del_all);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* tree logging is a special write ahead log used to make sure that
|
|
|
|
* fsyncs and O_SYNCs can happen without doing full tree commits.
|
|
|
|
*
|
|
|
|
* Full tree commits are expensive because they require commonly
|
|
|
|
* modified blocks to be recowed, creating many dirty pages in the
|
|
|
|
* extent tree an 4x-6x higher write load than ext3.
|
|
|
|
*
|
|
|
|
* Instead of doing a tree commit on every fsync, we use the
|
|
|
|
* key ranges and transaction ids to find items for a given file or directory
|
|
|
|
* that have changed in this transaction. Those items are copied into
|
|
|
|
* a special tree (one per subvolume root), that tree is written to disk
|
|
|
|
* and then the fsync is considered complete.
|
|
|
|
*
|
|
|
|
* After a crash, items are copied out of the log-tree back into the
|
|
|
|
* subvolume tree. Any file data extents found are recorded in the extent
|
|
|
|
* allocation tree, and the log-tree freed.
|
|
|
|
*
|
|
|
|
* The log tree is read three times, once to pin down all the extents it is
|
|
|
|
* using in ram and once, once to create all the inodes logged in the tree
|
|
|
|
* and once to do all the other items.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* start a sub transaction and setup the log tree
|
|
|
|
* this increments the log tree writer count to make the people
|
|
|
|
* syncing the tree wait for us to finish
|
|
|
|
*/
|
|
|
|
static int start_log_trans(struct btrfs_trans_handle *trans,
|
2014-02-20 11:08:58 +01:00
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_log_ctx *ctx)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
2014-02-20 11:08:58 +01:00
|
|
|
int index;
|
2008-09-05 22:13:11 +02:00
|
|
|
int ret;
|
2009-01-21 18:54:03 +01:00
|
|
|
|
|
|
|
mutex_lock(&root->log_mutex);
|
|
|
|
if (root->log_root) {
|
2014-04-02 13:51:06 +02:00
|
|
|
if (btrfs_need_log_full_commit(root->fs_info, trans)) {
|
2014-02-20 11:08:57 +01:00
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-10-08 21:30:04 +02:00
|
|
|
if (!root->log_start_pid) {
|
|
|
|
root->log_start_pid = current->pid;
|
2014-04-02 13:51:05 +02:00
|
|
|
clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
|
2009-10-08 21:30:04 +02:00
|
|
|
} else if (root->log_start_pid != current->pid) {
|
2014-04-02 13:51:05 +02:00
|
|
|
set_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
|
2009-10-08 21:30:04 +02:00
|
|
|
}
|
|
|
|
|
2012-09-06 12:04:27 +02:00
|
|
|
atomic_inc(&root->log_batch);
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_inc(&root->log_writers);
|
2014-02-20 11:08:58 +01:00
|
|
|
if (ctx) {
|
|
|
|
index = root->log_transid % 2;
|
|
|
|
list_add_tail(&ctx->list, &root->log_ctxs[index]);
|
2014-02-20 11:08:59 +01:00
|
|
|
ctx->log_transid = root->log_transid;
|
2014-02-20 11:08:58 +01:00
|
|
|
}
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-02-20 11:08:53 +01:00
|
|
|
|
|
|
|
ret = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
mutex_lock(&root->fs_info->tree_log_mutex);
|
2014-02-20 11:08:53 +01:00
|
|
|
if (!root->fs_info->log_root_tree)
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_init_log_root_tree(trans, root->fs_info);
|
2014-02-20 11:08:53 +01:00
|
|
|
mutex_unlock(&root->fs_info->tree_log_mutex);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!root->log_root) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_add_log_tree(trans, root);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret)
|
2014-02-20 11:08:53 +01:00
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2014-04-02 13:51:05 +02:00
|
|
|
clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
|
2014-02-20 11:08:53 +01:00
|
|
|
root->log_start_pid = current->pid;
|
2012-09-06 12:04:27 +02:00
|
|
|
atomic_inc(&root->log_batch);
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_inc(&root->log_writers);
|
2014-02-20 11:08:58 +01:00
|
|
|
if (ctx) {
|
|
|
|
index = root->log_transid % 2;
|
|
|
|
list_add_tail(&ctx->list, &root->log_ctxs[index]);
|
2014-02-20 11:08:59 +01:00
|
|
|
ctx->log_transid = root->log_transid;
|
2014-02-20 11:08:58 +01:00
|
|
|
}
|
2014-02-20 11:08:53 +01:00
|
|
|
out:
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_unlock(&root->log_mutex);
|
2014-02-20 11:08:53 +01:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns 0 if there was a log transaction running and we were able
|
|
|
|
* to join, or returns -ENOENT if there were not transactions
|
|
|
|
* in progress
|
|
|
|
*/
|
|
|
|
static int join_running_log_trans(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
smp_mb();
|
|
|
|
if (!root->log_root)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_lock(&root->log_mutex);
|
2008-09-05 22:13:11 +02:00
|
|
|
if (root->log_root) {
|
|
|
|
ret = 0;
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_inc(&root->log_writers);
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_unlock(&root->log_mutex);
|
2008-09-05 22:13:11 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
/*
|
|
|
|
* This either makes the current running log transaction wait
|
|
|
|
* until you call btrfs_end_log_trans() or it makes any future
|
|
|
|
* log transactions wait until you call btrfs_end_log_trans()
|
|
|
|
*/
|
|
|
|
int btrfs_pin_log_trans(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
mutex_lock(&root->log_mutex);
|
|
|
|
atomic_inc(&root->log_writers);
|
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/*
|
|
|
|
* indicate we're done making changes to the log tree
|
|
|
|
* and wake up anyone waiting to do a sync
|
|
|
|
*/
|
2012-03-01 14:56:26 +01:00
|
|
|
void btrfs_end_log_trans(struct btrfs_root *root)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
2009-01-21 18:54:03 +01:00
|
|
|
if (atomic_dec_and_test(&root->log_writers)) {
|
|
|
|
smp_mb();
|
|
|
|
if (waitqueue_active(&root->log_writer_wait))
|
|
|
|
wake_up(&root->log_writer_wait);
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the walk control struct is used to pass state down the chain when
|
|
|
|
* processing the log tree. The stage field tells us which part
|
|
|
|
* of the log tree processing we are currently doing. The others
|
|
|
|
* are state fields used for that specific part
|
|
|
|
*/
|
|
|
|
struct walk_control {
|
|
|
|
/* should we free the extent on disk when done? This is used
|
|
|
|
* at transaction commit time while freeing a log tree
|
|
|
|
*/
|
|
|
|
int free;
|
|
|
|
|
|
|
|
/* should we write out the extent buffer? This is used
|
|
|
|
* while flushing the log tree to disk during a sync
|
|
|
|
*/
|
|
|
|
int write;
|
|
|
|
|
|
|
|
/* should we wait for the extent buffer io to finish? Also used
|
|
|
|
* while flushing the log tree to disk for a sync
|
|
|
|
*/
|
|
|
|
int wait;
|
|
|
|
|
|
|
|
/* pin only walk, we record which extents on disk belong to the
|
|
|
|
* log trees
|
|
|
|
*/
|
|
|
|
int pin;
|
|
|
|
|
|
|
|
/* what stage of the replay code we're currently in */
|
|
|
|
int stage;
|
|
|
|
|
|
|
|
/* the root we are currently replaying */
|
|
|
|
struct btrfs_root *replay_dest;
|
|
|
|
|
|
|
|
/* the trans handle for the current replay */
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
|
|
|
/* the function that gets used to process blocks we find in the
|
|
|
|
* tree. Note the extent_buffer might not be up to date when it is
|
|
|
|
* passed in, and it must be checked or read if you need the data
|
|
|
|
* inside it
|
|
|
|
*/
|
|
|
|
int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb,
|
|
|
|
struct walk_control *wc, u64 gen);
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* process_func used to pin down extents, write them or wait on them
|
|
|
|
*/
|
|
|
|
static int process_one_buffer(struct btrfs_root *log,
|
|
|
|
struct extent_buffer *eb,
|
|
|
|
struct walk_control *wc, u64 gen)
|
|
|
|
{
|
2013-04-25 21:55:30 +02:00
|
|
|
int ret = 0;
|
|
|
|
|
2013-06-06 19:19:32 +02:00
|
|
|
/*
|
|
|
|
* If this fs is mixed then we need to be able to process the leaves to
|
|
|
|
* pin down any logged extents, so we have to read the block.
|
|
|
|
*/
|
|
|
|
if (btrfs_fs_incompat(log->fs_info, MIXED_GROUPS)) {
|
|
|
|
ret = btrfs_read_buffer(eb, gen);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-04-03 16:14:18 +02:00
|
|
|
if (wc->pin)
|
2013-04-25 21:55:30 +02:00
|
|
|
ret = btrfs_pin_extent_for_log_replay(log->fs_info->extent_root,
|
|
|
|
eb->start, eb->len);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2013-04-25 21:55:30 +02:00
|
|
|
if (!ret && btrfs_buffer_uptodate(eb, gen, 0)) {
|
2013-06-06 19:19:32 +02:00
|
|
|
if (wc->pin && btrfs_header_level(eb) == 0)
|
|
|
|
ret = btrfs_exclude_logged_extents(log, eb);
|
2008-09-05 22:13:11 +02:00
|
|
|
if (wc->write)
|
|
|
|
btrfs_write_tree_block(eb);
|
|
|
|
if (wc->wait)
|
|
|
|
btrfs_wait_tree_block_writeback(eb);
|
|
|
|
}
|
2013-04-25 21:55:30 +02:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Item overwrite used by replay and tree logging. eb, slot and key all refer
|
|
|
|
* to the src data we are copying out.
|
|
|
|
*
|
|
|
|
* root is the tree we are copying into, and path is a scratch
|
|
|
|
* path for use in this function (it should be released on entry and
|
|
|
|
* will be released on exit).
|
|
|
|
*
|
|
|
|
* If the key is already in the destination tree the existing item is
|
|
|
|
* overwritten. If the existing item isn't big enough, it is extended.
|
|
|
|
* If it is too large, it is truncated.
|
|
|
|
*
|
|
|
|
* If the key isn't in the destination yet, a new item is inserted.
|
|
|
|
*/
|
|
|
|
static noinline int overwrite_item(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct extent_buffer *eb, int slot,
|
|
|
|
struct btrfs_key *key)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u32 item_size;
|
|
|
|
u64 saved_i_size = 0;
|
|
|
|
int save_old_i_size = 0;
|
|
|
|
unsigned long src_ptr;
|
|
|
|
unsigned long dst_ptr;
|
|
|
|
int overwrite_root = 0;
|
2013-04-05 22:50:09 +02:00
|
|
|
bool inode_item = key->type == BTRFS_INODE_ITEM_KEY;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
|
|
|
|
overwrite_root = 1;
|
|
|
|
|
|
|
|
item_size = btrfs_item_size_nr(eb, slot);
|
|
|
|
src_ptr = btrfs_item_ptr_offset(eb, slot);
|
|
|
|
|
|
|
|
/* look for the key in the destination tree */
|
|
|
|
ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
|
2013-04-05 22:50:09 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
if (ret == 0) {
|
|
|
|
char *src_copy;
|
|
|
|
char *dst_copy;
|
|
|
|
u32 dst_size = btrfs_item_size_nr(path->nodes[0],
|
|
|
|
path->slots[0]);
|
|
|
|
if (dst_size != item_size)
|
|
|
|
goto insert;
|
|
|
|
|
|
|
|
if (item_size == 0) {
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
dst_copy = kmalloc(item_size, GFP_NOFS);
|
|
|
|
src_copy = kmalloc(item_size, GFP_NOFS);
|
2011-01-26 07:22:08 +01:00
|
|
|
if (!dst_copy || !src_copy) {
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2011-01-26 07:22:08 +01:00
|
|
|
kfree(dst_copy);
|
|
|
|
kfree(src_copy);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
read_extent_buffer(eb, src_copy, src_ptr, item_size);
|
|
|
|
|
|
|
|
dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
|
|
|
|
read_extent_buffer(path->nodes[0], dst_copy, dst_ptr,
|
|
|
|
item_size);
|
|
|
|
ret = memcmp(dst_copy, src_copy, item_size);
|
|
|
|
|
|
|
|
kfree(dst_copy);
|
|
|
|
kfree(src_copy);
|
|
|
|
/*
|
|
|
|
* they have the same contents, just return, this saves
|
|
|
|
* us from cowing blocks in the destination tree and doing
|
|
|
|
* extra writes that may not have been done by a previous
|
|
|
|
* sync
|
|
|
|
*/
|
|
|
|
if (ret == 0) {
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-05 22:50:09 +02:00
|
|
|
/*
|
|
|
|
* We need to load the old nbytes into the inode so when we
|
|
|
|
* replay the extents we've logged we get the right nbytes.
|
|
|
|
*/
|
|
|
|
if (inode_item) {
|
|
|
|
struct btrfs_inode_item *item;
|
|
|
|
u64 nbytes;
|
2013-09-11 20:17:00 +02:00
|
|
|
u32 mode;
|
2013-04-05 22:50:09 +02:00
|
|
|
|
|
|
|
item = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_inode_item);
|
|
|
|
nbytes = btrfs_inode_nbytes(path->nodes[0], item);
|
|
|
|
item = btrfs_item_ptr(eb, slot,
|
|
|
|
struct btrfs_inode_item);
|
|
|
|
btrfs_set_inode_nbytes(eb, item, nbytes);
|
2013-09-11 20:17:00 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a directory we need to reset the i_size to
|
|
|
|
* 0 so that we can set it up properly when replaying
|
|
|
|
* the rest of the items in this log.
|
|
|
|
*/
|
|
|
|
mode = btrfs_inode_mode(eb, item);
|
|
|
|
if (S_ISDIR(mode))
|
|
|
|
btrfs_set_inode_size(eb, item, 0);
|
2013-04-05 22:50:09 +02:00
|
|
|
}
|
|
|
|
} else if (inode_item) {
|
|
|
|
struct btrfs_inode_item *item;
|
2013-09-11 20:17:00 +02:00
|
|
|
u32 mode;
|
2013-04-05 22:50:09 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* New inode, set nbytes to 0 so that the nbytes comes out
|
|
|
|
* properly when we replay the extents.
|
|
|
|
*/
|
|
|
|
item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
|
|
|
|
btrfs_set_inode_nbytes(eb, item, 0);
|
2013-09-11 20:17:00 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a directory we need to reset the i_size to 0 so
|
|
|
|
* that we can set it up properly when replaying the rest of
|
|
|
|
* the items in this log.
|
|
|
|
*/
|
|
|
|
mode = btrfs_inode_mode(eb, item);
|
|
|
|
if (S_ISDIR(mode))
|
|
|
|
btrfs_set_inode_size(eb, item, 0);
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
insert:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
/* try to insert the key into the destination tree */
|
Btrfs: fix fsync log replay for inodes with a mix of regular refs and extrefs
If we have an inode with a large number of hard links, some of which may
be extrefs, turn a regular ref into an extref, fsync the inode and then
replay the fsync log (after a crash/reboot), we can endup with an fsync
log that makes the replay code always fail with -EOVERFLOW when processing
the inode's references.
This is easy to reproduce with the test case I made for xfstests. Its steps
are the following:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Now remove one link, add a new one with a new name, add another new one with
# the same name as the one we just removed and fsync the inode.
rm -f $SCRATCH_MNT/foo_link_0001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_0001
rm -f $SCRATCH_MNT/foo_link_0002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3003
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Check that the number of hard links is correct, we are able to remove all
# the hard links and read the file's data. This is just to verify we don't
# get stale file handle errors (due to dangling directory index entries that
# point to inodes that no longer exist).
echo "Link count: $(stat --format=%h $SCRATCH_MNT/foo)"
[ -f $SCRATCH_MNT/foo ] || echo "Link foo is missing"
for ((i = 1; i <= 3003; i++)); do
name=foo_link_`printf "%04d" $i`
if [ $i -eq 2 ]; then
[ -f $SCRATCH_MNT/$name ] && echo "Link $name found"
else
[ -f $SCRATCH_MNT/$name ] || echo "Link $name is missing"
fi
done
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
rm -f $SCRATCH_MNT/foo
status=0
exit
The fix is simply to correct the overflow condition when overwriting a
reference item because it was wrong, trying to increase the item in the
fs/subvol tree by an impossible amount. Also ensure that we don't insert
one normal ref and one ext ref for the same dentry - this happened because
processing a dir index entry from the parent in the log happened when
the normal ref item was full, which made the logic insert an extref and
later when the normal ref had enough room, it would be inserted again
when processing the ref item from the child inode in the log.
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon. This test only passes if the previous
patch titled "Btrfs: fix fsync when extend references are added to an inode"
is applied too.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-14 02:52:25 +01:00
|
|
|
path->skip_release_on_error = 1;
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_insert_empty_item(trans, root, path,
|
|
|
|
key, item_size);
|
Btrfs: fix fsync log replay for inodes with a mix of regular refs and extrefs
If we have an inode with a large number of hard links, some of which may
be extrefs, turn a regular ref into an extref, fsync the inode and then
replay the fsync log (after a crash/reboot), we can endup with an fsync
log that makes the replay code always fail with -EOVERFLOW when processing
the inode's references.
This is easy to reproduce with the test case I made for xfstests. Its steps
are the following:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Now remove one link, add a new one with a new name, add another new one with
# the same name as the one we just removed and fsync the inode.
rm -f $SCRATCH_MNT/foo_link_0001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_0001
rm -f $SCRATCH_MNT/foo_link_0002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3003
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Check that the number of hard links is correct, we are able to remove all
# the hard links and read the file's data. This is just to verify we don't
# get stale file handle errors (due to dangling directory index entries that
# point to inodes that no longer exist).
echo "Link count: $(stat --format=%h $SCRATCH_MNT/foo)"
[ -f $SCRATCH_MNT/foo ] || echo "Link foo is missing"
for ((i = 1; i <= 3003; i++)); do
name=foo_link_`printf "%04d" $i`
if [ $i -eq 2 ]; then
[ -f $SCRATCH_MNT/$name ] && echo "Link $name found"
else
[ -f $SCRATCH_MNT/$name ] || echo "Link $name is missing"
fi
done
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
rm -f $SCRATCH_MNT/foo
status=0
exit
The fix is simply to correct the overflow condition when overwriting a
reference item because it was wrong, trying to increase the item in the
fs/subvol tree by an impossible amount. Also ensure that we don't insert
one normal ref and one ext ref for the same dentry - this happened because
processing a dir index entry from the parent in the log happened when
the normal ref item was full, which made the logic insert an extref and
later when the normal ref had enough room, it would be inserted again
when processing the ref item from the child inode in the log.
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon. This test only passes if the previous
patch titled "Btrfs: fix fsync when extend references are added to an inode"
is applied too.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-14 02:52:25 +01:00
|
|
|
path->skip_release_on_error = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* make sure any existing item is the correct size */
|
Btrfs: fix fsync log replay for inodes with a mix of regular refs and extrefs
If we have an inode with a large number of hard links, some of which may
be extrefs, turn a regular ref into an extref, fsync the inode and then
replay the fsync log (after a crash/reboot), we can endup with an fsync
log that makes the replay code always fail with -EOVERFLOW when processing
the inode's references.
This is easy to reproduce with the test case I made for xfstests. Its steps
are the following:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Now remove one link, add a new one with a new name, add another new one with
# the same name as the one we just removed and fsync the inode.
rm -f $SCRATCH_MNT/foo_link_0001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_0001
rm -f $SCRATCH_MNT/foo_link_0002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3003
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Check that the number of hard links is correct, we are able to remove all
# the hard links and read the file's data. This is just to verify we don't
# get stale file handle errors (due to dangling directory index entries that
# point to inodes that no longer exist).
echo "Link count: $(stat --format=%h $SCRATCH_MNT/foo)"
[ -f $SCRATCH_MNT/foo ] || echo "Link foo is missing"
for ((i = 1; i <= 3003; i++)); do
name=foo_link_`printf "%04d" $i`
if [ $i -eq 2 ]; then
[ -f $SCRATCH_MNT/$name ] && echo "Link $name found"
else
[ -f $SCRATCH_MNT/$name ] || echo "Link $name is missing"
fi
done
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
rm -f $SCRATCH_MNT/foo
status=0
exit
The fix is simply to correct the overflow condition when overwriting a
reference item because it was wrong, trying to increase the item in the
fs/subvol tree by an impossible amount. Also ensure that we don't insert
one normal ref and one ext ref for the same dentry - this happened because
processing a dir index entry from the parent in the log happened when
the normal ref item was full, which made the logic insert an extref and
later when the normal ref had enough room, it would be inserted again
when processing the ref item from the child inode in the log.
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon. This test only passes if the previous
patch titled "Btrfs: fix fsync when extend references are added to an inode"
is applied too.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-14 02:52:25 +01:00
|
|
|
if (ret == -EEXIST || ret == -EOVERFLOW) {
|
2008-09-05 22:13:11 +02:00
|
|
|
u32 found_size;
|
|
|
|
found_size = btrfs_item_size_nr(path->nodes[0],
|
|
|
|
path->slots[0]);
|
2012-03-01 14:56:26 +01:00
|
|
|
if (found_size > item_size)
|
2013-04-16 07:18:22 +02:00
|
|
|
btrfs_truncate_item(root, path, item_size, 1);
|
2012-03-01 14:56:26 +01:00
|
|
|
else if (found_size < item_size)
|
2013-04-16 07:18:49 +02:00
|
|
|
btrfs_extend_item(root, path,
|
2012-03-01 14:56:26 +01:00
|
|
|
item_size - found_size);
|
2008-09-05 22:13:11 +02:00
|
|
|
} else if (ret) {
|
2010-05-16 16:49:59 +02:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
dst_ptr = btrfs_item_ptr_offset(path->nodes[0],
|
|
|
|
path->slots[0]);
|
|
|
|
|
|
|
|
/* don't overwrite an existing inode if the generation number
|
|
|
|
* was logged as zero. This is done when the tree logging code
|
|
|
|
* is just logging an inode to make sure it exists after recovery.
|
|
|
|
*
|
|
|
|
* Also, don't overwrite i_size on directories during replay.
|
|
|
|
* log replay inserts and removes directory items based on the
|
|
|
|
* state of the tree found in the subvolume, and i_size is modified
|
|
|
|
* as it goes
|
|
|
|
*/
|
|
|
|
if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
|
|
|
|
struct btrfs_inode_item *src_item;
|
|
|
|
struct btrfs_inode_item *dst_item;
|
|
|
|
|
|
|
|
src_item = (struct btrfs_inode_item *)src_ptr;
|
|
|
|
dst_item = (struct btrfs_inode_item *)dst_ptr;
|
|
|
|
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
if (btrfs_inode_generation(eb, src_item) == 0) {
|
|
|
|
struct extent_buffer *dst_eb = path->nodes[0];
|
|
|
|
|
|
|
|
if (S_ISREG(btrfs_inode_mode(eb, src_item)) &&
|
|
|
|
S_ISREG(btrfs_inode_mode(dst_eb, dst_item))) {
|
|
|
|
struct btrfs_map_token token;
|
|
|
|
u64 ino_size = btrfs_inode_size(eb, src_item);
|
|
|
|
|
|
|
|
btrfs_init_map_token(&token);
|
|
|
|
btrfs_set_token_inode_size(dst_eb, dst_item,
|
|
|
|
ino_size, &token);
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
goto no_copy;
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
if (overwrite_root &&
|
|
|
|
S_ISDIR(btrfs_inode_mode(eb, src_item)) &&
|
|
|
|
S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) {
|
|
|
|
save_old_i_size = 1;
|
|
|
|
saved_i_size = btrfs_inode_size(path->nodes[0],
|
|
|
|
dst_item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
copy_extent_buffer(path->nodes[0], eb, dst_ptr,
|
|
|
|
src_ptr, item_size);
|
|
|
|
|
|
|
|
if (save_old_i_size) {
|
|
|
|
struct btrfs_inode_item *dst_item;
|
|
|
|
dst_item = (struct btrfs_inode_item *)dst_ptr;
|
|
|
|
btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure the generation is filled in */
|
|
|
|
if (key->type == BTRFS_INODE_ITEM_KEY) {
|
|
|
|
struct btrfs_inode_item *dst_item;
|
|
|
|
dst_item = (struct btrfs_inode_item *)dst_ptr;
|
|
|
|
if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) {
|
|
|
|
btrfs_set_inode_generation(path->nodes[0], dst_item,
|
|
|
|
trans->transid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
no_copy:
|
|
|
|
btrfs_mark_buffer_dirty(path->nodes[0]);
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* simple helper to read an inode off the disk from a given root
|
|
|
|
* This can only be called for subvolume roots and not for the log
|
|
|
|
*/
|
|
|
|
static noinline struct inode *read_one_inode(struct btrfs_root *root,
|
|
|
|
u64 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 16:45:14 +02:00
|
|
|
struct btrfs_key key;
|
2008-09-05 22:13:11 +02:00
|
|
|
struct inode *inode;
|
|
|
|
|
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 16:45:14 +02:00
|
|
|
key.objectid = objectid;
|
|
|
|
key.type = BTRFS_INODE_ITEM_KEY;
|
|
|
|
key.offset = 0;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-04 18:38:27 +01:00
|
|
|
inode = btrfs_iget(root->fs_info->sb, &key, root, NULL);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 16:45:14 +02:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
inode = NULL;
|
|
|
|
} else if (is_bad_inode(inode)) {
|
2008-09-05 22:13:11 +02:00
|
|
|
iput(inode);
|
|
|
|
inode = NULL;
|
|
|
|
}
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* replays a single extent in 'eb' at 'slot' with 'key' into the
|
|
|
|
* subvolume 'root'. path is released on entry and should be released
|
|
|
|
* on exit.
|
|
|
|
*
|
|
|
|
* extents in the log tree have not been allocated out of the extent
|
|
|
|
* tree yet. So, this completes the allocation, taking a reference
|
|
|
|
* as required if the extent already exists or creating a new extent
|
|
|
|
* if it isn't in the extent allocation tree yet.
|
|
|
|
*
|
|
|
|
* The extent is inserted into the file, dropping any existing extents
|
|
|
|
* from the file that overlap the new one.
|
|
|
|
*/
|
|
|
|
static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct extent_buffer *eb, int slot,
|
|
|
|
struct btrfs_key *key)
|
|
|
|
{
|
|
|
|
int found_type;
|
|
|
|
u64 extent_end;
|
|
|
|
u64 start = key->offset;
|
2013-04-05 22:50:09 +02:00
|
|
|
u64 nbytes = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
struct btrfs_file_extent_item *item;
|
|
|
|
struct inode *inode = NULL;
|
|
|
|
unsigned long size;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
|
|
|
|
found_type = btrfs_file_extent_type(eb, item);
|
|
|
|
|
2008-10-30 19:25:28 +01:00
|
|
|
if (found_type == BTRFS_FILE_EXTENT_REG ||
|
2013-04-05 22:50:09 +02:00
|
|
|
found_type == BTRFS_FILE_EXTENT_PREALLOC) {
|
|
|
|
nbytes = btrfs_file_extent_num_bytes(eb, item);
|
|
|
|
extent_end = start + nbytes;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't add to the inodes nbytes if we are prealloc or a
|
|
|
|
* hole.
|
|
|
|
*/
|
|
|
|
if (btrfs_file_extent_disk_bytenr(eb, item) == 0)
|
|
|
|
nbytes = 0;
|
|
|
|
} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
|
2014-01-04 06:07:00 +01:00
|
|
|
size = btrfs_file_extent_inline_len(eb, slot, item);
|
2013-04-05 22:50:09 +02:00
|
|
|
nbytes = btrfs_file_extent_ram_bytes(eb, item);
|
2013-02-26 09:10:22 +01:00
|
|
|
extent_end = ALIGN(start + size, root->sectorsize);
|
2008-09-05 22:13:11 +02:00
|
|
|
} else {
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
inode = read_one_inode(root, key->objectid);
|
|
|
|
if (!inode) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* first check to see if we already have this extent in the
|
|
|
|
* file. This must be done before the btrfs_drop_extents run
|
|
|
|
* so we don't try to drop this extent.
|
|
|
|
*/
|
2011-04-20 04:31:50 +02:00
|
|
|
ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
|
2008-09-05 22:13:11 +02:00
|
|
|
start, 0);
|
|
|
|
|
2008-10-30 19:25:28 +01:00
|
|
|
if (ret == 0 &&
|
|
|
|
(found_type == BTRFS_FILE_EXTENT_REG ||
|
|
|
|
found_type == BTRFS_FILE_EXTENT_PREALLOC)) {
|
2008-09-05 22:13:11 +02:00
|
|
|
struct btrfs_file_extent_item cmp1;
|
|
|
|
struct btrfs_file_extent_item cmp2;
|
|
|
|
struct btrfs_file_extent_item *existing;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
existing = btrfs_item_ptr(leaf, path->slots[0],
|
|
|
|
struct btrfs_file_extent_item);
|
|
|
|
|
|
|
|
read_extent_buffer(eb, &cmp1, (unsigned long)item,
|
|
|
|
sizeof(cmp1));
|
|
|
|
read_extent_buffer(leaf, &cmp2, (unsigned long)existing,
|
|
|
|
sizeof(cmp2));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we already have a pointer to this exact extent,
|
|
|
|
* we don't have to do anything
|
|
|
|
*/
|
|
|
|
if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) {
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* drop any overlapping extents */
|
2012-08-29 18:24:27 +02:00
|
|
|
ret = btrfs_drop_extents(trans, root, inode, start, extent_end, 1);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-06 17:42:00 +01:00
|
|
|
if (found_type == BTRFS_FILE_EXTENT_REG ||
|
|
|
|
found_type == BTRFS_FILE_EXTENT_PREALLOC) {
|
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 16:45:14 +02:00
|
|
|
u64 offset;
|
2009-01-06 17:42:00 +01:00
|
|
|
unsigned long dest_offset;
|
|
|
|
struct btrfs_key ins;
|
|
|
|
|
|
|
|
ret = btrfs_insert_empty_item(trans, root, path, key,
|
|
|
|
sizeof(*item));
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-01-06 17:42:00 +01:00
|
|
|
dest_offset = btrfs_item_ptr_offset(path->nodes[0],
|
|
|
|
path->slots[0]);
|
|
|
|
copy_extent_buffer(path->nodes[0], eb, dest_offset,
|
|
|
|
(unsigned long)item, sizeof(*item));
|
|
|
|
|
|
|
|
ins.objectid = btrfs_file_extent_disk_bytenr(eb, item);
|
|
|
|
ins.offset = btrfs_file_extent_disk_num_bytes(eb, item);
|
|
|
|
ins.type = BTRFS_EXTENT_ITEM_KEY;
|
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 16:45:14 +02:00
|
|
|
offset = key->offset - btrfs_file_extent_offset(eb, item);
|
2009-01-06 17:42:00 +01:00
|
|
|
|
|
|
|
if (ins.objectid > 0) {
|
|
|
|
u64 csum_start;
|
|
|
|
u64 csum_end;
|
|
|
|
LIST_HEAD(ordered_sums);
|
|
|
|
/*
|
|
|
|
* is this extent already allocated in the extent
|
|
|
|
* allocation tree? If so, just add a reference
|
|
|
|
*/
|
2014-10-27 11:44:24 +01:00
|
|
|
ret = btrfs_lookup_data_extent(root, ins.objectid,
|
2009-01-06 17:42:00 +01:00
|
|
|
ins.offset);
|
|
|
|
if (ret == 0) {
|
|
|
|
ret = btrfs_inc_extent_ref(trans, root,
|
|
|
|
ins.objectid, ins.offset,
|
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 16:45:14 +02:00
|
|
|
0, root->root_key.objectid,
|
2011-09-12 15:26:38 +02:00
|
|
|
key->objectid, offset, 0);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-01-06 17:42:00 +01:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* insert the extent pointer in the extent
|
|
|
|
* allocation tree
|
|
|
|
*/
|
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 16:45:14 +02:00
|
|
|
ret = btrfs_alloc_logged_file_extent(trans,
|
|
|
|
root, root->root_key.objectid,
|
|
|
|
key->objectid, offset, &ins);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-01-06 17:42:00 +01:00
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2009-01-06 17:42:00 +01:00
|
|
|
|
|
|
|
if (btrfs_file_extent_compression(eb, item)) {
|
|
|
|
csum_start = ins.objectid;
|
|
|
|
csum_end = csum_start + ins.offset;
|
|
|
|
} else {
|
|
|
|
csum_start = ins.objectid +
|
|
|
|
btrfs_file_extent_offset(eb, item);
|
|
|
|
csum_end = csum_start +
|
|
|
|
btrfs_file_extent_num_bytes(eb, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = btrfs_lookup_csums_range(root->log_root,
|
|
|
|
csum_start, csum_end - 1,
|
2011-03-08 14:14:00 +01:00
|
|
|
&ordered_sums, 0);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-01-06 17:42:00 +01:00
|
|
|
while (!list_empty(&ordered_sums)) {
|
|
|
|
struct btrfs_ordered_sum *sums;
|
|
|
|
sums = list_entry(ordered_sums.next,
|
|
|
|
struct btrfs_ordered_sum,
|
|
|
|
list);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (!ret)
|
|
|
|
ret = btrfs_csum_file_blocks(trans,
|
2009-01-06 17:42:00 +01:00
|
|
|
root->fs_info->csum_root,
|
|
|
|
sums);
|
|
|
|
list_del(&sums->list);
|
|
|
|
kfree(sums);
|
|
|
|
}
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-01-06 17:42:00 +01:00
|
|
|
} else {
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2009-01-06 17:42:00 +01:00
|
|
|
}
|
|
|
|
} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
|
|
|
|
/* inline extents are easy, we just overwrite them */
|
|
|
|
ret = overwrite_item(trans, root, path, eb, slot, key);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-01-06 17:42:00 +01:00
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2013-04-05 22:50:09 +02:00
|
|
|
inode_add_bytes(inode, nbytes);
|
2012-06-26 05:25:22 +02:00
|
|
|
ret = btrfs_update_inode(trans, root, inode);
|
2008-09-05 22:13:11 +02:00
|
|
|
out:
|
|
|
|
if (inode)
|
|
|
|
iput(inode);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* when cleaning up conflicts between the directory names in the
|
|
|
|
* subvolume, directory names in the log and directory names in the
|
|
|
|
* inode back references, we may have to unlink inodes from directories.
|
|
|
|
*
|
|
|
|
* This is a helper function to do the unlink of a specific directory
|
|
|
|
* item
|
|
|
|
*/
|
|
|
|
static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct inode *dir,
|
|
|
|
struct btrfs_dir_item *di)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
char *name;
|
|
|
|
int name_len;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key location;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
|
|
|
btrfs_dir_item_key_to_cpu(leaf, di, &location);
|
|
|
|
name_len = btrfs_dir_name_len(leaf, di);
|
|
|
|
name = kmalloc(name_len, GFP_NOFS);
|
2011-01-26 07:22:08 +01:00
|
|
|
if (!name)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len);
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
inode = read_one_inode(root, location.objectid);
|
2011-04-28 11:10:23 +02:00
|
|
|
if (!inode) {
|
2013-04-25 22:23:32 +02:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2011-04-28 11:10:23 +02:00
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-05 21:43:42 +01:00
|
|
|
ret = link_to_fixup_dir(trans, root, path, location.objectid);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-03-24 15:24:20 +01:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2013-08-05 10:25:47 +02:00
|
|
|
else
|
|
|
|
ret = btrfs_run_delayed_items(trans, root);
|
2013-04-25 22:23:32 +02:00
|
|
|
out:
|
2008-09-05 22:13:11 +02:00
|
|
|
kfree(name);
|
|
|
|
iput(inode);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to see if a given name and sequence number found
|
|
|
|
* in an inode back reference are already in a directory and correctly
|
|
|
|
* point to this inode
|
|
|
|
*/
|
|
|
|
static noinline int inode_in_dir(struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
u64 dirid, u64 objectid, u64 index,
|
|
|
|
const char *name, int name_len)
|
|
|
|
{
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
struct btrfs_key location;
|
|
|
|
int match = 0;
|
|
|
|
|
|
|
|
di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
|
|
|
|
index, name, name_len, 0);
|
|
|
|
if (di && !IS_ERR(di)) {
|
|
|
|
btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
|
|
|
|
if (location.objectid != objectid)
|
|
|
|
goto out;
|
|
|
|
} else
|
|
|
|
goto out;
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
|
|
|
|
if (di && !IS_ERR(di)) {
|
|
|
|
btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
|
|
|
|
if (location.objectid != objectid)
|
|
|
|
goto out;
|
|
|
|
} else
|
|
|
|
goto out;
|
|
|
|
match = 1;
|
|
|
|
out:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
return match;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to check a log tree for a named back reference in
|
|
|
|
* an inode. This is used to decide if a back reference that is
|
|
|
|
* found in the subvolume conflicts with what we find in the log.
|
|
|
|
*
|
|
|
|
* inode backreferences may have multiple refs in a single item,
|
|
|
|
* during replay we process one reference at a time, and we don't
|
|
|
|
* want to delete valid links to a file from the subvolume if that
|
|
|
|
* link is also in the log.
|
|
|
|
*/
|
|
|
|
static noinline int backref_in_log(struct btrfs_root *log,
|
|
|
|
struct btrfs_key *key,
|
2012-08-08 20:32:27 +02:00
|
|
|
u64 ref_objectid,
|
Btrfs: fix fsync log replay for inodes with a mix of regular refs and extrefs
If we have an inode with a large number of hard links, some of which may
be extrefs, turn a regular ref into an extref, fsync the inode and then
replay the fsync log (after a crash/reboot), we can endup with an fsync
log that makes the replay code always fail with -EOVERFLOW when processing
the inode's references.
This is easy to reproduce with the test case I made for xfstests. Its steps
are the following:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Now remove one link, add a new one with a new name, add another new one with
# the same name as the one we just removed and fsync the inode.
rm -f $SCRATCH_MNT/foo_link_0001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_0001
rm -f $SCRATCH_MNT/foo_link_0002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3003
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Check that the number of hard links is correct, we are able to remove all
# the hard links and read the file's data. This is just to verify we don't
# get stale file handle errors (due to dangling directory index entries that
# point to inodes that no longer exist).
echo "Link count: $(stat --format=%h $SCRATCH_MNT/foo)"
[ -f $SCRATCH_MNT/foo ] || echo "Link foo is missing"
for ((i = 1; i <= 3003; i++)); do
name=foo_link_`printf "%04d" $i`
if [ $i -eq 2 ]; then
[ -f $SCRATCH_MNT/$name ] && echo "Link $name found"
else
[ -f $SCRATCH_MNT/$name ] || echo "Link $name is missing"
fi
done
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
rm -f $SCRATCH_MNT/foo
status=0
exit
The fix is simply to correct the overflow condition when overwriting a
reference item because it was wrong, trying to increase the item in the
fs/subvol tree by an impossible amount. Also ensure that we don't insert
one normal ref and one ext ref for the same dentry - this happened because
processing a dir index entry from the parent in the log happened when
the normal ref item was full, which made the logic insert an extref and
later when the normal ref had enough room, it would be inserted again
when processing the ref item from the child inode in the log.
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon. This test only passes if the previous
patch titled "Btrfs: fix fsync when extend references are added to an inode"
is applied too.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-14 02:52:25 +01:00
|
|
|
const char *name, int namelen)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_inode_ref *ref;
|
|
|
|
unsigned long ptr;
|
|
|
|
unsigned long ptr_end;
|
|
|
|
unsigned long name_ptr;
|
|
|
|
int found_name_len;
|
|
|
|
int item_size;
|
|
|
|
int ret;
|
|
|
|
int match = 0;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2011-01-26 07:22:08 +01:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
|
|
|
|
if (ret != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
|
2012-08-08 20:32:27 +02:00
|
|
|
|
|
|
|
if (key->type == BTRFS_INODE_EXTREF_KEY) {
|
|
|
|
if (btrfs_find_name_in_ext_backref(path, ref_objectid,
|
|
|
|
name, namelen, NULL))
|
|
|
|
match = 1;
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
|
2008-09-05 22:13:11 +02:00
|
|
|
ptr_end = ptr + item_size;
|
|
|
|
while (ptr < ptr_end) {
|
|
|
|
ref = (struct btrfs_inode_ref *)ptr;
|
|
|
|
found_name_len = btrfs_inode_ref_name_len(path->nodes[0], ref);
|
|
|
|
if (found_name_len == namelen) {
|
|
|
|
name_ptr = (unsigned long)(ref + 1);
|
|
|
|
ret = memcmp_extent_buffer(path->nodes[0], name,
|
|
|
|
name_ptr, namelen);
|
|
|
|
if (ret == 0) {
|
|
|
|
match = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ptr = (unsigned long)(ref + 1) + found_name_len;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
|
2012-08-17 23:04:41 +02:00
|
|
|
static inline int __add_inode_ref(struct btrfs_trans_handle *trans,
|
2008-09-05 22:13:11 +02:00
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
2012-08-17 23:04:41 +02:00
|
|
|
struct btrfs_root *log_root,
|
|
|
|
struct inode *dir, struct inode *inode,
|
|
|
|
struct extent_buffer *eb,
|
2012-08-08 20:32:27 +02:00
|
|
|
u64 inode_objectid, u64 parent_objectid,
|
|
|
|
u64 ref_index, char *name, int namelen,
|
|
|
|
int *search_done)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
2011-08-06 10:35:23 +02:00
|
|
|
int ret;
|
2012-08-08 20:32:27 +02:00
|
|
|
char *victim_name;
|
|
|
|
int victim_name_len;
|
|
|
|
struct extent_buffer *leaf;
|
2012-08-17 23:04:41 +02:00
|
|
|
struct btrfs_dir_item *di;
|
2012-08-08 20:32:27 +02:00
|
|
|
struct btrfs_key search_key;
|
|
|
|
struct btrfs_inode_extref *extref;
|
btrfs: make inode ref log recovery faster
When we recover from crash via write-ahead log tree and process
the inode refs, for each btrfs_inode_ref item, we will
1) check if we already have a perfect match in fs/file tree, if
we have, then we're done.
2) search the corresponding back reference in fs/file tree, and
check all the names in this back reference to see if they are
also in the log to avoid conflict corners.
3) recover the logged inode refs to fs/file tree.
In current btrfs, however,
- for 2)'s check, once is enough, since the checked back reference
will remain unchanged after processing all the inode refs belonged
to the key.
- it has no need to do another 1) between 2) and 3).
I've made a small test to show how it improves,
$dd if=/dev/zero of=foobar bs=4K count=1
$sync
$make 100 hard links continuously, like ln foobar link_i
$fsync foobar
$echo b > /proc/sysrq-trigger
after reboot
$time mount DEV PATH
without patch:
real 0m0.285s
user 0m0.001s
sys 0m0.009s
with patch:
real 0m0.123s
user 0m0.000s
sys 0m0.010s
Changelog v1->v2:
- fix double free - pointed by David Sterba
Changelog v2->v3:
- adjust free order
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-26 13:01:12 +01:00
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
again:
|
|
|
|
/* Search old style refs */
|
|
|
|
search_key.objectid = inode_objectid;
|
|
|
|
search_key.type = BTRFS_INODE_REF_KEY;
|
|
|
|
search_key.offset = parent_objectid;
|
|
|
|
ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
|
2008-09-05 22:13:11 +02:00
|
|
|
if (ret == 0) {
|
|
|
|
struct btrfs_inode_ref *victim_ref;
|
|
|
|
unsigned long ptr;
|
|
|
|
unsigned long ptr_end;
|
2012-08-08 20:32:27 +02:00
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* are we trying to overwrite a back ref for the root directory
|
|
|
|
* if so, just jump out, we're done
|
|
|
|
*/
|
2012-08-08 20:32:27 +02:00
|
|
|
if (search_key.objectid == search_key.offset)
|
2012-08-17 23:04:41 +02:00
|
|
|
return 1;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* check all the names in this back reference to see
|
|
|
|
* if they are in the log. if so, we allow them to stay
|
|
|
|
* otherwise they must be unlinked as a conflict
|
|
|
|
*/
|
|
|
|
ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
|
|
|
|
ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]);
|
2009-01-06 03:25:51 +01:00
|
|
|
while (ptr < ptr_end) {
|
2008-09-05 22:13:11 +02:00
|
|
|
victim_ref = (struct btrfs_inode_ref *)ptr;
|
|
|
|
victim_name_len = btrfs_inode_ref_name_len(leaf,
|
|
|
|
victim_ref);
|
|
|
|
victim_name = kmalloc(victim_name_len, GFP_NOFS);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (!victim_name)
|
|
|
|
return -ENOMEM;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
read_extent_buffer(leaf, victim_name,
|
|
|
|
(unsigned long)(victim_ref + 1),
|
|
|
|
victim_name_len);
|
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
if (!backref_in_log(log_root, &search_key,
|
|
|
|
parent_objectid,
|
|
|
|
victim_name,
|
2008-09-05 22:13:11 +02:00
|
|
|
victim_name_len)) {
|
2013-10-16 21:10:34 +02:00
|
|
|
inc_nlink(inode);
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2009-03-24 15:24:20 +01:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_unlink_inode(trans, root, dir,
|
|
|
|
inode, victim_name,
|
|
|
|
victim_name_len);
|
2012-08-08 20:32:27 +02:00
|
|
|
kfree(victim_name);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-08-05 10:25:47 +02:00
|
|
|
ret = btrfs_run_delayed_items(trans, root);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-08-08 20:32:27 +02:00
|
|
|
*search_done = 1;
|
|
|
|
goto again;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
kfree(victim_name);
|
2012-08-08 20:32:27 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
|
|
|
|
}
|
|
|
|
|
btrfs: make inode ref log recovery faster
When we recover from crash via write-ahead log tree and process
the inode refs, for each btrfs_inode_ref item, we will
1) check if we already have a perfect match in fs/file tree, if
we have, then we're done.
2) search the corresponding back reference in fs/file tree, and
check all the names in this back reference to see if they are
also in the log to avoid conflict corners.
3) recover the logged inode refs to fs/file tree.
In current btrfs, however,
- for 2)'s check, once is enough, since the checked back reference
will remain unchanged after processing all the inode refs belonged
to the key.
- it has no need to do another 1) between 2) and 3).
I've made a small test to show how it improves,
$dd if=/dev/zero of=foobar bs=4K count=1
$sync
$make 100 hard links continuously, like ln foobar link_i
$fsync foobar
$echo b > /proc/sysrq-trigger
after reboot
$time mount DEV PATH
without patch:
real 0m0.285s
user 0m0.001s
sys 0m0.009s
with patch:
real 0m0.123s
user 0m0.000s
sys 0m0.010s
Changelog v1->v2:
- fix double free - pointed by David Sterba
Changelog v2->v3:
- adjust free order
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-26 13:01:12 +01:00
|
|
|
/*
|
|
|
|
* NOTE: we have searched root tree and checked the
|
|
|
|
* coresponding ref, it does not need to check again.
|
|
|
|
*/
|
2012-08-17 23:04:41 +02:00
|
|
|
*search_done = 1;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
/* Same search but for extended refs */
|
|
|
|
extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen,
|
|
|
|
inode_objectid, parent_objectid, 0,
|
|
|
|
0);
|
|
|
|
if (!IS_ERR_OR_NULL(extref)) {
|
|
|
|
u32 item_size;
|
|
|
|
u32 cur_offset = 0;
|
|
|
|
unsigned long base;
|
|
|
|
struct inode *victim_parent;
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
|
|
|
item_size = btrfs_item_size_nr(leaf, path->slots[0]);
|
|
|
|
base = btrfs_item_ptr_offset(leaf, path->slots[0]);
|
|
|
|
|
|
|
|
while (cur_offset < item_size) {
|
2015-03-03 16:31:38 +01:00
|
|
|
extref = (struct btrfs_inode_extref *)(base + cur_offset);
|
2012-08-08 20:32:27 +02:00
|
|
|
|
|
|
|
victim_name_len = btrfs_inode_extref_name_len(leaf, extref);
|
|
|
|
|
|
|
|
if (btrfs_inode_extref_parent(leaf, extref) != parent_objectid)
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
victim_name = kmalloc(victim_name_len, GFP_NOFS);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (!victim_name)
|
|
|
|
return -ENOMEM;
|
2012-08-08 20:32:27 +02:00
|
|
|
read_extent_buffer(leaf, victim_name, (unsigned long)&extref->name,
|
|
|
|
victim_name_len);
|
|
|
|
|
|
|
|
search_key.objectid = inode_objectid;
|
|
|
|
search_key.type = BTRFS_INODE_EXTREF_KEY;
|
|
|
|
search_key.offset = btrfs_extref_hash(parent_objectid,
|
|
|
|
victim_name,
|
|
|
|
victim_name_len);
|
|
|
|
ret = 0;
|
|
|
|
if (!backref_in_log(log_root, &search_key,
|
|
|
|
parent_objectid, victim_name,
|
|
|
|
victim_name_len)) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
victim_parent = read_one_inode(root,
|
|
|
|
parent_objectid);
|
|
|
|
if (victim_parent) {
|
2013-10-16 21:10:34 +02:00
|
|
|
inc_nlink(inode);
|
2012-08-08 20:32:27 +02:00
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
ret = btrfs_unlink_inode(trans, root,
|
|
|
|
victim_parent,
|
|
|
|
inode,
|
|
|
|
victim_name,
|
|
|
|
victim_name_len);
|
2013-08-05 10:25:47 +02:00
|
|
|
if (!ret)
|
|
|
|
ret = btrfs_run_delayed_items(
|
|
|
|
trans, root);
|
2012-08-08 20:32:27 +02:00
|
|
|
}
|
|
|
|
iput(victim_parent);
|
|
|
|
kfree(victim_name);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-08-08 20:32:27 +02:00
|
|
|
*search_done = 1;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
kfree(victim_name);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-08-08 20:32:27 +02:00
|
|
|
next:
|
|
|
|
cur_offset += victim_name_len + sizeof(*extref);
|
|
|
|
}
|
|
|
|
*search_done = 1;
|
|
|
|
}
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
2011-08-06 10:35:23 +02:00
|
|
|
/* look for a conflicting sequence number */
|
|
|
|
di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
|
2012-08-08 20:32:27 +02:00
|
|
|
ref_index, name, namelen, 0);
|
2011-08-06 10:35:23 +02:00
|
|
|
if (di && !IS_ERR(di)) {
|
|
|
|
ret = drop_one_dir_item(trans, root, path, dir, di);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-08-06 10:35:23 +02:00
|
|
|
}
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
/* look for a conflicing name */
|
|
|
|
di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir),
|
|
|
|
name, namelen, 0);
|
|
|
|
if (di && !IS_ERR(di)) {
|
|
|
|
ret = drop_one_dir_item(trans, root, path, dir, di);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-08-06 10:35:23 +02:00
|
|
|
}
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
2012-08-17 23:04:41 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
static int extref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
|
|
|
|
u32 *namelen, char **name, u64 *index,
|
|
|
|
u64 *parent_objectid)
|
|
|
|
{
|
|
|
|
struct btrfs_inode_extref *extref;
|
|
|
|
|
|
|
|
extref = (struct btrfs_inode_extref *)ref_ptr;
|
|
|
|
|
|
|
|
*namelen = btrfs_inode_extref_name_len(eb, extref);
|
|
|
|
*name = kmalloc(*namelen, GFP_NOFS);
|
|
|
|
if (*name == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
read_extent_buffer(eb, *name, (unsigned long)&extref->name,
|
|
|
|
*namelen);
|
|
|
|
|
|
|
|
*index = btrfs_inode_extref_index(eb, extref);
|
|
|
|
if (parent_objectid)
|
|
|
|
*parent_objectid = btrfs_inode_extref_parent(eb, extref);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
|
|
|
|
u32 *namelen, char **name, u64 *index)
|
|
|
|
{
|
|
|
|
struct btrfs_inode_ref *ref;
|
|
|
|
|
|
|
|
ref = (struct btrfs_inode_ref *)ref_ptr;
|
|
|
|
|
|
|
|
*namelen = btrfs_inode_ref_name_len(eb, ref);
|
|
|
|
*name = kmalloc(*namelen, GFP_NOFS);
|
|
|
|
if (*name == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
read_extent_buffer(eb, *name, (unsigned long)(ref + 1), *namelen);
|
|
|
|
|
|
|
|
*index = btrfs_inode_ref_index(eb, ref);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-17 23:04:41 +02:00
|
|
|
/*
|
|
|
|
* replay one inode back reference item found in the log tree.
|
|
|
|
* eb, slot and key refer to the buffer and key found in the log tree.
|
|
|
|
* root is the destination we are replaying into, and path is for temp
|
|
|
|
* use by this function. (it should be released on return).
|
|
|
|
*/
|
|
|
|
static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_root *log,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct extent_buffer *eb, int slot,
|
|
|
|
struct btrfs_key *key)
|
|
|
|
{
|
2013-10-11 20:35:45 +02:00
|
|
|
struct inode *dir = NULL;
|
|
|
|
struct inode *inode = NULL;
|
2012-08-17 23:04:41 +02:00
|
|
|
unsigned long ref_ptr;
|
|
|
|
unsigned long ref_end;
|
2013-10-11 20:35:45 +02:00
|
|
|
char *name = NULL;
|
2012-08-17 23:04:41 +02:00
|
|
|
int namelen;
|
|
|
|
int ret;
|
|
|
|
int search_done = 0;
|
2012-08-08 20:32:27 +02:00
|
|
|
int log_ref_ver = 0;
|
|
|
|
u64 parent_objectid;
|
|
|
|
u64 inode_objectid;
|
2012-10-09 17:17:20 +02:00
|
|
|
u64 ref_index = 0;
|
2012-08-08 20:32:27 +02:00
|
|
|
int ref_struct_size;
|
|
|
|
|
|
|
|
ref_ptr = btrfs_item_ptr_offset(eb, slot);
|
|
|
|
ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
|
|
|
|
|
|
|
|
if (key->type == BTRFS_INODE_EXTREF_KEY) {
|
|
|
|
struct btrfs_inode_extref *r;
|
|
|
|
|
|
|
|
ref_struct_size = sizeof(struct btrfs_inode_extref);
|
|
|
|
log_ref_ver = 1;
|
|
|
|
r = (struct btrfs_inode_extref *)ref_ptr;
|
|
|
|
parent_objectid = btrfs_inode_extref_parent(eb, r);
|
|
|
|
} else {
|
|
|
|
ref_struct_size = sizeof(struct btrfs_inode_ref);
|
|
|
|
parent_objectid = key->offset;
|
|
|
|
}
|
|
|
|
inode_objectid = key->objectid;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2012-08-17 23:04:41 +02:00
|
|
|
/*
|
|
|
|
* it is possible that we didn't log all the parent directories
|
|
|
|
* for a given inode. If we don't find the dir, just don't
|
|
|
|
* copy the back ref in. The link count fixup code will take
|
|
|
|
* care of the rest
|
|
|
|
*/
|
2012-08-08 20:32:27 +02:00
|
|
|
dir = read_one_inode(root, parent_objectid);
|
2013-10-11 20:35:45 +02:00
|
|
|
if (!dir) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-17 23:04:41 +02:00
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
inode = read_one_inode(root, inode_objectid);
|
2012-08-17 23:04:41 +02:00
|
|
|
if (!inode) {
|
2013-10-11 20:35:45 +02:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2012-08-17 23:04:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
while (ref_ptr < ref_end) {
|
2012-08-08 20:32:27 +02:00
|
|
|
if (log_ref_ver) {
|
|
|
|
ret = extref_get_fields(eb, ref_ptr, &namelen, &name,
|
|
|
|
&ref_index, &parent_objectid);
|
|
|
|
/*
|
|
|
|
* parent object can change from one array
|
|
|
|
* item to another.
|
|
|
|
*/
|
|
|
|
if (!dir)
|
|
|
|
dir = read_one_inode(root, parent_objectid);
|
2013-10-11 20:35:45 +02:00
|
|
|
if (!dir) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-08 20:32:27 +02:00
|
|
|
} else {
|
|
|
|
ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
|
|
|
|
&ref_index);
|
|
|
|
}
|
|
|
|
if (ret)
|
2013-10-11 20:35:45 +02:00
|
|
|
goto out;
|
2012-08-17 23:04:41 +02:00
|
|
|
|
|
|
|
/* if we already have a perfect match, we're done */
|
|
|
|
if (!inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
|
2012-08-08 20:32:27 +02:00
|
|
|
ref_index, name, namelen)) {
|
2012-08-17 23:04:41 +02:00
|
|
|
/*
|
|
|
|
* look for a conflicting back reference in the
|
|
|
|
* metadata. if we find one we have to unlink that name
|
|
|
|
* of the file before we add our new link. Later on, we
|
|
|
|
* overwrite any existing back reference, and we don't
|
|
|
|
* want to create dangling pointers in the directory.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!search_done) {
|
|
|
|
ret = __add_inode_ref(trans, root, path, log,
|
2012-08-08 20:32:27 +02:00
|
|
|
dir, inode, eb,
|
|
|
|
inode_objectid,
|
|
|
|
parent_objectid,
|
|
|
|
ref_index, name, namelen,
|
2012-08-17 23:04:41 +02:00
|
|
|
&search_done);
|
2013-10-11 20:35:45 +02:00
|
|
|
if (ret) {
|
|
|
|
if (ret == 1)
|
|
|
|
ret = 0;
|
2013-04-25 22:23:32 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2012-08-17 23:04:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* insert our name */
|
|
|
|
ret = btrfs_add_link(trans, dir, inode, name, namelen,
|
2012-08-08 20:32:27 +02:00
|
|
|
0, ref_index);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2012-08-17 23:04:41 +02:00
|
|
|
|
|
|
|
btrfs_update_inode(trans, root, inode);
|
|
|
|
}
|
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
|
2012-08-17 23:04:41 +02:00
|
|
|
kfree(name);
|
2013-10-11 20:35:45 +02:00
|
|
|
name = NULL;
|
2012-08-08 20:32:27 +02:00
|
|
|
if (log_ref_ver) {
|
|
|
|
iput(dir);
|
|
|
|
dir = NULL;
|
|
|
|
}
|
2012-08-17 23:04:41 +02:00
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* finally write the back reference in the inode */
|
|
|
|
ret = overwrite_item(trans, root, path, eb, slot, key);
|
2012-08-17 23:04:41 +02:00
|
|
|
out:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2013-10-11 20:35:45 +02:00
|
|
|
kfree(name);
|
2008-09-05 22:13:11 +02:00
|
|
|
iput(dir);
|
|
|
|
iput(inode);
|
2013-04-25 22:23:32 +02:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
2009-11-12 10:34:40 +01:00
|
|
|
static int insert_orphan_item(struct btrfs_trans_handle *trans,
|
2015-01-02 19:12:57 +01:00
|
|
|
struct btrfs_root *root, u64 ino)
|
2009-11-12 10:34:40 +01:00
|
|
|
{
|
|
|
|
int ret;
|
2015-01-02 18:45:16 +01:00
|
|
|
|
2015-01-02 19:12:57 +01:00
|
|
|
ret = btrfs_insert_orphan_item(trans, root, ino);
|
|
|
|
if (ret == -EEXIST)
|
|
|
|
ret = 0;
|
2015-01-02 18:45:16 +01:00
|
|
|
|
2009-11-12 10:34:40 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
static int count_inode_extrefs(struct btrfs_root *root,
|
|
|
|
struct inode *inode, struct btrfs_path *path)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int name_len;
|
|
|
|
unsigned int nlink = 0;
|
|
|
|
u32 item_size;
|
|
|
|
u32 cur_offset = 0;
|
|
|
|
u64 inode_objectid = btrfs_ino(inode);
|
|
|
|
u64 offset = 0;
|
|
|
|
unsigned long ptr;
|
|
|
|
struct btrfs_inode_extref *extref;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
ret = btrfs_find_one_extref(root, inode_objectid, offset, path,
|
|
|
|
&extref, &offset);
|
|
|
|
if (ret)
|
|
|
|
break;
|
2009-11-12 10:34:40 +01:00
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
leaf = path->nodes[0];
|
|
|
|
item_size = btrfs_item_size_nr(leaf, path->slots[0]);
|
|
|
|
ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
|
Btrfs: fix fsync when extend references are added to an inode
If we added an extended reference to an inode and fsync'ed it, the log
replay code would make our inode have an incorrect link count, which
was lower then the expected/correct count.
This resulted in stale directory index entries after deleting some of
the hard links, and any access to the dangling directory entries resulted
in -ESTALE errors because the entries pointed to inode items that don't
exist anymore.
This is easy to reproduce with the test case I made for xfstests, and
the bulk of that test is:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Add one more link to the inode that ends up being a btrfs extref and fsync
# the inode.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Now after the fsync log replay btrfs left our inode with a wrong link count N,
# which was smaller than the correct link count M (N < M).
# So after removing N hard links, the remaining M - N directory entries were
# still visible to user space but it was impossible to do anything with them
# because they pointed to an inode that didn't exist anymore. This resulted in
# stale file handle errors (-ESTALE) when accessing those dentries for example.
#
# So remove all hard links except the first one and then attempt to read the
# file, to verify we don't get an -ESTALE error when accessing the inodel
#
# The btrfs fsck tool also detected the incorrect inode link count and it
# reported an error message like the following:
#
# root 5 inode 257 errors 2001, no inode item, link count wrong
# unresolved ref dir 256 index 2978 namelen 13 name foo_link_2976 filetype 1 errors 4, no inode ref
#
# The fstests framework automatically calls fsck after a test is run, so we
# don't need to call fsck explicitly here.
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
status=0
exit
So make sure an fsync always flushes the delayed inode item, so that the
fsync log contains it (needed in order to trigger the link count fixup
code) and fix the extref counting function, which always return -ENOENT
to its caller (and made it assume there were always 0 extrefs).
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-13 17:40:04 +01:00
|
|
|
cur_offset = 0;
|
2012-08-08 20:32:27 +02:00
|
|
|
|
|
|
|
while (cur_offset < item_size) {
|
|
|
|
extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
|
|
|
|
name_len = btrfs_inode_extref_name_len(leaf, extref);
|
|
|
|
|
|
|
|
nlink++;
|
|
|
|
|
|
|
|
cur_offset += name_len + sizeof(*extref);
|
|
|
|
}
|
|
|
|
|
|
|
|
offset++;
|
|
|
|
btrfs_release_path(path);
|
|
|
|
}
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
Btrfs: fix fsync when extend references are added to an inode
If we added an extended reference to an inode and fsync'ed it, the log
replay code would make our inode have an incorrect link count, which
was lower then the expected/correct count.
This resulted in stale directory index entries after deleting some of
the hard links, and any access to the dangling directory entries resulted
in -ESTALE errors because the entries pointed to inode items that don't
exist anymore.
This is easy to reproduce with the test case I made for xfstests, and
the bulk of that test is:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Add one more link to the inode that ends up being a btrfs extref and fsync
# the inode.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Now after the fsync log replay btrfs left our inode with a wrong link count N,
# which was smaller than the correct link count M (N < M).
# So after removing N hard links, the remaining M - N directory entries were
# still visible to user space but it was impossible to do anything with them
# because they pointed to an inode that didn't exist anymore. This resulted in
# stale file handle errors (-ESTALE) when accessing those dentries for example.
#
# So remove all hard links except the first one and then attempt to read the
# file, to verify we don't get an -ESTALE error when accessing the inodel
#
# The btrfs fsck tool also detected the incorrect inode link count and it
# reported an error message like the following:
#
# root 5 inode 257 errors 2001, no inode item, link count wrong
# unresolved ref dir 256 index 2978 namelen 13 name foo_link_2976 filetype 1 errors 4, no inode ref
#
# The fstests framework automatically calls fsck after a test is run, so we
# don't need to call fsck explicitly here.
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
status=0
exit
So make sure an fsync always flushes the delayed inode item, so that the
fsync log contains it (needed in order to trigger the link count fixup
code) and fix the extref counting function, which always return -ENOENT
to its caller (and made it assume there were always 0 extrefs).
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-13 17:40:04 +01:00
|
|
|
if (ret < 0 && ret != -ENOENT)
|
2012-08-08 20:32:27 +02:00
|
|
|
return ret;
|
|
|
|
return nlink;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int count_inode_refs(struct btrfs_root *root,
|
|
|
|
struct inode *inode, struct btrfs_path *path)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_key key;
|
2012-08-08 20:32:27 +02:00
|
|
|
unsigned int nlink = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
unsigned long ptr;
|
|
|
|
unsigned long ptr_end;
|
|
|
|
int name_len;
|
2011-04-20 04:31:50 +02:00
|
|
|
u64 ino = btrfs_ino(inode);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2011-04-20 04:31:50 +02:00
|
|
|
key.objectid = ino;
|
2008-09-05 22:13:11 +02:00
|
|
|
key.type = BTRFS_INODE_REF_KEY;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
if (ret > 0) {
|
|
|
|
if (path->slots[0] == 0)
|
|
|
|
break;
|
|
|
|
path->slots[0]--;
|
|
|
|
}
|
2013-10-14 23:49:11 +02:00
|
|
|
process_slot:
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key,
|
|
|
|
path->slots[0]);
|
2011-04-20 04:31:50 +02:00
|
|
|
if (key.objectid != ino ||
|
2008-09-05 22:13:11 +02:00
|
|
|
key.type != BTRFS_INODE_REF_KEY)
|
|
|
|
break;
|
|
|
|
ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
|
|
|
|
ptr_end = ptr + btrfs_item_size_nr(path->nodes[0],
|
|
|
|
path->slots[0]);
|
2009-01-06 03:25:51 +01:00
|
|
|
while (ptr < ptr_end) {
|
2008-09-05 22:13:11 +02:00
|
|
|
struct btrfs_inode_ref *ref;
|
|
|
|
|
|
|
|
ref = (struct btrfs_inode_ref *)ptr;
|
|
|
|
name_len = btrfs_inode_ref_name_len(path->nodes[0],
|
|
|
|
ref);
|
|
|
|
ptr = (unsigned long)(ref + 1) + name_len;
|
|
|
|
nlink++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (key.offset == 0)
|
|
|
|
break;
|
2013-10-14 23:49:11 +02:00
|
|
|
if (path->slots[0] > 0) {
|
|
|
|
path->slots[0]--;
|
|
|
|
goto process_slot;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
key.offset--;
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2012-08-08 20:32:27 +02:00
|
|
|
|
|
|
|
return nlink;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There are a few corners where the link count of the file can't
|
|
|
|
* be properly maintained during replay. So, instead of adding
|
|
|
|
* lots of complexity to the log code, we just scan the backrefs
|
|
|
|
* for any file that has been through replay.
|
|
|
|
*
|
|
|
|
* The scan will update the link count on the inode to reflect the
|
|
|
|
* number of back refs found. If it goes down to zero, the iput
|
|
|
|
* will free the inode.
|
|
|
|
*/
|
|
|
|
static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
|
|
|
struct btrfs_path *path;
|
|
|
|
int ret;
|
|
|
|
u64 nlink = 0;
|
|
|
|
u64 ino = btrfs_ino(inode);
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = count_inode_refs(root, inode, path);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nlink = ret;
|
|
|
|
|
|
|
|
ret = count_inode_extrefs(root, inode, path);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nlink += ret;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
if (nlink != inode->i_nlink) {
|
2011-10-28 14:13:29 +02:00
|
|
|
set_nlink(inode, nlink);
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_update_inode(trans, root, inode);
|
|
|
|
}
|
2008-09-11 21:51:21 +02:00
|
|
|
BTRFS_I(inode)->index_cnt = (u64)-1;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-11-12 10:34:40 +01:00
|
|
|
if (inode->i_nlink == 0) {
|
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
|
|
|
ret = replay_dir_deletes(trans, root, NULL, path,
|
2011-04-20 04:31:50 +02:00
|
|
|
ino, 1);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-11-12 10:34:40 +01:00
|
|
|
}
|
2011-04-20 04:31:50 +02:00
|
|
|
ret = insert_orphan_item(trans, root, ino);
|
2009-03-24 15:24:20 +01:00
|
|
|
}
|
|
|
|
|
2012-08-08 20:32:27 +02:00
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct inode *inode;
|
|
|
|
|
|
|
|
key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
|
|
|
|
key.type = BTRFS_ORPHAN_ITEM_KEY;
|
|
|
|
key.offset = (u64)-1;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (ret == 1) {
|
|
|
|
if (path->slots[0] == 0)
|
|
|
|
break;
|
|
|
|
path->slots[0]--;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
|
|
|
|
if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
|
|
|
|
key.type != BTRFS_ORPHAN_ITEM_KEY)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ret = btrfs_del_item(trans, root, path);
|
2011-05-19 06:37:44 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
inode = read_one_inode(root, key.offset);
|
2011-04-28 11:10:23 +02:00
|
|
|
if (!inode)
|
|
|
|
return -EIO;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
ret = fixup_inode_link_count(trans, root, inode);
|
|
|
|
iput(inode);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
/*
|
|
|
|
* fixup on a directory may create new entries,
|
|
|
|
* make sure we always look for the highset possible
|
|
|
|
* offset
|
|
|
|
*/
|
|
|
|
key.offset = (u64)-1;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2011-05-19 06:37:44 +02:00
|
|
|
ret = 0;
|
|
|
|
out:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2011-05-19 06:37:44 +02:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* record a given inode in the fixup dir so we can check its link
|
|
|
|
* count when replay is done. The link count is incremented here
|
|
|
|
* so the inode won't go away until we check it
|
|
|
|
*/
|
|
|
|
static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
u64 objectid)
|
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
|
|
|
int ret = 0;
|
|
|
|
struct inode *inode;
|
|
|
|
|
|
|
|
inode = read_one_inode(root, objectid);
|
2011-04-28 11:10:23 +02:00
|
|
|
if (!inode)
|
|
|
|
return -EIO;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
|
2014-06-04 18:41:45 +02:00
|
|
|
key.type = BTRFS_ORPHAN_ITEM_KEY;
|
2008-09-05 22:13:11 +02:00
|
|
|
key.offset = objectid;
|
|
|
|
|
|
|
|
ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
|
|
|
|
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
if (ret == 0) {
|
2013-03-01 19:35:47 +01:00
|
|
|
if (!inode->i_nlink)
|
|
|
|
set_nlink(inode, 1);
|
|
|
|
else
|
2013-10-16 21:10:34 +02:00
|
|
|
inc_nlink(inode);
|
2012-06-26 05:25:22 +02:00
|
|
|
ret = btrfs_update_inode(trans, root, inode);
|
2008-09-05 22:13:11 +02:00
|
|
|
} else if (ret == -EEXIST) {
|
|
|
|
ret = 0;
|
|
|
|
} else {
|
2013-04-25 22:23:32 +02:00
|
|
|
BUG(); /* Logic Error */
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
iput(inode);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* when replaying the log for a directory, we only insert names
|
|
|
|
* for inodes that actually exist. This means an fsync on a directory
|
|
|
|
* does not implicitly fsync all the new files in it
|
|
|
|
*/
|
|
|
|
static noinline int insert_one_name(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
u64 dirid, u64 index,
|
|
|
|
char *name, int name_len, u8 type,
|
|
|
|
struct btrfs_key *location)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
struct inode *dir;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
inode = read_one_inode(root, location->objectid);
|
|
|
|
if (!inode)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
dir = read_one_inode(root, dirid);
|
|
|
|
if (!dir) {
|
|
|
|
iput(inode);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2013-09-11 20:17:00 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index);
|
|
|
|
|
|
|
|
/* FIXME, put inode into FIXUP list */
|
|
|
|
|
|
|
|
iput(inode);
|
|
|
|
iput(dir);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
Btrfs: fix fsync log replay for inodes with a mix of regular refs and extrefs
If we have an inode with a large number of hard links, some of which may
be extrefs, turn a regular ref into an extref, fsync the inode and then
replay the fsync log (after a crash/reboot), we can endup with an fsync
log that makes the replay code always fail with -EOVERFLOW when processing
the inode's references.
This is easy to reproduce with the test case I made for xfstests. Its steps
are the following:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Now remove one link, add a new one with a new name, add another new one with
# the same name as the one we just removed and fsync the inode.
rm -f $SCRATCH_MNT/foo_link_0001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_0001
rm -f $SCRATCH_MNT/foo_link_0002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3003
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Check that the number of hard links is correct, we are able to remove all
# the hard links and read the file's data. This is just to verify we don't
# get stale file handle errors (due to dangling directory index entries that
# point to inodes that no longer exist).
echo "Link count: $(stat --format=%h $SCRATCH_MNT/foo)"
[ -f $SCRATCH_MNT/foo ] || echo "Link foo is missing"
for ((i = 1; i <= 3003; i++)); do
name=foo_link_`printf "%04d" $i`
if [ $i -eq 2 ]; then
[ -f $SCRATCH_MNT/$name ] && echo "Link $name found"
else
[ -f $SCRATCH_MNT/$name ] || echo "Link $name is missing"
fi
done
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
rm -f $SCRATCH_MNT/foo
status=0
exit
The fix is simply to correct the overflow condition when overwriting a
reference item because it was wrong, trying to increase the item in the
fs/subvol tree by an impossible amount. Also ensure that we don't insert
one normal ref and one ext ref for the same dentry - this happened because
processing a dir index entry from the parent in the log happened when
the normal ref item was full, which made the logic insert an extref and
later when the normal ref had enough room, it would be inserted again
when processing the ref item from the child inode in the log.
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon. This test only passes if the previous
patch titled "Btrfs: fix fsync when extend references are added to an inode"
is applied too.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-14 02:52:25 +01:00
|
|
|
/*
|
|
|
|
* Return true if an inode reference exists in the log for the given name,
|
|
|
|
* inode and parent inode.
|
|
|
|
*/
|
|
|
|
static bool name_in_log_ref(struct btrfs_root *log_root,
|
|
|
|
const char *name, const int name_len,
|
|
|
|
const u64 dirid, const u64 ino)
|
|
|
|
{
|
|
|
|
struct btrfs_key search_key;
|
|
|
|
|
|
|
|
search_key.objectid = ino;
|
|
|
|
search_key.type = BTRFS_INODE_REF_KEY;
|
|
|
|
search_key.offset = dirid;
|
|
|
|
if (backref_in_log(log_root, &search_key, dirid, name, name_len))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
search_key.type = BTRFS_INODE_EXTREF_KEY;
|
|
|
|
search_key.offset = btrfs_extref_hash(dirid, name, name_len);
|
|
|
|
if (backref_in_log(log_root, &search_key, dirid, name, name_len))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/*
|
|
|
|
* take a single entry in a log directory item and replay it into
|
|
|
|
* the subvolume.
|
|
|
|
*
|
|
|
|
* if a conflicting item exists in the subdirectory already,
|
|
|
|
* the inode it points to is unlinked and put into the link count
|
|
|
|
* fix up tree.
|
|
|
|
*
|
|
|
|
* If a name from the log points to a file or directory that does
|
|
|
|
* not exist in the FS, it is skipped. fsyncs on directories
|
|
|
|
* do not force down inodes inside that directory, just changes to the
|
|
|
|
* names or unlinks in a directory.
|
|
|
|
*/
|
|
|
|
static noinline int replay_one_name(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct extent_buffer *eb,
|
|
|
|
struct btrfs_dir_item *di,
|
|
|
|
struct btrfs_key *key)
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
int name_len;
|
|
|
|
struct btrfs_dir_item *dst_di;
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
struct btrfs_key log_key;
|
|
|
|
struct inode *dir;
|
|
|
|
u8 log_type;
|
2008-09-08 17:18:08 +02:00
|
|
|
int exists;
|
2013-04-25 22:23:32 +02:00
|
|
|
int ret = 0;
|
2013-09-11 20:17:00 +02:00
|
|
|
bool update_size = (key->type == BTRFS_DIR_INDEX_KEY);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
dir = read_one_inode(root, key->objectid);
|
2011-04-28 11:10:23 +02:00
|
|
|
if (!dir)
|
|
|
|
return -EIO;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
name_len = btrfs_dir_name_len(eb, di);
|
|
|
|
name = kmalloc(name_len, GFP_NOFS);
|
2013-08-04 20:58:57 +02:00
|
|
|
if (!name) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-01-26 07:22:08 +01:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
log_type = btrfs_dir_type(eb, di);
|
|
|
|
read_extent_buffer(eb, name, (unsigned long)(di + 1),
|
|
|
|
name_len);
|
|
|
|
|
|
|
|
btrfs_dir_item_key_to_cpu(eb, di, &log_key);
|
2008-09-08 17:18:08 +02:00
|
|
|
exists = btrfs_lookup_inode(trans, root, path, &log_key, 0);
|
|
|
|
if (exists == 0)
|
|
|
|
exists = 1;
|
|
|
|
else
|
|
|
|
exists = 0;
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-08 17:18:08 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
if (key->type == BTRFS_DIR_ITEM_KEY) {
|
|
|
|
dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
|
|
|
|
name, name_len, 1);
|
2009-01-06 03:25:51 +01:00
|
|
|
} else if (key->type == BTRFS_DIR_INDEX_KEY) {
|
2008-09-05 22:13:11 +02:00
|
|
|
dst_di = btrfs_lookup_dir_index_item(trans, root, path,
|
|
|
|
key->objectid,
|
|
|
|
key->offset, name,
|
|
|
|
name_len, 1);
|
|
|
|
} else {
|
2013-04-25 22:23:32 +02:00
|
|
|
/* Corruption */
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2011-04-19 18:00:01 +02:00
|
|
|
if (IS_ERR_OR_NULL(dst_di)) {
|
2008-09-05 22:13:11 +02:00
|
|
|
/* we need a sequence number to insert, so we only
|
|
|
|
* do inserts for the BTRFS_DIR_INDEX_KEY types
|
|
|
|
*/
|
|
|
|
if (key->type != BTRFS_DIR_INDEX_KEY)
|
|
|
|
goto out;
|
|
|
|
goto insert;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key);
|
|
|
|
/* the existing item matches the logged item */
|
|
|
|
if (found_key.objectid == log_key.objectid &&
|
|
|
|
found_key.type == log_key.type &&
|
|
|
|
found_key.offset == log_key.offset &&
|
|
|
|
btrfs_dir_type(path->nodes[0], dst_di) == log_type) {
|
2014-09-08 23:53:18 +02:00
|
|
|
update_size = false;
|
2008-09-05 22:13:11 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* don't drop the conflicting directory entry if the inode
|
|
|
|
* for the new entry doesn't exist
|
|
|
|
*/
|
2008-09-08 17:18:08 +02:00
|
|
|
if (!exists)
|
2008-09-05 22:13:11 +02:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = drop_one_dir_item(trans, root, path, dir, dst_di);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
if (key->type == BTRFS_DIR_INDEX_KEY)
|
|
|
|
goto insert;
|
|
|
|
out:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2013-09-11 20:17:00 +02:00
|
|
|
if (!ret && update_size) {
|
|
|
|
btrfs_i_size_write(dir, dir->i_size + name_len * 2);
|
|
|
|
ret = btrfs_update_inode(trans, root, dir);
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
kfree(name);
|
|
|
|
iput(dir);
|
2013-04-25 22:23:32 +02:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
insert:
|
Btrfs: fix fsync log replay for inodes with a mix of regular refs and extrefs
If we have an inode with a large number of hard links, some of which may
be extrefs, turn a regular ref into an extref, fsync the inode and then
replay the fsync log (after a crash/reboot), we can endup with an fsync
log that makes the replay code always fail with -EOVERFLOW when processing
the inode's references.
This is easy to reproduce with the test case I made for xfstests. Its steps
are the following:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Now remove one link, add a new one with a new name, add another new one with
# the same name as the one we just removed and fsync the inode.
rm -f $SCRATCH_MNT/foo_link_0001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_0001
rm -f $SCRATCH_MNT/foo_link_0002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3003
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Check that the number of hard links is correct, we are able to remove all
# the hard links and read the file's data. This is just to verify we don't
# get stale file handle errors (due to dangling directory index entries that
# point to inodes that no longer exist).
echo "Link count: $(stat --format=%h $SCRATCH_MNT/foo)"
[ -f $SCRATCH_MNT/foo ] || echo "Link foo is missing"
for ((i = 1; i <= 3003; i++)); do
name=foo_link_`printf "%04d" $i`
if [ $i -eq 2 ]; then
[ -f $SCRATCH_MNT/$name ] && echo "Link $name found"
else
[ -f $SCRATCH_MNT/$name ] || echo "Link $name is missing"
fi
done
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
rm -f $SCRATCH_MNT/foo
status=0
exit
The fix is simply to correct the overflow condition when overwriting a
reference item because it was wrong, trying to increase the item in the
fs/subvol tree by an impossible amount. Also ensure that we don't insert
one normal ref and one ext ref for the same dentry - this happened because
processing a dir index entry from the parent in the log happened when
the normal ref item was full, which made the logic insert an extref and
later when the normal ref had enough room, it would be inserted again
when processing the ref item from the child inode in the log.
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon. This test only passes if the previous
patch titled "Btrfs: fix fsync when extend references are added to an inode"
is applied too.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-14 02:52:25 +01:00
|
|
|
if (name_in_log_ref(root->log_root, name, name_len,
|
|
|
|
key->objectid, log_key.objectid)) {
|
|
|
|
/* The dentry will be added later. */
|
|
|
|
ret = 0;
|
|
|
|
update_size = false;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = insert_one_name(trans, root, path, key->objectid, key->offset,
|
|
|
|
name, name_len, log_type, &log_key);
|
Btrfs: fix fsync log replay for inodes with a mix of regular refs and extrefs
If we have an inode with a large number of hard links, some of which may
be extrefs, turn a regular ref into an extref, fsync the inode and then
replay the fsync log (after a crash/reboot), we can endup with an fsync
log that makes the replay code always fail with -EOVERFLOW when processing
the inode's references.
This is easy to reproduce with the test case I made for xfstests. Its steps
are the following:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Now remove one link, add a new one with a new name, add another new one with
# the same name as the one we just removed and fsync the inode.
rm -f $SCRATCH_MNT/foo_link_0001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_0001
rm -f $SCRATCH_MNT/foo_link_0002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3002
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3003
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Check that the number of hard links is correct, we are able to remove all
# the hard links and read the file's data. This is just to verify we don't
# get stale file handle errors (due to dangling directory index entries that
# point to inodes that no longer exist).
echo "Link count: $(stat --format=%h $SCRATCH_MNT/foo)"
[ -f $SCRATCH_MNT/foo ] || echo "Link foo is missing"
for ((i = 1; i <= 3003; i++)); do
name=foo_link_`printf "%04d" $i`
if [ $i -eq 2 ]; then
[ -f $SCRATCH_MNT/$name ] && echo "Link $name found"
else
[ -f $SCRATCH_MNT/$name ] || echo "Link $name is missing"
fi
done
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
rm -f $SCRATCH_MNT/foo
status=0
exit
The fix is simply to correct the overflow condition when overwriting a
reference item because it was wrong, trying to increase the item in the
fs/subvol tree by an impossible amount. Also ensure that we don't insert
one normal ref and one ext ref for the same dentry - this happened because
processing a dir index entry from the parent in the log happened when
the normal ref item was full, which made the logic insert an extref and
later when the normal ref had enough room, it would be inserted again
when processing the ref item from the child inode in the log.
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon. This test only passes if the previous
patch titled "Btrfs: fix fsync when extend references are added to an inode"
is applied too.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-14 02:52:25 +01:00
|
|
|
if (ret && ret != -ENOENT && ret != -EEXIST)
|
2013-04-25 22:23:32 +02:00
|
|
|
goto out;
|
2013-09-11 20:17:00 +02:00
|
|
|
update_size = false;
|
2013-04-25 22:23:32 +02:00
|
|
|
ret = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* find all the names in a directory item and reconcile them into
|
|
|
|
* the subvolume. Only BTRFS_DIR_ITEM_KEY types will have more than
|
|
|
|
* one name in a directory item, but the same code gets used for
|
|
|
|
* both directory index types
|
|
|
|
*/
|
|
|
|
static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct extent_buffer *eb, int slot,
|
|
|
|
struct btrfs_key *key)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u32 item_size = btrfs_item_size_nr(eb, slot);
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
int name_len;
|
|
|
|
unsigned long ptr;
|
|
|
|
unsigned long ptr_end;
|
|
|
|
|
|
|
|
ptr = btrfs_item_ptr_offset(eb, slot);
|
|
|
|
ptr_end = ptr + item_size;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (ptr < ptr_end) {
|
2008-09-05 22:13:11 +02:00
|
|
|
di = (struct btrfs_dir_item *)ptr;
|
2011-03-16 21:47:17 +01:00
|
|
|
if (verify_dir_item(root, eb, di))
|
|
|
|
return -EIO;
|
2008-09-05 22:13:11 +02:00
|
|
|
name_len = btrfs_dir_name_len(eb, di);
|
|
|
|
ret = replay_one_name(trans, root, path, eb, di, key);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
ptr = (unsigned long)(di + 1);
|
|
|
|
ptr += name_len;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* directory replay has two parts. There are the standard directory
|
|
|
|
* items in the log copied from the subvolume, and range items
|
|
|
|
* created in the log while the subvolume was logged.
|
|
|
|
*
|
|
|
|
* The range items tell us which parts of the key space the log
|
|
|
|
* is authoritative for. During replay, if a key in the subvolume
|
|
|
|
* directory is in a logged range item, but not actually in the log
|
|
|
|
* that means it was deleted from the directory before the fsync
|
|
|
|
* and should be removed.
|
|
|
|
*/
|
|
|
|
static noinline int find_dir_range(struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
u64 dirid, int key_type,
|
|
|
|
u64 *start_ret, u64 *end_ret)
|
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
|
|
|
u64 found_end;
|
|
|
|
struct btrfs_dir_log_item *item;
|
|
|
|
int ret;
|
|
|
|
int nritems;
|
|
|
|
|
|
|
|
if (*start_ret == (u64)-1)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
key.objectid = dirid;
|
|
|
|
key.type = key_type;
|
|
|
|
key.offset = *start_ret;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
if (ret > 0) {
|
|
|
|
if (path->slots[0] == 0)
|
|
|
|
goto out;
|
|
|
|
path->slots[0]--;
|
|
|
|
}
|
|
|
|
if (ret != 0)
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
|
|
|
|
|
|
|
|
if (key.type != key_type || key.objectid != dirid) {
|
|
|
|
ret = 1;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
item = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_dir_log_item);
|
|
|
|
found_end = btrfs_dir_log_end(path->nodes[0], item);
|
|
|
|
|
|
|
|
if (*start_ret >= key.offset && *start_ret <= found_end) {
|
|
|
|
ret = 0;
|
|
|
|
*start_ret = key.offset;
|
|
|
|
*end_ret = found_end;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = 1;
|
|
|
|
next:
|
|
|
|
/* check the next slot in the tree to see if it is a valid item */
|
|
|
|
nritems = btrfs_header_nritems(path->nodes[0]);
|
|
|
|
if (path->slots[0] >= nritems) {
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
path->slots[0]++;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
|
|
|
|
|
|
|
|
if (key.type != key_type || key.objectid != dirid) {
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
item = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_dir_log_item);
|
|
|
|
found_end = btrfs_dir_log_end(path->nodes[0], item);
|
|
|
|
*start_ret = key.offset;
|
|
|
|
*end_ret = found_end;
|
|
|
|
ret = 0;
|
|
|
|
out:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this looks for a given directory item in the log. If the directory
|
|
|
|
* item is not in the log, the item is removed and the inode it points
|
|
|
|
* to is unlinked
|
|
|
|
*/
|
|
|
|
static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_root *log,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct btrfs_path *log_path,
|
|
|
|
struct inode *dir,
|
|
|
|
struct btrfs_key *dir_key)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
int slot;
|
|
|
|
u32 item_size;
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
struct btrfs_dir_item *log_di;
|
|
|
|
int name_len;
|
|
|
|
unsigned long ptr;
|
|
|
|
unsigned long ptr_end;
|
|
|
|
char *name;
|
|
|
|
struct inode *inode;
|
|
|
|
struct btrfs_key location;
|
|
|
|
|
|
|
|
again:
|
|
|
|
eb = path->nodes[0];
|
|
|
|
slot = path->slots[0];
|
|
|
|
item_size = btrfs_item_size_nr(eb, slot);
|
|
|
|
ptr = btrfs_item_ptr_offset(eb, slot);
|
|
|
|
ptr_end = ptr + item_size;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (ptr < ptr_end) {
|
2008-09-05 22:13:11 +02:00
|
|
|
di = (struct btrfs_dir_item *)ptr;
|
2011-03-16 21:47:17 +01:00
|
|
|
if (verify_dir_item(root, eb, di)) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
name_len = btrfs_dir_name_len(eb, di);
|
|
|
|
name = kmalloc(name_len, GFP_NOFS);
|
|
|
|
if (!name) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
read_extent_buffer(eb, name, (unsigned long)(di + 1),
|
|
|
|
name_len);
|
|
|
|
log_di = NULL;
|
2009-03-24 15:24:20 +01:00
|
|
|
if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) {
|
2008-09-05 22:13:11 +02:00
|
|
|
log_di = btrfs_lookup_dir_item(trans, log, log_path,
|
|
|
|
dir_key->objectid,
|
|
|
|
name, name_len, 0);
|
2009-03-24 15:24:20 +01:00
|
|
|
} else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) {
|
2008-09-05 22:13:11 +02:00
|
|
|
log_di = btrfs_lookup_dir_index_item(trans, log,
|
|
|
|
log_path,
|
|
|
|
dir_key->objectid,
|
|
|
|
dir_key->offset,
|
|
|
|
name, name_len, 0);
|
|
|
|
}
|
2013-10-28 18:39:21 +01:00
|
|
|
if (!log_di || (IS_ERR(log_di) && PTR_ERR(log_di) == -ENOENT)) {
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_dir_item_key_to_cpu(eb, di, &location);
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
|
|
|
btrfs_release_path(log_path);
|
2008-09-05 22:13:11 +02:00
|
|
|
inode = read_one_inode(root, location.objectid);
|
2011-04-28 11:10:23 +02:00
|
|
|
if (!inode) {
|
|
|
|
kfree(name);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
ret = link_to_fixup_dir(trans, root,
|
|
|
|
path, location.objectid);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret) {
|
|
|
|
kfree(name);
|
|
|
|
iput(inode);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-10-16 21:10:34 +02:00
|
|
|
inc_nlink(inode);
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_unlink_inode(trans, root, dir, inode,
|
|
|
|
name, name_len);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (!ret)
|
2013-08-05 10:25:47 +02:00
|
|
|
ret = btrfs_run_delayed_items(trans, root);
|
2008-09-05 22:13:11 +02:00
|
|
|
kfree(name);
|
|
|
|
iput(inode);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* there might still be more names under this key
|
|
|
|
* check and repeat if required
|
|
|
|
*/
|
|
|
|
ret = btrfs_search_slot(NULL, root, dir_key, path,
|
|
|
|
0, 0);
|
|
|
|
if (ret == 0)
|
|
|
|
goto again;
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
2013-10-28 18:39:21 +01:00
|
|
|
} else if (IS_ERR(log_di)) {
|
|
|
|
kfree(name);
|
|
|
|
return PTR_ERR(log_di);
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(log_path);
|
2008-09-05 22:13:11 +02:00
|
|
|
kfree(name);
|
|
|
|
|
|
|
|
ptr = (unsigned long)(di + 1);
|
|
|
|
ptr += name_len;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
|
|
|
btrfs_release_path(log_path);
|
2008-09-05 22:13:11 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* deletion replay happens before we copy any new directory items
|
|
|
|
* out of the log or out of backreferences from inodes. It
|
|
|
|
* scans the log to find ranges of keys that log is authoritative for,
|
|
|
|
* and then scans the directory to find items in those ranges that are
|
|
|
|
* not present in the log.
|
|
|
|
*
|
|
|
|
* Anything we don't find in the log is unlinked and removed from the
|
|
|
|
* directory.
|
|
|
|
*/
|
|
|
|
static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_root *log,
|
|
|
|
struct btrfs_path *path,
|
2009-03-24 15:24:20 +01:00
|
|
|
u64 dirid, int del_all)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
|
|
|
u64 range_start;
|
|
|
|
u64 range_end;
|
|
|
|
int key_type = BTRFS_DIR_LOG_ITEM_KEY;
|
|
|
|
int ret = 0;
|
|
|
|
struct btrfs_key dir_key;
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
struct btrfs_path *log_path;
|
|
|
|
struct inode *dir;
|
|
|
|
|
|
|
|
dir_key.objectid = dirid;
|
|
|
|
dir_key.type = BTRFS_DIR_ITEM_KEY;
|
|
|
|
log_path = btrfs_alloc_path();
|
|
|
|
if (!log_path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
dir = read_one_inode(root, dirid);
|
|
|
|
/* it isn't an error if the inode isn't there, that can happen
|
|
|
|
* because we replay the deletes before we copy in the inode item
|
|
|
|
* from the log
|
|
|
|
*/
|
|
|
|
if (!dir) {
|
|
|
|
btrfs_free_path(log_path);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
again:
|
|
|
|
range_start = 0;
|
|
|
|
range_end = 0;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2009-03-24 15:24:20 +01:00
|
|
|
if (del_all)
|
|
|
|
range_end = (u64)-1;
|
|
|
|
else {
|
|
|
|
ret = find_dir_range(log, path, dirid, key_type,
|
|
|
|
&range_start, &range_end);
|
|
|
|
if (ret != 0)
|
|
|
|
break;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
dir_key.offset = range_start;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
int nritems;
|
|
|
|
ret = btrfs_search_slot(NULL, root, &dir_key, path,
|
|
|
|
0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nritems = btrfs_header_nritems(path->nodes[0]);
|
|
|
|
if (path->slots[0] >= nritems) {
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &found_key,
|
|
|
|
path->slots[0]);
|
|
|
|
if (found_key.objectid != dirid ||
|
|
|
|
found_key.type != dir_key.type)
|
|
|
|
goto next_type;
|
|
|
|
|
|
|
|
if (found_key.offset > range_end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ret = check_item_in_log(trans, root, log, path,
|
2009-03-24 15:24:20 +01:00
|
|
|
log_path, dir,
|
|
|
|
&found_key);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
if (found_key.offset == (u64)-1)
|
|
|
|
break;
|
|
|
|
dir_key.offset = found_key.offset + 1;
|
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
if (range_end == (u64)-1)
|
|
|
|
break;
|
|
|
|
range_start = range_end + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
next_type:
|
|
|
|
ret = 0;
|
|
|
|
if (key_type == BTRFS_DIR_LOG_ITEM_KEY) {
|
|
|
|
key_type = BTRFS_DIR_LOG_INDEX_KEY;
|
|
|
|
dir_key.type = BTRFS_DIR_INDEX_KEY;
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
out:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_free_path(log_path);
|
|
|
|
iput(dir);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the process_func used to replay items from the log tree. This
|
|
|
|
* gets called in two different stages. The first stage just looks
|
|
|
|
* for inodes and makes sure they are all copied into the subvolume.
|
|
|
|
*
|
|
|
|
* The second stage copies all the other item types from the log into
|
|
|
|
* the subvolume. The two stage approach is slower, but gets rid of
|
|
|
|
* lots of complexity around inodes referencing other inodes that exist
|
|
|
|
* only in the log (references come from either directory items or inode
|
|
|
|
* back refs).
|
|
|
|
*/
|
|
|
|
static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
|
|
|
|
struct walk_control *wc, u64 gen)
|
|
|
|
{
|
|
|
|
int nritems;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_root *root = wc->replay_dest;
|
|
|
|
struct btrfs_key key;
|
|
|
|
int level;
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
2012-05-29 11:10:13 +02:00
|
|
|
ret = btrfs_read_buffer(eb, gen);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
level = btrfs_header_level(eb);
|
|
|
|
|
|
|
|
if (level != 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2011-07-12 19:46:06 +02:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
nritems = btrfs_header_nritems(eb);
|
|
|
|
for (i = 0; i < nritems; i++) {
|
|
|
|
btrfs_item_key_to_cpu(eb, &key, i);
|
|
|
|
|
|
|
|
/* inode keys are done during the first stage */
|
|
|
|
if (key.type == BTRFS_INODE_ITEM_KEY &&
|
|
|
|
wc->stage == LOG_WALK_REPLAY_INODES) {
|
|
|
|
struct btrfs_inode_item *inode_item;
|
|
|
|
u32 mode;
|
|
|
|
|
|
|
|
inode_item = btrfs_item_ptr(eb, i,
|
|
|
|
struct btrfs_inode_item);
|
|
|
|
mode = btrfs_inode_mode(eb, inode_item);
|
|
|
|
if (S_ISDIR(mode)) {
|
|
|
|
ret = replay_dir_deletes(wc->trans,
|
2009-03-24 15:24:20 +01:00
|
|
|
root, log, path, key.objectid, 0);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
break;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
ret = overwrite_item(wc->trans, root, path,
|
|
|
|
eb, i, &key);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
break;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-11-12 10:34:40 +01:00
|
|
|
/* for regular files, make sure corresponding
|
|
|
|
* orhpan item exist. extents past the new EOF
|
|
|
|
* will be truncated later by orphan cleanup.
|
2008-09-05 22:13:11 +02:00
|
|
|
*/
|
|
|
|
if (S_ISREG(mode)) {
|
2009-11-12 10:34:40 +01:00
|
|
|
ret = insert_orphan_item(wc->trans, root,
|
|
|
|
key.objectid);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
break;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2009-11-12 10:34:40 +01:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = link_to_fixup_dir(wc->trans, root,
|
|
|
|
path, key.objectid);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
break;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2013-09-11 17:57:23 +02:00
|
|
|
|
|
|
|
if (key.type == BTRFS_DIR_INDEX_KEY &&
|
|
|
|
wc->stage == LOG_WALK_REPLAY_DIR_INDEX) {
|
|
|
|
ret = replay_one_dir_item(wc->trans, root, path,
|
|
|
|
eb, i, &key);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
if (wc->stage < LOG_WALK_REPLAY_ALL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* these keys are simply copied */
|
|
|
|
if (key.type == BTRFS_XATTR_ITEM_KEY) {
|
|
|
|
ret = overwrite_item(wc->trans, root, path,
|
|
|
|
eb, i, &key);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
break;
|
2013-05-26 15:50:29 +02:00
|
|
|
} else if (key.type == BTRFS_INODE_REF_KEY ||
|
|
|
|
key.type == BTRFS_INODE_EXTREF_KEY) {
|
2012-08-08 20:32:27 +02:00
|
|
|
ret = add_inode_ref(wc->trans, root, log, path,
|
|
|
|
eb, i, &key);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret && ret != -ENOENT)
|
|
|
|
break;
|
|
|
|
ret = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
} else if (key.type == BTRFS_EXTENT_DATA_KEY) {
|
|
|
|
ret = replay_one_extent(wc->trans, root, path,
|
|
|
|
eb, i, &key);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
break;
|
2013-09-11 17:57:23 +02:00
|
|
|
} else if (key.type == BTRFS_DIR_ITEM_KEY) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = replay_one_dir_item(wc->trans, root, path,
|
|
|
|
eb, i, &key);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
break;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
btrfs_free_path(path);
|
2013-04-25 21:55:30 +02:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
|
2008-09-05 22:13:11 +02:00
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path, int *level,
|
|
|
|
struct walk_control *wc)
|
|
|
|
{
|
|
|
|
u64 root_owner;
|
|
|
|
u64 bytenr;
|
|
|
|
u64 ptr_gen;
|
|
|
|
struct extent_buffer *next;
|
|
|
|
struct extent_buffer *cur;
|
|
|
|
struct extent_buffer *parent;
|
|
|
|
u32 blocksize;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
WARN_ON(*level < 0);
|
|
|
|
WARN_ON(*level >= BTRFS_MAX_LEVEL);
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (*level > 0) {
|
2008-09-05 22:13:11 +02:00
|
|
|
WARN_ON(*level < 0);
|
|
|
|
WARN_ON(*level >= BTRFS_MAX_LEVEL);
|
|
|
|
cur = path->nodes[*level];
|
|
|
|
|
2013-10-31 06:00:08 +01:00
|
|
|
WARN_ON(btrfs_header_level(cur) != *level);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
if (path->slots[*level] >=
|
|
|
|
btrfs_header_nritems(cur))
|
|
|
|
break;
|
|
|
|
|
|
|
|
bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
|
|
|
|
ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
|
2014-06-04 19:22:26 +02:00
|
|
|
blocksize = root->nodesize;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
parent = path->nodes[*level];
|
|
|
|
root_owner = btrfs_header_owner(parent);
|
|
|
|
|
2014-06-15 02:39:54 +02:00
|
|
|
next = btrfs_find_create_tree_block(root, bytenr);
|
2011-01-26 07:22:08 +01:00
|
|
|
if (!next)
|
|
|
|
return -ENOMEM;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
if (*level == 1) {
|
2011-07-12 19:46:06 +02:00
|
|
|
ret = wc->process_func(root, next, wc, ptr_gen);
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret) {
|
|
|
|
free_extent_buffer(next);
|
2011-07-12 19:46:06 +02:00
|
|
|
return ret;
|
2013-04-25 21:55:30 +02:00
|
|
|
}
|
2010-05-16 16:49:59 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
path->slots[*level]++;
|
|
|
|
if (wc->free) {
|
2012-05-29 11:10:13 +02:00
|
|
|
ret = btrfs_read_buffer(next, ptr_gen);
|
|
|
|
if (ret) {
|
|
|
|
free_extent_buffer(next);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2013-10-07 21:11:00 +02:00
|
|
|
if (trans) {
|
|
|
|
btrfs_tree_lock(next);
|
|
|
|
btrfs_set_lock_blocking(next);
|
|
|
|
clean_tree_block(trans, root, next);
|
|
|
|
btrfs_wait_tree_block_writeback(next);
|
|
|
|
btrfs_tree_unlock(next);
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
WARN_ON(root_owner !=
|
|
|
|
BTRFS_TREE_LOG_OBJECTID);
|
2011-11-01 01:52:39 +01:00
|
|
|
ret = btrfs_free_and_pin_reserved_extent(root,
|
2008-09-11 21:54:42 +02:00
|
|
|
bytenr, blocksize);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret) {
|
|
|
|
free_extent_buffer(next);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
free_extent_buffer(next);
|
|
|
|
continue;
|
|
|
|
}
|
2012-05-29 11:10:13 +02:00
|
|
|
ret = btrfs_read_buffer(next, ptr_gen);
|
|
|
|
if (ret) {
|
|
|
|
free_extent_buffer(next);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
WARN_ON(*level <= 0);
|
|
|
|
if (path->nodes[*level-1])
|
|
|
|
free_extent_buffer(path->nodes[*level-1]);
|
|
|
|
path->nodes[*level-1] = next;
|
|
|
|
*level = btrfs_header_level(next);
|
|
|
|
path->slots[*level] = 0;
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
WARN_ON(*level < 0);
|
|
|
|
WARN_ON(*level >= BTRFS_MAX_LEVEL);
|
|
|
|
|
2010-05-16 16:49:59 +02:00
|
|
|
path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
cond_resched();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
|
2008-09-05 22:13:11 +02:00
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_path *path, int *level,
|
|
|
|
struct walk_control *wc)
|
|
|
|
{
|
|
|
|
u64 root_owner;
|
|
|
|
int i;
|
|
|
|
int slot;
|
|
|
|
int ret;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
|
2008-09-05 22:13:11 +02:00
|
|
|
slot = path->slots[i];
|
2010-05-16 16:49:59 +02:00
|
|
|
if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
|
2008-09-05 22:13:11 +02:00
|
|
|
path->slots[i]++;
|
|
|
|
*level = i;
|
|
|
|
WARN_ON(*level == 0);
|
|
|
|
return 0;
|
|
|
|
} else {
|
2008-09-23 19:14:14 +02:00
|
|
|
struct extent_buffer *parent;
|
|
|
|
if (path->nodes[*level] == root->node)
|
|
|
|
parent = path->nodes[*level];
|
|
|
|
else
|
|
|
|
parent = path->nodes[*level + 1];
|
|
|
|
|
|
|
|
root_owner = btrfs_header_owner(parent);
|
2011-07-12 19:46:06 +02:00
|
|
|
ret = wc->process_func(root, path->nodes[*level], wc,
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_header_generation(path->nodes[*level]));
|
2011-07-12 19:46:06 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
if (wc->free) {
|
|
|
|
struct extent_buffer *next;
|
|
|
|
|
|
|
|
next = path->nodes[*level];
|
|
|
|
|
2013-10-07 21:11:00 +02:00
|
|
|
if (trans) {
|
|
|
|
btrfs_tree_lock(next);
|
|
|
|
btrfs_set_lock_blocking(next);
|
|
|
|
clean_tree_block(trans, root, next);
|
|
|
|
btrfs_wait_tree_block_writeback(next);
|
|
|
|
btrfs_tree_unlock(next);
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID);
|
2011-11-01 01:52:39 +01:00
|
|
|
ret = btrfs_free_and_pin_reserved_extent(root,
|
2008-09-05 22:13:11 +02:00
|
|
|
path->nodes[*level]->start,
|
2008-09-11 21:54:42 +02:00
|
|
|
path->nodes[*level]->len);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
free_extent_buffer(path->nodes[*level]);
|
|
|
|
path->nodes[*level] = NULL;
|
|
|
|
*level = i + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* drop the reference count on the tree rooted at 'snap'. This traverses
|
|
|
|
* the tree freeing any blocks that have a ref count of zero after being
|
|
|
|
* decremented.
|
|
|
|
*/
|
|
|
|
static int walk_log_tree(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *log, struct walk_control *wc)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int wret;
|
|
|
|
int level;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
int orig_level;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2011-03-23 09:14:16 +01:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
level = btrfs_header_level(log->node);
|
|
|
|
orig_level = level;
|
|
|
|
path->nodes[level] = log->node;
|
|
|
|
extent_buffer_get(log->node);
|
|
|
|
path->slots[level] = 0;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
wret = walk_down_log_tree(trans, log, path, &level, wc);
|
|
|
|
if (wret > 0)
|
|
|
|
break;
|
2012-03-12 16:03:00 +01:00
|
|
|
if (wret < 0) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = wret;
|
2012-03-12 16:03:00 +01:00
|
|
|
goto out;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
wret = walk_up_log_tree(trans, log, path, &level, wc);
|
|
|
|
if (wret > 0)
|
|
|
|
break;
|
2012-03-12 16:03:00 +01:00
|
|
|
if (wret < 0) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = wret;
|
2012-03-12 16:03:00 +01:00
|
|
|
goto out;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* was the root node processed? if not, catch it here */
|
|
|
|
if (path->nodes[orig_level]) {
|
2012-03-12 16:03:00 +01:00
|
|
|
ret = wc->process_func(log, path->nodes[orig_level], wc,
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_header_generation(path->nodes[orig_level]));
|
2012-03-12 16:03:00 +01:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
if (wc->free) {
|
|
|
|
struct extent_buffer *next;
|
|
|
|
|
|
|
|
next = path->nodes[orig_level];
|
|
|
|
|
2013-10-07 21:11:00 +02:00
|
|
|
if (trans) {
|
|
|
|
btrfs_tree_lock(next);
|
|
|
|
btrfs_set_lock_blocking(next);
|
|
|
|
clean_tree_block(trans, log, next);
|
|
|
|
btrfs_wait_tree_block_writeback(next);
|
|
|
|
btrfs_tree_unlock(next);
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
WARN_ON(log->root_key.objectid !=
|
|
|
|
BTRFS_TREE_LOG_OBJECTID);
|
2011-11-01 01:52:39 +01:00
|
|
|
ret = btrfs_free_and_pin_reserved_extent(log, next->start,
|
2008-09-11 21:54:42 +02:00
|
|
|
next->len);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-12 16:03:00 +01:00
|
|
|
out:
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
/*
|
|
|
|
* helper function to update the item for a given subvolumes log root
|
|
|
|
* in the tree of log roots
|
|
|
|
*/
|
|
|
|
static int update_log_root(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *log)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (log->log_transid == 1) {
|
|
|
|
/* insert root item on the first sync */
|
|
|
|
ret = btrfs_insert_root(trans, log->fs_info->log_root_tree,
|
|
|
|
&log->root_key, &log->root_item);
|
|
|
|
} else {
|
|
|
|
ret = btrfs_update_root(trans, log->fs_info->log_root_tree,
|
|
|
|
&log->root_key, &log->root_item);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-02-20 11:08:58 +01:00
|
|
|
static void wait_log_commit(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, int transid)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
|
|
|
DEFINE_WAIT(wait);
|
2009-01-21 18:54:03 +01:00
|
|
|
int index = transid % 2;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
/*
|
|
|
|
* we only allow two pending log transactions at a time,
|
|
|
|
* so we know that if ours is more than 2 older than the
|
|
|
|
* current transaction, we're done
|
|
|
|
*/
|
2008-09-05 22:13:11 +02:00
|
|
|
do {
|
2009-01-21 18:54:03 +01:00
|
|
|
prepare_to_wait(&root->log_commit_wait[index],
|
|
|
|
&wait, TASK_UNINTERRUPTIBLE);
|
|
|
|
mutex_unlock(&root->log_mutex);
|
2009-03-24 15:24:20 +01:00
|
|
|
|
2014-02-20 11:08:59 +01:00
|
|
|
if (root->log_transid_committed < transid &&
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_read(&root->log_commit[index]))
|
|
|
|
schedule();
|
2009-03-24 15:24:20 +01:00
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
finish_wait(&root->log_commit_wait[index], &wait);
|
|
|
|
mutex_lock(&root->log_mutex);
|
2014-02-20 11:08:59 +01:00
|
|
|
} while (root->log_transid_committed < transid &&
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_read(&root->log_commit[index]));
|
|
|
|
}
|
|
|
|
|
2012-03-01 14:56:26 +01:00
|
|
|
static void wait_for_writer(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2009-01-21 18:54:03 +01:00
|
|
|
{
|
|
|
|
DEFINE_WAIT(wait);
|
2014-02-20 11:08:58 +01:00
|
|
|
|
|
|
|
while (atomic_read(&root->log_writers)) {
|
2009-01-21 18:54:03 +01:00
|
|
|
prepare_to_wait(&root->log_writer_wait,
|
|
|
|
&wait, TASK_UNINTERRUPTIBLE);
|
|
|
|
mutex_unlock(&root->log_mutex);
|
2014-02-20 11:08:58 +01:00
|
|
|
if (atomic_read(&root->log_writers))
|
2008-09-05 22:13:11 +02:00
|
|
|
schedule();
|
2009-01-21 18:54:03 +01:00
|
|
|
finish_wait(&root->log_writer_wait, &wait);
|
2015-02-11 12:12:39 +01:00
|
|
|
mutex_lock(&root->log_mutex);
|
2009-01-21 18:54:03 +01:00
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
2014-02-20 11:08:58 +01:00
|
|
|
static inline void btrfs_remove_log_ctx(struct btrfs_root *root,
|
|
|
|
struct btrfs_log_ctx *ctx)
|
|
|
|
{
|
|
|
|
if (!ctx)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&root->log_mutex);
|
|
|
|
list_del_init(&ctx->list);
|
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Invoked in log mutex context, or be sure there is no other task which
|
|
|
|
* can access the list.
|
|
|
|
*/
|
|
|
|
static inline void btrfs_remove_all_log_ctxs(struct btrfs_root *root,
|
|
|
|
int index, int error)
|
|
|
|
{
|
|
|
|
struct btrfs_log_ctx *ctx;
|
|
|
|
|
|
|
|
if (!error) {
|
|
|
|
INIT_LIST_HEAD(&root->log_ctxs[index]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(ctx, &root->log_ctxs[index], list)
|
|
|
|
ctx->log_ret = error;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&root->log_ctxs[index]);
|
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/*
|
|
|
|
* btrfs_sync_log does sends a given tree log down to the disk and
|
|
|
|
* updates the super blocks to record it. When this call is done,
|
2009-03-24 15:24:20 +01:00
|
|
|
* you know that any inodes previously logged are safely on disk only
|
|
|
|
* if it returns 0.
|
|
|
|
*
|
|
|
|
* Any other return value means you need to call btrfs_commit_transaction.
|
|
|
|
* Some of the edge cases for fsyncing directories that have had unlinks
|
|
|
|
* or renames done in the past mean that sometimes the only safe
|
|
|
|
* fsync is to commit the whole FS. When btrfs_sync_log returns -EAGAIN,
|
|
|
|
* that has happened.
|
2008-09-05 22:13:11 +02:00
|
|
|
*/
|
|
|
|
int btrfs_sync_log(struct btrfs_trans_handle *trans,
|
2014-02-20 11:08:58 +01:00
|
|
|
struct btrfs_root *root, struct btrfs_log_ctx *ctx)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
2009-01-21 18:54:03 +01:00
|
|
|
int index1;
|
|
|
|
int index2;
|
2009-11-12 10:33:26 +01:00
|
|
|
int mark;
|
2008-09-05 22:13:11 +02:00
|
|
|
int ret;
|
|
|
|
struct btrfs_root *log = root->log_root;
|
2009-01-21 18:54:03 +01:00
|
|
|
struct btrfs_root *log_root_tree = root->fs_info->log_root_tree;
|
2014-02-20 11:08:56 +01:00
|
|
|
int log_transid = 0;
|
2014-02-20 11:08:58 +01:00
|
|
|
struct btrfs_log_ctx root_log_ctx;
|
2013-05-28 12:05:39 +02:00
|
|
|
struct blk_plug plug;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_lock(&root->log_mutex);
|
2014-02-20 11:08:59 +01:00
|
|
|
log_transid = ctx->log_transid;
|
|
|
|
if (root->log_transid_committed >= log_transid) {
|
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
return ctx->log_ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
index1 = log_transid % 2;
|
2009-01-21 18:54:03 +01:00
|
|
|
if (atomic_read(&root->log_commit[index1])) {
|
2014-02-20 11:08:59 +01:00
|
|
|
wait_log_commit(trans, root, log_transid);
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_unlock(&root->log_mutex);
|
2014-02-20 11:08:58 +01:00
|
|
|
return ctx->log_ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2014-02-20 11:08:59 +01:00
|
|
|
ASSERT(log_transid == root->log_transid);
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_set(&root->log_commit[index1], 1);
|
|
|
|
|
|
|
|
/* wait for previous tree log sync to complete */
|
|
|
|
if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
|
2014-02-20 11:08:59 +01:00
|
|
|
wait_log_commit(trans, root, log_transid - 1);
|
2014-02-20 11:08:52 +01:00
|
|
|
|
2009-10-14 15:24:59 +02:00
|
|
|
while (1) {
|
2012-09-06 12:04:27 +02:00
|
|
|
int batch = atomic_read(&root->log_batch);
|
2011-10-20 21:45:37 +02:00
|
|
|
/* when we're on an ssd, just kick the log commit out */
|
2014-04-02 13:51:05 +02:00
|
|
|
if (!btrfs_test_opt(root, SSD) &&
|
|
|
|
test_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state)) {
|
2009-10-14 15:24:59 +02:00
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
schedule_timeout_uninterruptible(1);
|
|
|
|
mutex_lock(&root->log_mutex);
|
|
|
|
}
|
2009-03-24 15:24:20 +01:00
|
|
|
wait_for_writer(trans, root);
|
2012-09-06 12:04:27 +02:00
|
|
|
if (batch == atomic_read(&root->log_batch))
|
2008-09-05 22:13:11 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
/* bail out if we need to do a full commit */
|
2014-04-02 13:51:06 +02:00
|
|
|
if (btrfs_need_log_full_commit(root->fs_info, trans)) {
|
2009-03-24 15:24:20 +01:00
|
|
|
ret = -EAGAIN;
|
2012-10-12 21:27:49 +02:00
|
|
|
btrfs_free_logged_extents(log, log_transid);
|
2009-03-24 15:24:20 +01:00
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-11-12 10:33:26 +01:00
|
|
|
if (log_transid % 2 == 0)
|
|
|
|
mark = EXTENT_DIRTY;
|
|
|
|
else
|
|
|
|
mark = EXTENT_NEW;
|
|
|
|
|
2009-10-13 19:29:19 +02:00
|
|
|
/* we start IO on all the marked extents here, but we don't actually
|
|
|
|
* wait for them until later.
|
|
|
|
*/
|
2013-05-28 12:05:39 +02:00
|
|
|
blk_start_plug(&plug);
|
2009-11-12 10:33:26 +01:00
|
|
|
ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark);
|
2012-03-12 16:03:00 +01:00
|
|
|
if (ret) {
|
2013-05-28 12:05:39 +02:00
|
|
|
blk_finish_plug(&plug);
|
2012-03-12 16:03:00 +01:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2012-10-12 21:27:49 +02:00
|
|
|
btrfs_free_logged_extents(log, log_transid);
|
2014-04-02 13:51:06 +02:00
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
2012-03-12 16:03:00 +01:00
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
goto out;
|
|
|
|
}
|
2009-01-21 18:54:03 +01: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 16:45:14 +02:00
|
|
|
btrfs_set_root_node(&log->root_item, log->node);
|
2009-01-21 18:54:03 +01:00
|
|
|
|
|
|
|
root->log_transid++;
|
|
|
|
log->log_transid = root->log_transid;
|
2009-10-08 21:30:04 +02:00
|
|
|
root->log_start_pid = 0;
|
2009-01-21 18:54:03 +01:00
|
|
|
/*
|
2009-11-12 10:33:26 +01:00
|
|
|
* IO has been started, blocks of the log tree have WRITTEN flag set
|
|
|
|
* in their headers. new modifications of the log will be written to
|
|
|
|
* new positions. so it's safe to allow log writers to go in.
|
2009-01-21 18:54:03 +01:00
|
|
|
*/
|
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
|
2014-02-20 11:08:59 +01:00
|
|
|
btrfs_init_log_ctx(&root_log_ctx);
|
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_lock(&log_root_tree->log_mutex);
|
2012-09-06 12:04:27 +02:00
|
|
|
atomic_inc(&log_root_tree->log_batch);
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_inc(&log_root_tree->log_writers);
|
2014-02-20 11:08:59 +01:00
|
|
|
|
|
|
|
index2 = log_root_tree->log_transid % 2;
|
|
|
|
list_add_tail(&root_log_ctx.list, &log_root_tree->log_ctxs[index2]);
|
|
|
|
root_log_ctx.log_transid = log_root_tree->log_transid;
|
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
|
|
|
|
ret = update_log_root(trans, log);
|
|
|
|
|
|
|
|
mutex_lock(&log_root_tree->log_mutex);
|
|
|
|
if (atomic_dec_and_test(&log_root_tree->log_writers)) {
|
|
|
|
smp_mb();
|
|
|
|
if (waitqueue_active(&log_root_tree->log_writer_wait))
|
|
|
|
wake_up(&log_root_tree->log_writer_wait);
|
|
|
|
}
|
|
|
|
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret) {
|
2014-02-20 11:08:59 +01:00
|
|
|
if (!list_empty(&root_log_ctx.list))
|
|
|
|
list_del_init(&root_log_ctx.list);
|
|
|
|
|
2013-05-28 12:05:39 +02:00
|
|
|
blk_finish_plug(&plug);
|
2014-04-02 13:51:06 +02:00
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
|
|
|
|
2012-03-12 16:03:00 +01:00
|
|
|
if (ret != -ENOSPC) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
goto out;
|
|
|
|
}
|
2010-05-16 16:49:59 +02:00
|
|
|
btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
|
2012-10-12 21:27:49 +02:00
|
|
|
btrfs_free_logged_extents(log, log_transid);
|
2010-05-16 16:49:59 +02:00
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-02-20 11:08:59 +01:00
|
|
|
if (log_root_tree->log_transid_committed >= root_log_ctx.log_transid) {
|
2015-01-30 12:42:12 +01:00
|
|
|
blk_finish_plug(&plug);
|
2014-02-20 11:08:59 +01:00
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
ret = root_log_ctx.log_ret;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-02-20 11:08:58 +01:00
|
|
|
|
2014-02-20 11:08:59 +01:00
|
|
|
index2 = root_log_ctx.log_transid % 2;
|
2009-01-21 18:54:03 +01:00
|
|
|
if (atomic_read(&log_root_tree->log_commit[index2])) {
|
2013-05-28 12:05:39 +02:00
|
|
|
blk_finish_plug(&plug);
|
2014-11-13 17:59:53 +01:00
|
|
|
ret = btrfs_wait_marked_extents(log, &log->dirty_log_pages,
|
|
|
|
mark);
|
2014-11-21 20:52:38 +01:00
|
|
|
btrfs_wait_logged_extents(trans, log, log_transid);
|
2014-02-20 11:08:58 +01:00
|
|
|
wait_log_commit(trans, log_root_tree,
|
2014-02-20 11:08:59 +01:00
|
|
|
root_log_ctx.log_transid);
|
2009-01-21 18:54:03 +01:00
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
2014-11-13 17:59:53 +01:00
|
|
|
if (!ret)
|
|
|
|
ret = root_log_ctx.log_ret;
|
2009-01-21 18:54:03 +01:00
|
|
|
goto out;
|
|
|
|
}
|
2014-02-20 11:08:59 +01:00
|
|
|
ASSERT(root_log_ctx.log_transid == log_root_tree->log_transid);
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_set(&log_root_tree->log_commit[index2], 1);
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
if (atomic_read(&log_root_tree->log_commit[(index2 + 1) % 2])) {
|
|
|
|
wait_log_commit(trans, log_root_tree,
|
2014-02-20 11:08:59 +01:00
|
|
|
root_log_ctx.log_transid - 1);
|
2009-03-24 15:24:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
wait_for_writer(trans, log_root_tree);
|
2009-01-21 18:54:03 +01:00
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
/*
|
|
|
|
* now that we've moved on to the tree of log tree roots,
|
|
|
|
* check the full commit flag again
|
|
|
|
*/
|
2014-04-02 13:51:06 +02:00
|
|
|
if (btrfs_need_log_full_commit(root->fs_info, trans)) {
|
2013-05-28 12:05:39 +02:00
|
|
|
blk_finish_plug(&plug);
|
2009-11-12 10:33:26 +01:00
|
|
|
btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
|
2012-10-12 21:27:49 +02:00
|
|
|
btrfs_free_logged_extents(log, log_transid);
|
2009-03-24 15:24:20 +01:00
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out_wake_log_root;
|
|
|
|
}
|
2009-01-21 18:54:03 +01:00
|
|
|
|
2013-05-28 12:05:39 +02:00
|
|
|
ret = btrfs_write_marked_extents(log_root_tree,
|
|
|
|
&log_root_tree->dirty_log_pages,
|
|
|
|
EXTENT_DIRTY | EXTENT_NEW);
|
|
|
|
blk_finish_plug(&plug);
|
2012-03-12 16:03:00 +01:00
|
|
|
if (ret) {
|
2014-04-02 13:51:06 +02:00
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
2012-03-12 16:03:00 +01:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2012-10-12 21:27:49 +02:00
|
|
|
btrfs_free_logged_extents(log, log_transid);
|
2012-03-12 16:03:00 +01:00
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
goto out_wake_log_root;
|
|
|
|
}
|
2014-11-13 17:59:53 +01:00
|
|
|
ret = btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
|
|
|
|
if (!ret)
|
|
|
|
ret = btrfs_wait_marked_extents(log_root_tree,
|
|
|
|
&log_root_tree->dirty_log_pages,
|
|
|
|
EXTENT_NEW | EXTENT_DIRTY);
|
|
|
|
if (ret) {
|
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
|
|
|
btrfs_free_logged_extents(log, log_transid);
|
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
goto out_wake_log_root;
|
|
|
|
}
|
2014-11-21 20:52:38 +01:00
|
|
|
btrfs_wait_logged_extents(trans, log, log_transid);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2011-04-13 15:41:04 +02:00
|
|
|
btrfs_set_super_log_root(root->fs_info->super_for_commit,
|
2009-01-21 18:54:03 +01:00
|
|
|
log_root_tree->node->start);
|
2011-04-13 15:41:04 +02:00
|
|
|
btrfs_set_super_log_root_level(root->fs_info->super_for_commit,
|
2009-01-21 18:54:03 +01:00
|
|
|
btrfs_header_level(log_root_tree->node));
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
log_root_tree->log_transid++;
|
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nobody else is going to jump in and write the the ctree
|
|
|
|
* super here because the log_commit atomic below is protecting
|
|
|
|
* us. We must be called with a transaction handle pinning
|
|
|
|
* the running transaction open, so a full commit can't hop
|
|
|
|
* in and cause problems either.
|
|
|
|
*/
|
2012-08-01 18:56:49 +02:00
|
|
|
ret = write_ctree_super(trans, root->fs_info->tree_root, 1);
|
|
|
|
if (ret) {
|
2014-04-02 13:51:06 +02:00
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
2012-08-01 18:56:49 +02:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto out_wake_log_root;
|
|
|
|
}
|
2009-01-21 18:54:03 +01:00
|
|
|
|
2009-10-13 19:21:08 +02:00
|
|
|
mutex_lock(&root->log_mutex);
|
|
|
|
if (root->last_log_commit < log_transid)
|
|
|
|
root->last_log_commit = log_transid;
|
|
|
|
mutex_unlock(&root->log_mutex);
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
out_wake_log_root:
|
2014-02-20 11:08:58 +01:00
|
|
|
/*
|
|
|
|
* We needn't get log_mutex here because we are sure all
|
|
|
|
* the other tasks are blocked.
|
|
|
|
*/
|
|
|
|
btrfs_remove_all_log_ctxs(log_root_tree, index2, ret);
|
|
|
|
|
2014-02-20 11:08:59 +01:00
|
|
|
mutex_lock(&log_root_tree->log_mutex);
|
|
|
|
log_root_tree->log_transid_committed++;
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_set(&log_root_tree->log_commit[index2], 0);
|
2014-02-20 11:08:59 +01:00
|
|
|
mutex_unlock(&log_root_tree->log_mutex);
|
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
if (waitqueue_active(&log_root_tree->log_commit_wait[index2]))
|
|
|
|
wake_up(&log_root_tree->log_commit_wait[index2]);
|
2008-09-05 22:13:11 +02:00
|
|
|
out:
|
2014-02-20 11:08:58 +01:00
|
|
|
/* See above. */
|
|
|
|
btrfs_remove_all_log_ctxs(root, index1, ret);
|
|
|
|
|
2014-02-20 11:08:59 +01:00
|
|
|
mutex_lock(&root->log_mutex);
|
|
|
|
root->log_transid_committed++;
|
2009-01-21 18:54:03 +01:00
|
|
|
atomic_set(&root->log_commit[index1], 0);
|
2014-02-20 11:08:59 +01:00
|
|
|
mutex_unlock(&root->log_mutex);
|
2014-02-20 11:08:58 +01:00
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
if (waitqueue_active(&root->log_commit_wait[index1]))
|
|
|
|
wake_up(&root->log_commit_wait[index1]);
|
2011-01-31 22:48:24 +01:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
2010-05-16 16:49:59 +02:00
|
|
|
static void free_log_tree(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *log)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
|
|
|
int ret;
|
2008-09-11 22:17:57 +02:00
|
|
|
u64 start;
|
|
|
|
u64 end;
|
2008-09-05 22:13:11 +02:00
|
|
|
struct walk_control wc = {
|
|
|
|
.free = 1,
|
|
|
|
.process_func = process_one_buffer
|
|
|
|
};
|
|
|
|
|
2013-10-07 21:11:00 +02:00
|
|
|
ret = walk_log_tree(trans, log, &wc);
|
|
|
|
/* I don't think this can happen but just in case */
|
|
|
|
if (ret)
|
|
|
|
btrfs_abort_transaction(trans, log, ret);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-11 22:17:57 +02:00
|
|
|
ret = find_first_extent_bit(&log->dirty_log_pages,
|
2012-09-27 23:07:30 +02:00
|
|
|
0, &start, &end, EXTENT_DIRTY | EXTENT_NEW,
|
|
|
|
NULL);
|
2008-09-11 22:17:57 +02:00
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
|
2009-11-12 10:33:26 +01:00
|
|
|
clear_extent_bits(&log->dirty_log_pages, start, end,
|
|
|
|
EXTENT_DIRTY | EXTENT_NEW, GFP_NOFS);
|
2008-09-11 22:17:57 +02:00
|
|
|
}
|
|
|
|
|
2012-10-12 21:27:49 +02:00
|
|
|
/*
|
|
|
|
* We may have short-circuited the log tree with the full commit logic
|
|
|
|
* and left ordered extents on our list, so clear these out to keep us
|
|
|
|
* from leaking inodes and memory.
|
|
|
|
*/
|
|
|
|
btrfs_free_logged_extents(log, 0);
|
|
|
|
btrfs_free_logged_extents(log, 1);
|
|
|
|
|
2009-01-21 18:54:03 +01:00
|
|
|
free_extent_buffer(log->node);
|
|
|
|
kfree(log);
|
2010-05-16 16:49:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* free all the extents used by the tree log. This should be called
|
|
|
|
* at commit time of the full transaction
|
|
|
|
*/
|
|
|
|
int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
if (root->log_root) {
|
|
|
|
free_log_tree(trans, root->log_root);
|
|
|
|
root->log_root = NULL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info)
|
|
|
|
{
|
|
|
|
if (fs_info->log_root_tree) {
|
|
|
|
free_log_tree(trans, fs_info->log_root_tree);
|
|
|
|
fs_info->log_root_tree = NULL;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If both a file and directory are logged, and unlinks or renames are
|
|
|
|
* mixed in, we have a few interesting corners:
|
|
|
|
*
|
|
|
|
* create file X in dir Y
|
|
|
|
* link file X to X.link in dir Y
|
|
|
|
* fsync file X
|
|
|
|
* unlink file X but leave X.link
|
|
|
|
* fsync dir Y
|
|
|
|
*
|
|
|
|
* After a crash we would expect only X.link to exist. But file X
|
|
|
|
* didn't get fsync'd again so the log has back refs for X and X.link.
|
|
|
|
*
|
|
|
|
* We solve this by removing directory entries and inode backrefs from the
|
|
|
|
* log when a file that was logged in the current transaction is
|
|
|
|
* unlinked. Any later fsync will include the updated log entries, and
|
|
|
|
* we'll be able to reconstruct the proper directory items from backrefs.
|
|
|
|
*
|
|
|
|
* This optimizations allows us to avoid relogging the entire inode
|
|
|
|
* or the entire directory.
|
|
|
|
*/
|
|
|
|
int btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
const char *name, int name_len,
|
|
|
|
struct inode *dir, u64 index)
|
|
|
|
{
|
|
|
|
struct btrfs_root *log;
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
int ret;
|
2010-05-16 16:49:59 +02:00
|
|
|
int err = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
int bytes_del = 0;
|
2011-04-20 04:31:50 +02:00
|
|
|
u64 dir_ino = btrfs_ino(dir);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2008-09-11 21:53:37 +02:00
|
|
|
if (BTRFS_I(dir)->logged_trans < trans->transid)
|
|
|
|
return 0;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = join_running_log_trans(root);
|
|
|
|
if (ret)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
mutex_lock(&BTRFS_I(dir)->log_mutex);
|
|
|
|
|
|
|
|
log = root->log_root;
|
|
|
|
path = btrfs_alloc_path();
|
2011-04-26 01:43:51 +02:00
|
|
|
if (!path) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2011-01-26 07:22:08 +01:00
|
|
|
|
2011-04-20 04:31:50 +02:00
|
|
|
di = btrfs_lookup_dir_item(trans, log, path, dir_ino,
|
2008-09-05 22:13:11 +02:00
|
|
|
name, name_len, -1);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (IS_ERR(di)) {
|
|
|
|
err = PTR_ERR(di);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (di) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_delete_one_dir_name(trans, log, path, di);
|
|
|
|
bytes_del += name_len;
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret) {
|
|
|
|
err = ret;
|
|
|
|
goto fail;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2011-04-20 04:31:50 +02:00
|
|
|
di = btrfs_lookup_dir_index_item(trans, log, path, dir_ino,
|
2008-09-05 22:13:11 +02:00
|
|
|
index, name, name_len, -1);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (IS_ERR(di)) {
|
|
|
|
err = PTR_ERR(di);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (di) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_delete_one_dir_name(trans, log, path, di);
|
|
|
|
bytes_del += name_len;
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret) {
|
|
|
|
err = ret;
|
|
|
|
goto fail;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* update the directory size in the log to reflect the names
|
|
|
|
* we have removed
|
|
|
|
*/
|
|
|
|
if (bytes_del) {
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
2011-04-20 04:31:50 +02:00
|
|
|
key.objectid = dir_ino;
|
2008-09-05 22:13:11 +02:00
|
|
|
key.offset = 0;
|
|
|
|
key.type = BTRFS_INODE_ITEM_KEY;
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
ret = btrfs_search_slot(trans, log, &key, path, 0, 1);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
err = ret;
|
|
|
|
goto fail;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
if (ret == 0) {
|
|
|
|
struct btrfs_inode_item *item;
|
|
|
|
u64 i_size;
|
|
|
|
|
|
|
|
item = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_inode_item);
|
|
|
|
i_size = btrfs_inode_size(path->nodes[0], item);
|
|
|
|
if (i_size > bytes_del)
|
|
|
|
i_size -= bytes_del;
|
|
|
|
else
|
|
|
|
i_size = 0;
|
|
|
|
btrfs_set_inode_size(path->nodes[0], item, i_size);
|
|
|
|
btrfs_mark_buffer_dirty(path->nodes[0]);
|
|
|
|
} else
|
|
|
|
ret = 0;
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2010-05-16 16:49:59 +02:00
|
|
|
fail:
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_free_path(path);
|
2011-04-26 01:43:51 +02:00
|
|
|
out_unlock:
|
2008-09-05 22:13:11 +02:00
|
|
|
mutex_unlock(&BTRFS_I(dir)->log_mutex);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret == -ENOSPC) {
|
2014-04-02 13:51:06 +02:00
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
2010-05-16 16:49:59 +02:00
|
|
|
ret = 0;
|
2012-03-12 16:03:00 +01:00
|
|
|
} else if (ret < 0)
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
btrfs_end_log_trans(root);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2010-10-29 21:14:31 +02:00
|
|
|
return err;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* see comments for btrfs_del_dir_entries_in_log */
|
|
|
|
int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
const char *name, int name_len,
|
|
|
|
struct inode *inode, u64 dirid)
|
|
|
|
{
|
|
|
|
struct btrfs_root *log;
|
|
|
|
u64 index;
|
|
|
|
int ret;
|
|
|
|
|
2008-09-11 21:53:37 +02:00
|
|
|
if (BTRFS_I(inode)->logged_trans < trans->transid)
|
|
|
|
return 0;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = join_running_log_trans(root);
|
|
|
|
if (ret)
|
|
|
|
return 0;
|
|
|
|
log = root->log_root;
|
|
|
|
mutex_lock(&BTRFS_I(inode)->log_mutex);
|
|
|
|
|
2011-04-20 04:31:50 +02:00
|
|
|
ret = btrfs_del_inode_ref(trans, log, name, name_len, btrfs_ino(inode),
|
2008-09-05 22:13:11 +02:00
|
|
|
dirid, &index);
|
|
|
|
mutex_unlock(&BTRFS_I(inode)->log_mutex);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret == -ENOSPC) {
|
2014-04-02 13:51:06 +02:00
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
2010-05-16 16:49:59 +02:00
|
|
|
ret = 0;
|
2012-03-12 16:03:00 +01:00
|
|
|
} else if (ret < 0 && ret != -ENOENT)
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2009-03-24 15:24:20 +01:00
|
|
|
btrfs_end_log_trans(root);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* creates a range item in the log for 'dirid'. first_offset and
|
|
|
|
* last_offset tell us which parts of the key space the log should
|
|
|
|
* be considered authoritative for.
|
|
|
|
*/
|
|
|
|
static noinline int insert_dir_log_key(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *log,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
int key_type, u64 dirid,
|
|
|
|
u64 first_offset, u64 last_offset)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_dir_log_item *item;
|
|
|
|
|
|
|
|
key.objectid = dirid;
|
|
|
|
key.offset = first_offset;
|
|
|
|
if (key_type == BTRFS_DIR_ITEM_KEY)
|
|
|
|
key.type = BTRFS_DIR_LOG_ITEM_KEY;
|
|
|
|
else
|
|
|
|
key.type = BTRFS_DIR_LOG_INDEX_KEY;
|
|
|
|
ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
item = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_dir_log_item);
|
|
|
|
btrfs_set_dir_log_end(path->nodes[0], item, last_offset);
|
|
|
|
btrfs_mark_buffer_dirty(path->nodes[0]);
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* log all the items included in the current transaction for a given
|
|
|
|
* directory. This also creates the range items in the log tree required
|
|
|
|
* to replay anything deleted before the fsync
|
|
|
|
*/
|
|
|
|
static noinline int log_dir_items(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, struct inode *inode,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct btrfs_path *dst_path, int key_type,
|
|
|
|
u64 min_offset, u64 *last_offset_ret)
|
|
|
|
{
|
|
|
|
struct btrfs_key min_key;
|
|
|
|
struct btrfs_root *log = root->log_root;
|
|
|
|
struct extent_buffer *src;
|
2010-05-16 16:49:59 +02:00
|
|
|
int err = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
int nritems;
|
|
|
|
u64 first_offset = min_offset;
|
|
|
|
u64 last_offset = (u64)-1;
|
2011-04-20 04:31:50 +02:00
|
|
|
u64 ino = btrfs_ino(inode);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
log = root->log_root;
|
|
|
|
|
2011-04-20 04:31:50 +02:00
|
|
|
min_key.objectid = ino;
|
2008-09-05 22:13:11 +02:00
|
|
|
min_key.type = key_type;
|
|
|
|
min_key.offset = min_offset;
|
|
|
|
|
2013-10-01 17:13:42 +02:00
|
|
|
ret = btrfs_search_forward(root, &min_key, path, trans->transid);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we didn't find anything from this transaction, see if there
|
|
|
|
* is anything at all
|
|
|
|
*/
|
2011-04-20 04:31:50 +02:00
|
|
|
if (ret != 0 || min_key.objectid != ino || min_key.type != key_type) {
|
|
|
|
min_key.objectid = ino;
|
2008-09-05 22:13:11 +02:00
|
|
|
min_key.type = key_type;
|
|
|
|
min_key.offset = (u64)-1;
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
|
|
|
|
if (ret < 0) {
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
return ret;
|
|
|
|
}
|
2011-04-20 04:31:50 +02:00
|
|
|
ret = btrfs_previous_item(root, path, ino, key_type);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* if ret == 0 there are items for this type,
|
|
|
|
* create a range to tell us the last key of this type.
|
|
|
|
* otherwise, there are no items in this directory after
|
|
|
|
* *min_offset, and we create a range to indicate that.
|
|
|
|
*/
|
|
|
|
if (ret == 0) {
|
|
|
|
struct btrfs_key tmp;
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &tmp,
|
|
|
|
path->slots[0]);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (key_type == tmp.type)
|
2008-09-05 22:13:11 +02:00
|
|
|
first_offset = max(min_offset, tmp.offset) + 1;
|
|
|
|
}
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* go backward to find any previous key */
|
2011-04-20 04:31:50 +02:00
|
|
|
ret = btrfs_previous_item(root, path, ino, key_type);
|
2008-09-05 22:13:11 +02:00
|
|
|
if (ret == 0) {
|
|
|
|
struct btrfs_key tmp;
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
|
|
|
|
if (key_type == tmp.type) {
|
|
|
|
first_offset = tmp.offset;
|
|
|
|
ret = overwrite_item(trans, log, dst_path,
|
|
|
|
path->nodes[0], path->slots[0],
|
|
|
|
&tmp);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret) {
|
|
|
|
err = ret;
|
|
|
|
goto done;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* find the first key from this transaction again */
|
|
|
|
ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
|
2013-10-31 06:00:08 +01:00
|
|
|
if (WARN_ON(ret != 0))
|
2008-09-05 22:13:11 +02:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we have a block from this transaction, log every item in it
|
|
|
|
* from our directory
|
|
|
|
*/
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
struct btrfs_key tmp;
|
|
|
|
src = path->nodes[0];
|
|
|
|
nritems = btrfs_header_nritems(src);
|
|
|
|
for (i = path->slots[0]; i < nritems; i++) {
|
|
|
|
btrfs_item_key_to_cpu(src, &min_key, i);
|
|
|
|
|
2011-04-20 04:31:50 +02:00
|
|
|
if (min_key.objectid != ino || min_key.type != key_type)
|
2008-09-05 22:13:11 +02:00
|
|
|
goto done;
|
|
|
|
ret = overwrite_item(trans, log, dst_path, src, i,
|
|
|
|
&min_key);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret) {
|
|
|
|
err = ret;
|
|
|
|
goto done;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
path->slots[0] = nritems;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* look ahead to the next item and see if it is also
|
|
|
|
* from this directory and from this transaction
|
|
|
|
*/
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret == 1) {
|
|
|
|
last_offset = (u64)-1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
|
2011-04-20 04:31:50 +02:00
|
|
|
if (tmp.objectid != ino || tmp.type != key_type) {
|
2008-09-05 22:13:11 +02:00
|
|
|
last_offset = (u64)-1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (btrfs_header_generation(path->nodes[0]) != trans->transid) {
|
|
|
|
ret = overwrite_item(trans, log, dst_path,
|
|
|
|
path->nodes[0], path->slots[0],
|
|
|
|
&tmp);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret)
|
|
|
|
err = ret;
|
|
|
|
else
|
|
|
|
last_offset = tmp.offset;
|
2008-09-05 22:13:11 +02:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
done:
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
|
|
|
btrfs_release_path(dst_path);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2010-05-16 16:49:59 +02:00
|
|
|
if (err == 0) {
|
|
|
|
*last_offset_ret = last_offset;
|
|
|
|
/*
|
|
|
|
* insert the log range keys to indicate where the log
|
|
|
|
* is valid
|
|
|
|
*/
|
|
|
|
ret = insert_dir_log_key(trans, log, path, key_type,
|
2011-04-20 04:31:50 +02:00
|
|
|
ino, first_offset, last_offset);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret)
|
|
|
|
err = ret;
|
|
|
|
}
|
|
|
|
return err;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* logging directories is very similar to logging inodes, We find all the items
|
|
|
|
* from the current transaction and write them to the log.
|
|
|
|
*
|
|
|
|
* The recovery code scans the directory in the subvolume, and if it finds a
|
|
|
|
* key in the range logged that is not present in the log tree, then it means
|
|
|
|
* that dir entry was unlinked during the transaction.
|
|
|
|
*
|
|
|
|
* In order for that scan to work, we must include one key smaller than
|
|
|
|
* the smallest logged by this transaction and one key larger than the largest
|
|
|
|
* key logged by this transaction.
|
|
|
|
*/
|
|
|
|
static noinline int log_directory_changes(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, struct inode *inode,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct btrfs_path *dst_path)
|
|
|
|
{
|
|
|
|
u64 min_key;
|
|
|
|
u64 max_key;
|
|
|
|
int ret;
|
|
|
|
int key_type = BTRFS_DIR_ITEM_KEY;
|
|
|
|
|
|
|
|
again:
|
|
|
|
min_key = 0;
|
|
|
|
max_key = 0;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = log_dir_items(trans, root, inode, path,
|
|
|
|
dst_path, key_type, min_key,
|
|
|
|
&max_key);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
if (max_key == (u64)-1)
|
|
|
|
break;
|
|
|
|
min_key = max_key + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (key_type == BTRFS_DIR_ITEM_KEY) {
|
|
|
|
key_type = BTRFS_DIR_INDEX_KEY;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a helper function to drop items from the log before we relog an
|
|
|
|
* inode. max_key_type indicates the highest item type to remove.
|
|
|
|
* This cannot be run for file data extents because it does not
|
|
|
|
* free the extents they point to.
|
|
|
|
*/
|
|
|
|
static int drop_objectid_items(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *log,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
u64 objectid, int max_key_type)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key found_key;
|
2012-09-28 17:56:28 +02:00
|
|
|
int start_slot;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
key.objectid = objectid;
|
|
|
|
key.type = max_key_type;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
|
2013-04-25 22:23:32 +02:00
|
|
|
BUG_ON(ret == 0); /* Logic error */
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret < 0)
|
2008-09-05 22:13:11 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
if (path->slots[0] == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
path->slots[0]--;
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &found_key,
|
|
|
|
path->slots[0]);
|
|
|
|
|
|
|
|
if (found_key.objectid != objectid)
|
|
|
|
break;
|
|
|
|
|
2012-09-28 17:56:28 +02:00
|
|
|
found_key.offset = 0;
|
|
|
|
found_key.type = 0;
|
|
|
|
ret = btrfs_bin_search(path->nodes[0], &found_key, 0,
|
|
|
|
&start_slot);
|
|
|
|
|
|
|
|
ret = btrfs_del_items(trans, log, path, start_slot,
|
|
|
|
path->slots[0] - start_slot + 1);
|
|
|
|
/*
|
|
|
|
* If start slot isn't 0 then we don't need to re-search, we've
|
|
|
|
* found the last guy with the objectid in this tree.
|
|
|
|
*/
|
|
|
|
if (ret || start_slot != 0)
|
2011-05-19 06:37:44 +02:00
|
|
|
break;
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2012-05-29 22:59:49 +02:00
|
|
|
if (ret > 0)
|
|
|
|
ret = 0;
|
2010-05-16 16:49:59 +02:00
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
2012-09-25 20:56:25 +02:00
|
|
|
static void fill_inode_item(struct btrfs_trans_handle *trans,
|
|
|
|
struct extent_buffer *leaf,
|
|
|
|
struct btrfs_inode_item *item,
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
struct inode *inode, int log_inode_only,
|
|
|
|
u64 logged_isize)
|
2012-09-25 20:56:25 +02:00
|
|
|
{
|
2012-10-23 22:03:44 +02:00
|
|
|
struct btrfs_map_token token;
|
|
|
|
|
|
|
|
btrfs_init_map_token(&token);
|
2012-09-25 20:56:25 +02:00
|
|
|
|
|
|
|
if (log_inode_only) {
|
|
|
|
/* set the generation to zero so the recover code
|
|
|
|
* can tell the difference between an logging
|
|
|
|
* just to say 'this inode exists' and a logging
|
|
|
|
* to say 'update this inode with these values'
|
|
|
|
*/
|
2012-10-23 22:03:44 +02:00
|
|
|
btrfs_set_token_inode_generation(leaf, item, 0, &token);
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
btrfs_set_token_inode_size(leaf, item, logged_isize, &token);
|
2012-09-25 20:56:25 +02:00
|
|
|
} else {
|
2012-10-23 22:03:44 +02:00
|
|
|
btrfs_set_token_inode_generation(leaf, item,
|
|
|
|
BTRFS_I(inode)->generation,
|
|
|
|
&token);
|
|
|
|
btrfs_set_token_inode_size(leaf, item, inode->i_size, &token);
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);
|
|
|
|
btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);
|
|
|
|
btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);
|
|
|
|
btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);
|
|
|
|
|
2014-12-12 17:39:12 +01:00
|
|
|
btrfs_set_token_timespec_sec(leaf, &item->atime,
|
2012-10-23 22:03:44 +02:00
|
|
|
inode->i_atime.tv_sec, &token);
|
2014-12-12 17:39:12 +01:00
|
|
|
btrfs_set_token_timespec_nsec(leaf, &item->atime,
|
2012-10-23 22:03:44 +02:00
|
|
|
inode->i_atime.tv_nsec, &token);
|
|
|
|
|
2014-12-12 17:39:12 +01:00
|
|
|
btrfs_set_token_timespec_sec(leaf, &item->mtime,
|
2012-10-23 22:03:44 +02:00
|
|
|
inode->i_mtime.tv_sec, &token);
|
2014-12-12 17:39:12 +01:00
|
|
|
btrfs_set_token_timespec_nsec(leaf, &item->mtime,
|
2012-10-23 22:03:44 +02:00
|
|
|
inode->i_mtime.tv_nsec, &token);
|
|
|
|
|
2014-12-12 17:39:12 +01:00
|
|
|
btrfs_set_token_timespec_sec(leaf, &item->ctime,
|
2012-10-23 22:03:44 +02:00
|
|
|
inode->i_ctime.tv_sec, &token);
|
2014-12-12 17:39:12 +01:00
|
|
|
btrfs_set_token_timespec_nsec(leaf, &item->ctime,
|
2012-10-23 22:03:44 +02:00
|
|
|
inode->i_ctime.tv_nsec, &token);
|
|
|
|
|
|
|
|
btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),
|
|
|
|
&token);
|
|
|
|
|
|
|
|
btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token);
|
|
|
|
btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);
|
|
|
|
btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
|
|
|
|
btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
|
|
|
|
btrfs_set_token_inode_block_group(leaf, item, 0, &token);
|
2012-09-25 20:56:25 +02:00
|
|
|
}
|
|
|
|
|
2012-10-11 22:17:34 +02:00
|
|
|
static int log_inode_item(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *log, struct btrfs_path *path,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
|
|
|
struct btrfs_inode_item *inode_item;
|
|
|
|
int ret;
|
|
|
|
|
2013-10-07 22:20:44 +02:00
|
|
|
ret = btrfs_insert_empty_item(trans, log, path,
|
|
|
|
&BTRFS_I(inode)->location,
|
2012-10-11 22:17:34 +02:00
|
|
|
sizeof(*inode_item));
|
|
|
|
if (ret && ret != -EEXIST)
|
|
|
|
return ret;
|
|
|
|
inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_inode_item);
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
fill_inode_item(trans, path->nodes[0], inode_item, inode, 0, 0);
|
2012-10-11 22:17:34 +02:00
|
|
|
btrfs_release_path(path);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-11 22:17:57 +02:00
|
|
|
static noinline int copy_items(struct btrfs_trans_handle *trans,
|
2012-08-29 09:07:56 +02:00
|
|
|
struct inode *inode,
|
2008-09-11 22:17:57 +02:00
|
|
|
struct btrfs_path *dst_path,
|
2013-10-22 18:18:51 +02:00
|
|
|
struct btrfs_path *src_path, u64 *last_extent,
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
int start_slot, int nr, int inode_only,
|
|
|
|
u64 logged_isize)
|
2008-09-11 22:17:57 +02:00
|
|
|
{
|
|
|
|
unsigned long src_offset;
|
|
|
|
unsigned long dst_offset;
|
2012-08-29 09:07:56 +02:00
|
|
|
struct btrfs_root *log = BTRFS_I(inode)->root->log_root;
|
2008-09-11 22:17:57 +02:00
|
|
|
struct btrfs_file_extent_item *extent;
|
|
|
|
struct btrfs_inode_item *inode_item;
|
2013-10-22 18:18:51 +02:00
|
|
|
struct extent_buffer *src = src_path->nodes[0];
|
|
|
|
struct btrfs_key first_key, last_key, key;
|
2008-09-11 22:17:57 +02:00
|
|
|
int ret;
|
|
|
|
struct btrfs_key *ins_keys;
|
|
|
|
u32 *ins_sizes;
|
|
|
|
char *ins_data;
|
|
|
|
int i;
|
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-08 22:58:54 +01:00
|
|
|
struct list_head ordered_sums;
|
2012-08-29 09:07:56 +02:00
|
|
|
int skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
|
2013-10-22 18:18:51 +02:00
|
|
|
bool has_extents = false;
|
Btrfs: fix hole detection during file fsync
The file hole detection logic during a file fsync wasn't correct,
because it didn't look back (in a previous leaf) for the last file
extent item that can be in a leaf to the left of our leaf and that
has a generation lower than the current transaction id. This made it
assume that a hole exists when it really doesn't exist in the file.
Such false positive hole detection happens in the following scenario:
* We have a file that has many file extent items, covering 3 or more
btree leafs (the first leaf must contain non file extent items too).
* Two ranges of the file are modified, with their extent items being
located at 2 different leafs and those leafs aren't consecutive.
* When processing the second modified leaf, we weren't checking if
some file extent item exists that is located in some leaf that is
between our 2 modified leafs, and therefore assumed the range defined
between the last file extent item in the first leaf and the first file
extent item in the second leaf matched a hole.
Fortunately this didn't result in overriding the log with wrong data,
instead it made the last loop in copy_items() attempt to insert a
duplicated key (for a hole file extent item), which makes the file
fsync code return with -EEXIST to file.c:btrfs_sync_file() which in
turn ends up doing a full transaction commit, which is much more
expensive then writing only to the log tree and wait for it to be
durably persisted (as well as the file's modified extents/pages).
Therefore fix the hole detection logic, so that we don't pay the
cost of doing full transaction commits.
I could trigger this issue with the following test for xfstests (which
never fails, either without or with this patch). The last fsync call
results in a full transaction commit, due to the -EEXIST error mentioned
above. I could also observe this behaviour happening frequently when
running xfstests/generic/075 in a loop.
Test:
_cleanup()
{
_cleanup_flakey
rm -fr $tmp
}
# get standard environment, filters and checks
. ./common/rc
. ./common/filter
. ./common/dmflakey
# real QA test starts here
_supported_fs btrfs
_supported_os Linux
_require_scratch
_require_dm_flakey
_need_to_be_root
rm -f $seqres.full
# Create a file with many file extent items, each representing a 4Kb extent.
# These items span 3 btree leaves, of 16Kb each (default mkfs.btrfs leaf size
# as of btrfs-progs 3.12).
_scratch_mkfs -l 16384 >/dev/null 2>&1
_init_flakey
SAVE_MOUNT_OPTIONS="$MOUNT_OPTIONS"
MOUNT_OPTIONS="$MOUNT_OPTIONS -o commit=999"
_mount_flakey
# First fsync, inode has BTRFS_INODE_NEEDS_FULL_SYNC flag set.
$XFS_IO_PROG -f -c "pwrite -S 0x01 -b 4096 0 4096" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# For any of the following fsync calls, inode doesn't have the flag
# BTRFS_INODE_NEEDS_FULL_SYNC set.
for ((i = 1; i <= 500; i++)); do
OFFSET=$((4096 * i))
LEN=4096
$XFS_IO_PROG -c "pwrite -S 0x01 $OFFSET $LEN" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
done
# Commit transaction and bump next transaction's id (to 7).
sync
# Truncate will set the BTRFS_INODE_NEEDS_FULL_SYNC flag in the btrfs's
# inode runtime flags.
$XFS_IO_PROG -c "truncate 2048000" $SCRATCH_MNT/foo
# Commit transaction and bump next transaction's id (to 8).
sync
# Touch 1 extent item from the first leaf and 1 from the last leaf. The leaf
# in the middle, containing only file extent items, isn't touched. So the
# next fsync, when calling btrfs_search_forward(), won't visit that middle
# leaf. First and 3rd leaf have now a generation with value 8, while the
# middle leaf remains with a generation with value 6.
$XFS_IO_PROG \
-c "pwrite -S 0xee -b 4096 0 4096" \
-c "pwrite -S 0xff -b 4096 2043904 4096" \
-c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
_load_flakey_table $FLAKEY_DROP_WRITES
md5sum $SCRATCH_MNT/foo | _filter_scratch
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
# During mount, we'll replay the log created by the fsync above, and the file's
# md5 digest should be the same we got before the unmount.
_mount_flakey
md5sum $SCRATCH_MNT/foo | _filter_scratch
_unmount_flakey
MOUNT_OPTIONS="$SAVE_MOUNT_OPTIONS"
status=0
exit
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-08-07 13:00:44 +02:00
|
|
|
bool need_find_last_extent = true;
|
2013-10-22 18:18:51 +02:00
|
|
|
bool done = false;
|
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-08 22:58:54 +01:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&ordered_sums);
|
2008-09-11 22:17:57 +02:00
|
|
|
|
|
|
|
ins_data = kmalloc(nr * sizeof(struct btrfs_key) +
|
|
|
|
nr * sizeof(u32), GFP_NOFS);
|
2011-01-26 07:22:08 +01:00
|
|
|
if (!ins_data)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-10-22 18:18:51 +02:00
|
|
|
first_key.objectid = (u64)-1;
|
|
|
|
|
2008-09-11 22:17:57 +02:00
|
|
|
ins_sizes = (u32 *)ins_data;
|
|
|
|
ins_keys = (struct btrfs_key *)(ins_data + nr * sizeof(u32));
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++) {
|
|
|
|
ins_sizes[i] = btrfs_item_size_nr(src, i + start_slot);
|
|
|
|
btrfs_item_key_to_cpu(src, ins_keys + i, i + start_slot);
|
|
|
|
}
|
|
|
|
ret = btrfs_insert_empty_items(trans, log, dst_path,
|
|
|
|
ins_keys, ins_sizes, nr);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret) {
|
|
|
|
kfree(ins_data);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-09-11 22:17:57 +02: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 16:45:14 +02:00
|
|
|
for (i = 0; i < nr; i++, dst_path->slots[0]++) {
|
2008-09-11 22:17:57 +02:00
|
|
|
dst_offset = btrfs_item_ptr_offset(dst_path->nodes[0],
|
|
|
|
dst_path->slots[0]);
|
|
|
|
|
|
|
|
src_offset = btrfs_item_ptr_offset(src, start_slot + i);
|
|
|
|
|
2013-10-22 18:18:51 +02:00
|
|
|
if ((i == (nr - 1)))
|
|
|
|
last_key = ins_keys[i];
|
|
|
|
|
2012-09-25 20:56:25 +02:00
|
|
|
if (ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
|
2008-09-11 22:17:57 +02:00
|
|
|
inode_item = btrfs_item_ptr(dst_path->nodes[0],
|
|
|
|
dst_path->slots[0],
|
|
|
|
struct btrfs_inode_item);
|
2012-09-25 20:56:25 +02:00
|
|
|
fill_inode_item(trans, dst_path->nodes[0], inode_item,
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
inode, inode_only == LOG_INODE_EXISTS,
|
|
|
|
logged_isize);
|
2012-09-25 20:56:25 +02:00
|
|
|
} else {
|
|
|
|
copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
|
|
|
|
src_offset, ins_sizes[i]);
|
2008-09-11 22:17:57 +02:00
|
|
|
}
|
2012-09-25 20:56:25 +02:00
|
|
|
|
2013-10-22 18:18:51 +02:00
|
|
|
/*
|
|
|
|
* We set need_find_last_extent here in case we know we were
|
|
|
|
* processing other items and then walk into the first extent in
|
|
|
|
* the inode. If we don't hit an extent then nothing changes,
|
|
|
|
* we'll do the last search the next time around.
|
|
|
|
*/
|
|
|
|
if (ins_keys[i].type == BTRFS_EXTENT_DATA_KEY) {
|
|
|
|
has_extents = true;
|
Btrfs: fix hole detection during file fsync
The file hole detection logic during a file fsync wasn't correct,
because it didn't look back (in a previous leaf) for the last file
extent item that can be in a leaf to the left of our leaf and that
has a generation lower than the current transaction id. This made it
assume that a hole exists when it really doesn't exist in the file.
Such false positive hole detection happens in the following scenario:
* We have a file that has many file extent items, covering 3 or more
btree leafs (the first leaf must contain non file extent items too).
* Two ranges of the file are modified, with their extent items being
located at 2 different leafs and those leafs aren't consecutive.
* When processing the second modified leaf, we weren't checking if
some file extent item exists that is located in some leaf that is
between our 2 modified leafs, and therefore assumed the range defined
between the last file extent item in the first leaf and the first file
extent item in the second leaf matched a hole.
Fortunately this didn't result in overriding the log with wrong data,
instead it made the last loop in copy_items() attempt to insert a
duplicated key (for a hole file extent item), which makes the file
fsync code return with -EEXIST to file.c:btrfs_sync_file() which in
turn ends up doing a full transaction commit, which is much more
expensive then writing only to the log tree and wait for it to be
durably persisted (as well as the file's modified extents/pages).
Therefore fix the hole detection logic, so that we don't pay the
cost of doing full transaction commits.
I could trigger this issue with the following test for xfstests (which
never fails, either without or with this patch). The last fsync call
results in a full transaction commit, due to the -EEXIST error mentioned
above. I could also observe this behaviour happening frequently when
running xfstests/generic/075 in a loop.
Test:
_cleanup()
{
_cleanup_flakey
rm -fr $tmp
}
# get standard environment, filters and checks
. ./common/rc
. ./common/filter
. ./common/dmflakey
# real QA test starts here
_supported_fs btrfs
_supported_os Linux
_require_scratch
_require_dm_flakey
_need_to_be_root
rm -f $seqres.full
# Create a file with many file extent items, each representing a 4Kb extent.
# These items span 3 btree leaves, of 16Kb each (default mkfs.btrfs leaf size
# as of btrfs-progs 3.12).
_scratch_mkfs -l 16384 >/dev/null 2>&1
_init_flakey
SAVE_MOUNT_OPTIONS="$MOUNT_OPTIONS"
MOUNT_OPTIONS="$MOUNT_OPTIONS -o commit=999"
_mount_flakey
# First fsync, inode has BTRFS_INODE_NEEDS_FULL_SYNC flag set.
$XFS_IO_PROG -f -c "pwrite -S 0x01 -b 4096 0 4096" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# For any of the following fsync calls, inode doesn't have the flag
# BTRFS_INODE_NEEDS_FULL_SYNC set.
for ((i = 1; i <= 500; i++)); do
OFFSET=$((4096 * i))
LEN=4096
$XFS_IO_PROG -c "pwrite -S 0x01 $OFFSET $LEN" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
done
# Commit transaction and bump next transaction's id (to 7).
sync
# Truncate will set the BTRFS_INODE_NEEDS_FULL_SYNC flag in the btrfs's
# inode runtime flags.
$XFS_IO_PROG -c "truncate 2048000" $SCRATCH_MNT/foo
# Commit transaction and bump next transaction's id (to 8).
sync
# Touch 1 extent item from the first leaf and 1 from the last leaf. The leaf
# in the middle, containing only file extent items, isn't touched. So the
# next fsync, when calling btrfs_search_forward(), won't visit that middle
# leaf. First and 3rd leaf have now a generation with value 8, while the
# middle leaf remains with a generation with value 6.
$XFS_IO_PROG \
-c "pwrite -S 0xee -b 4096 0 4096" \
-c "pwrite -S 0xff -b 4096 2043904 4096" \
-c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
_load_flakey_table $FLAKEY_DROP_WRITES
md5sum $SCRATCH_MNT/foo | _filter_scratch
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
# During mount, we'll replay the log created by the fsync above, and the file's
# md5 digest should be the same we got before the unmount.
_mount_flakey
md5sum $SCRATCH_MNT/foo | _filter_scratch
_unmount_flakey
MOUNT_OPTIONS="$SAVE_MOUNT_OPTIONS"
status=0
exit
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-08-07 13:00:44 +02:00
|
|
|
if (first_key.objectid == (u64)-1)
|
2013-10-22 18:18:51 +02:00
|
|
|
first_key = ins_keys[i];
|
|
|
|
} else {
|
|
|
|
need_find_last_extent = false;
|
|
|
|
}
|
|
|
|
|
2008-09-11 22:17:57 +02:00
|
|
|
/* take a reference on file data extents so that truncates
|
|
|
|
* or deletes of this inode don't have to relog the inode
|
|
|
|
* again
|
|
|
|
*/
|
2014-06-04 18:41:45 +02:00
|
|
|
if (ins_keys[i].type == BTRFS_EXTENT_DATA_KEY &&
|
2012-08-29 09:07:56 +02:00
|
|
|
!skip_csum) {
|
2008-09-11 22:17:57 +02:00
|
|
|
int found_type;
|
|
|
|
extent = btrfs_item_ptr(src, start_slot + i,
|
|
|
|
struct btrfs_file_extent_item);
|
|
|
|
|
Btrfs: do not flush csum items of unchanged file data during treelog
The current code relogs the entire inode every time during fsync log,
and it is much better suited to small files rather than large ones.
During my performance test, the fsync performace of large files sucks,
and we can ascribe this to the tremendous amount of csum infos of the
large ones, cause we have to flush all of these csum infos into log trees
even when there are only _one_ change in the whole file data. Apparently,
to optimize fsync, we need to create a filter to skip the unnecessary csum
ones, that is, the corresponding file data remains unchanged before this fsync.
Here I have some test results to show, I use sysbench to do "random write + fsync".
===
sysbench --test=fileio --num-threads=1 --file-num=2 --file-block-size=4K --file-total-size=8G --file-test-mode=rndwr --file-io-mode=sync --file-extra-flags= [prepare, run]
===
Sysbench args:
- Number of threads: 1
- Extra file open flags: 0
- 2 files, 4Gb each
- Block size 4Kb
- Number of random requests for random IO: 10000
- Read/Write ratio for combined random IO test: 1.50
- Periodic FSYNC enabled, calling fsync() each 100 requests.
- Calling fsync() at the end of test, Enabled.
- Using synchronous I/O mode
- Doing random write test
Sysbench results:
===
Operations performed: 0 Read, 10000 Write, 200 Other = 10200 Total
Read 0b Written 39.062Mb Total transferred 39.062Mb
===
a) without patch: (*SPEED* : 451.01Kb/sec)
112.75 Requests/sec executed
b) with patch: (*SPEED* : 4.7533Mb/sec)
1216.84 Requests/sec executed
PS: I've made a _sub transid_ stuff patch, but it does not perform as effectively as this patch,
and I'm wanderring where the problem is and trying to improve it more.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-05-06 04:36:09 +02:00
|
|
|
if (btrfs_file_extent_generation(src, extent) < trans->transid)
|
|
|
|
continue;
|
|
|
|
|
2008-09-11 22:17:57 +02:00
|
|
|
found_type = btrfs_file_extent_type(src, extent);
|
2012-09-26 17:07:06 +02:00
|
|
|
if (found_type == BTRFS_FILE_EXTENT_REG) {
|
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 16:45:14 +02:00
|
|
|
u64 ds, dl, cs, cl;
|
|
|
|
ds = btrfs_file_extent_disk_bytenr(src,
|
|
|
|
extent);
|
|
|
|
/* ds == 0 is a hole */
|
|
|
|
if (ds == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
dl = btrfs_file_extent_disk_num_bytes(src,
|
|
|
|
extent);
|
|
|
|
cs = btrfs_file_extent_offset(src, extent);
|
|
|
|
cl = btrfs_file_extent_num_bytes(src,
|
2009-08-18 20:18:35 +02:00
|
|
|
extent);
|
2008-12-09 01:15:39 +01:00
|
|
|
if (btrfs_file_extent_compression(src,
|
|
|
|
extent)) {
|
|
|
|
cs = 0;
|
|
|
|
cl = dl;
|
|
|
|
}
|
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 16:45:14 +02:00
|
|
|
|
|
|
|
ret = btrfs_lookup_csums_range(
|
|
|
|
log->fs_info->csum_root,
|
|
|
|
ds + cs, ds + cs + cl - 1,
|
2011-03-08 14:14:00 +01:00
|
|
|
&ordered_sums, 0);
|
2013-04-25 22:23:32 +02:00
|
|
|
if (ret) {
|
|
|
|
btrfs_release_path(dst_path);
|
|
|
|
kfree(ins_data);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-09-11 22:17:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_mark_buffer_dirty(dst_path->nodes[0]);
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(dst_path);
|
2008-09-11 22:17:57 +02:00
|
|
|
kfree(ins_data);
|
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-08 22:58:54 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we have to do this after the loop above to avoid changing the
|
|
|
|
* log tree while trying to change the log tree.
|
|
|
|
*/
|
2010-05-16 16:49:59 +02:00
|
|
|
ret = 0;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (!list_empty(&ordered_sums)) {
|
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-08 22:58:54 +01:00
|
|
|
struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
|
|
|
|
struct btrfs_ordered_sum,
|
|
|
|
list);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (!ret)
|
|
|
|
ret = btrfs_csum_file_blocks(trans, log, sums);
|
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-08 22:58:54 +01:00
|
|
|
list_del(&sums->list);
|
|
|
|
kfree(sums);
|
|
|
|
}
|
2013-10-22 18:18:51 +02:00
|
|
|
|
|
|
|
if (!has_extents)
|
|
|
|
return ret;
|
|
|
|
|
Btrfs: fix hole detection during file fsync
The file hole detection logic during a file fsync wasn't correct,
because it didn't look back (in a previous leaf) for the last file
extent item that can be in a leaf to the left of our leaf and that
has a generation lower than the current transaction id. This made it
assume that a hole exists when it really doesn't exist in the file.
Such false positive hole detection happens in the following scenario:
* We have a file that has many file extent items, covering 3 or more
btree leafs (the first leaf must contain non file extent items too).
* Two ranges of the file are modified, with their extent items being
located at 2 different leafs and those leafs aren't consecutive.
* When processing the second modified leaf, we weren't checking if
some file extent item exists that is located in some leaf that is
between our 2 modified leafs, and therefore assumed the range defined
between the last file extent item in the first leaf and the first file
extent item in the second leaf matched a hole.
Fortunately this didn't result in overriding the log with wrong data,
instead it made the last loop in copy_items() attempt to insert a
duplicated key (for a hole file extent item), which makes the file
fsync code return with -EEXIST to file.c:btrfs_sync_file() which in
turn ends up doing a full transaction commit, which is much more
expensive then writing only to the log tree and wait for it to be
durably persisted (as well as the file's modified extents/pages).
Therefore fix the hole detection logic, so that we don't pay the
cost of doing full transaction commits.
I could trigger this issue with the following test for xfstests (which
never fails, either without or with this patch). The last fsync call
results in a full transaction commit, due to the -EEXIST error mentioned
above. I could also observe this behaviour happening frequently when
running xfstests/generic/075 in a loop.
Test:
_cleanup()
{
_cleanup_flakey
rm -fr $tmp
}
# get standard environment, filters and checks
. ./common/rc
. ./common/filter
. ./common/dmflakey
# real QA test starts here
_supported_fs btrfs
_supported_os Linux
_require_scratch
_require_dm_flakey
_need_to_be_root
rm -f $seqres.full
# Create a file with many file extent items, each representing a 4Kb extent.
# These items span 3 btree leaves, of 16Kb each (default mkfs.btrfs leaf size
# as of btrfs-progs 3.12).
_scratch_mkfs -l 16384 >/dev/null 2>&1
_init_flakey
SAVE_MOUNT_OPTIONS="$MOUNT_OPTIONS"
MOUNT_OPTIONS="$MOUNT_OPTIONS -o commit=999"
_mount_flakey
# First fsync, inode has BTRFS_INODE_NEEDS_FULL_SYNC flag set.
$XFS_IO_PROG -f -c "pwrite -S 0x01 -b 4096 0 4096" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# For any of the following fsync calls, inode doesn't have the flag
# BTRFS_INODE_NEEDS_FULL_SYNC set.
for ((i = 1; i <= 500; i++)); do
OFFSET=$((4096 * i))
LEN=4096
$XFS_IO_PROG -c "pwrite -S 0x01 $OFFSET $LEN" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
done
# Commit transaction and bump next transaction's id (to 7).
sync
# Truncate will set the BTRFS_INODE_NEEDS_FULL_SYNC flag in the btrfs's
# inode runtime flags.
$XFS_IO_PROG -c "truncate 2048000" $SCRATCH_MNT/foo
# Commit transaction and bump next transaction's id (to 8).
sync
# Touch 1 extent item from the first leaf and 1 from the last leaf. The leaf
# in the middle, containing only file extent items, isn't touched. So the
# next fsync, when calling btrfs_search_forward(), won't visit that middle
# leaf. First and 3rd leaf have now a generation with value 8, while the
# middle leaf remains with a generation with value 6.
$XFS_IO_PROG \
-c "pwrite -S 0xee -b 4096 0 4096" \
-c "pwrite -S 0xff -b 4096 2043904 4096" \
-c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
_load_flakey_table $FLAKEY_DROP_WRITES
md5sum $SCRATCH_MNT/foo | _filter_scratch
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
# During mount, we'll replay the log created by the fsync above, and the file's
# md5 digest should be the same we got before the unmount.
_mount_flakey
md5sum $SCRATCH_MNT/foo | _filter_scratch
_unmount_flakey
MOUNT_OPTIONS="$SAVE_MOUNT_OPTIONS"
status=0
exit
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-08-07 13:00:44 +02:00
|
|
|
if (need_find_last_extent && *last_extent == first_key.offset) {
|
|
|
|
/*
|
|
|
|
* We don't have any leafs between our current one and the one
|
|
|
|
* we processed before that can have file extent items for our
|
|
|
|
* inode (and have a generation number smaller than our current
|
|
|
|
* transaction id).
|
|
|
|
*/
|
|
|
|
need_find_last_extent = false;
|
|
|
|
}
|
|
|
|
|
2013-10-22 18:18:51 +02:00
|
|
|
/*
|
|
|
|
* Because we use btrfs_search_forward we could skip leaves that were
|
|
|
|
* not modified and then assume *last_extent is valid when it really
|
|
|
|
* isn't. So back up to the previous leaf and read the end of the last
|
|
|
|
* extent before we go and fill in holes.
|
|
|
|
*/
|
|
|
|
if (need_find_last_extent) {
|
|
|
|
u64 len;
|
|
|
|
|
|
|
|
ret = btrfs_prev_leaf(BTRFS_I(inode)->root, src_path);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (ret)
|
|
|
|
goto fill_holes;
|
|
|
|
if (src_path->slots[0])
|
|
|
|
src_path->slots[0]--;
|
|
|
|
src = src_path->nodes[0];
|
|
|
|
btrfs_item_key_to_cpu(src, &key, src_path->slots[0]);
|
|
|
|
if (key.objectid != btrfs_ino(inode) ||
|
|
|
|
key.type != BTRFS_EXTENT_DATA_KEY)
|
|
|
|
goto fill_holes;
|
|
|
|
extent = btrfs_item_ptr(src, src_path->slots[0],
|
|
|
|
struct btrfs_file_extent_item);
|
|
|
|
if (btrfs_file_extent_type(src, extent) ==
|
|
|
|
BTRFS_FILE_EXTENT_INLINE) {
|
2014-01-04 06:07:00 +01:00
|
|
|
len = btrfs_file_extent_inline_len(src,
|
|
|
|
src_path->slots[0],
|
|
|
|
extent);
|
2013-10-22 18:18:51 +02:00
|
|
|
*last_extent = ALIGN(key.offset + len,
|
|
|
|
log->sectorsize);
|
|
|
|
} else {
|
|
|
|
len = btrfs_file_extent_num_bytes(src, extent);
|
|
|
|
*last_extent = key.offset + len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fill_holes:
|
|
|
|
/* So we did prev_leaf, now we need to move to the next leaf, but a few
|
|
|
|
* things could have happened
|
|
|
|
*
|
|
|
|
* 1) A merge could have happened, so we could currently be on a leaf
|
|
|
|
* that holds what we were copying in the first place.
|
|
|
|
* 2) A split could have happened, and now not all of the items we want
|
|
|
|
* are on the same leaf.
|
|
|
|
*
|
|
|
|
* So we need to adjust how we search for holes, we need to drop the
|
|
|
|
* path and re-search for the first extent key we found, and then walk
|
|
|
|
* forward until we hit the last one we copied.
|
|
|
|
*/
|
|
|
|
if (need_find_last_extent) {
|
|
|
|
/* btrfs_prev_leaf could return 1 without releasing the path */
|
|
|
|
btrfs_release_path(src_path);
|
|
|
|
ret = btrfs_search_slot(NULL, BTRFS_I(inode)->root, &first_key,
|
|
|
|
src_path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
ASSERT(ret == 0);
|
|
|
|
src = src_path->nodes[0];
|
|
|
|
i = src_path->slots[0];
|
|
|
|
} else {
|
|
|
|
i = start_slot;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ok so here we need to go through and fill in any holes we may have
|
|
|
|
* to make sure that holes are punched for those areas in case they had
|
|
|
|
* extents previously.
|
|
|
|
*/
|
|
|
|
while (!done) {
|
|
|
|
u64 offset, len;
|
|
|
|
u64 extent_end;
|
|
|
|
|
|
|
|
if (i >= btrfs_header_nritems(src_path->nodes[0])) {
|
|
|
|
ret = btrfs_next_leaf(BTRFS_I(inode)->root, src_path);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
ASSERT(ret == 0);
|
|
|
|
src = src_path->nodes[0];
|
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(src, &key, i);
|
|
|
|
if (!btrfs_comp_cpu_keys(&key, &last_key))
|
|
|
|
done = true;
|
|
|
|
if (key.objectid != btrfs_ino(inode) ||
|
|
|
|
key.type != BTRFS_EXTENT_DATA_KEY) {
|
|
|
|
i++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
extent = btrfs_item_ptr(src, i, struct btrfs_file_extent_item);
|
|
|
|
if (btrfs_file_extent_type(src, extent) ==
|
|
|
|
BTRFS_FILE_EXTENT_INLINE) {
|
2014-01-04 06:07:00 +01:00
|
|
|
len = btrfs_file_extent_inline_len(src, i, extent);
|
2013-10-22 18:18:51 +02:00
|
|
|
extent_end = ALIGN(key.offset + len, log->sectorsize);
|
|
|
|
} else {
|
|
|
|
len = btrfs_file_extent_num_bytes(src, extent);
|
|
|
|
extent_end = key.offset + len;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
|
|
|
|
if (*last_extent == key.offset) {
|
|
|
|
*last_extent = extent_end;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
offset = *last_extent;
|
|
|
|
len = key.offset - *last_extent;
|
|
|
|
ret = btrfs_insert_file_extent(trans, log, btrfs_ino(inode),
|
|
|
|
offset, 0, 0, len, 0, len, 0,
|
|
|
|
0, 0);
|
|
|
|
if (ret)
|
|
|
|
break;
|
Btrfs: fix hole detection during file fsync
The file hole detection logic during a file fsync wasn't correct,
because it didn't look back (in a previous leaf) for the last file
extent item that can be in a leaf to the left of our leaf and that
has a generation lower than the current transaction id. This made it
assume that a hole exists when it really doesn't exist in the file.
Such false positive hole detection happens in the following scenario:
* We have a file that has many file extent items, covering 3 or more
btree leafs (the first leaf must contain non file extent items too).
* Two ranges of the file are modified, with their extent items being
located at 2 different leafs and those leafs aren't consecutive.
* When processing the second modified leaf, we weren't checking if
some file extent item exists that is located in some leaf that is
between our 2 modified leafs, and therefore assumed the range defined
between the last file extent item in the first leaf and the first file
extent item in the second leaf matched a hole.
Fortunately this didn't result in overriding the log with wrong data,
instead it made the last loop in copy_items() attempt to insert a
duplicated key (for a hole file extent item), which makes the file
fsync code return with -EEXIST to file.c:btrfs_sync_file() which in
turn ends up doing a full transaction commit, which is much more
expensive then writing only to the log tree and wait for it to be
durably persisted (as well as the file's modified extents/pages).
Therefore fix the hole detection logic, so that we don't pay the
cost of doing full transaction commits.
I could trigger this issue with the following test for xfstests (which
never fails, either without or with this patch). The last fsync call
results in a full transaction commit, due to the -EEXIST error mentioned
above. I could also observe this behaviour happening frequently when
running xfstests/generic/075 in a loop.
Test:
_cleanup()
{
_cleanup_flakey
rm -fr $tmp
}
# get standard environment, filters and checks
. ./common/rc
. ./common/filter
. ./common/dmflakey
# real QA test starts here
_supported_fs btrfs
_supported_os Linux
_require_scratch
_require_dm_flakey
_need_to_be_root
rm -f $seqres.full
# Create a file with many file extent items, each representing a 4Kb extent.
# These items span 3 btree leaves, of 16Kb each (default mkfs.btrfs leaf size
# as of btrfs-progs 3.12).
_scratch_mkfs -l 16384 >/dev/null 2>&1
_init_flakey
SAVE_MOUNT_OPTIONS="$MOUNT_OPTIONS"
MOUNT_OPTIONS="$MOUNT_OPTIONS -o commit=999"
_mount_flakey
# First fsync, inode has BTRFS_INODE_NEEDS_FULL_SYNC flag set.
$XFS_IO_PROG -f -c "pwrite -S 0x01 -b 4096 0 4096" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# For any of the following fsync calls, inode doesn't have the flag
# BTRFS_INODE_NEEDS_FULL_SYNC set.
for ((i = 1; i <= 500; i++)); do
OFFSET=$((4096 * i))
LEN=4096
$XFS_IO_PROG -c "pwrite -S 0x01 $OFFSET $LEN" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
done
# Commit transaction and bump next transaction's id (to 7).
sync
# Truncate will set the BTRFS_INODE_NEEDS_FULL_SYNC flag in the btrfs's
# inode runtime flags.
$XFS_IO_PROG -c "truncate 2048000" $SCRATCH_MNT/foo
# Commit transaction and bump next transaction's id (to 8).
sync
# Touch 1 extent item from the first leaf and 1 from the last leaf. The leaf
# in the middle, containing only file extent items, isn't touched. So the
# next fsync, when calling btrfs_search_forward(), won't visit that middle
# leaf. First and 3rd leaf have now a generation with value 8, while the
# middle leaf remains with a generation with value 6.
$XFS_IO_PROG \
-c "pwrite -S 0xee -b 4096 0 4096" \
-c "pwrite -S 0xff -b 4096 2043904 4096" \
-c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
_load_flakey_table $FLAKEY_DROP_WRITES
md5sum $SCRATCH_MNT/foo | _filter_scratch
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
# During mount, we'll replay the log created by the fsync above, and the file's
# md5 digest should be the same we got before the unmount.
_mount_flakey
md5sum $SCRATCH_MNT/foo | _filter_scratch
_unmount_flakey
MOUNT_OPTIONS="$SAVE_MOUNT_OPTIONS"
status=0
exit
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-08-07 13:00:44 +02:00
|
|
|
*last_extent = extent_end;
|
2013-10-22 18:18:51 +02:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Need to let the callers know we dropped the path so they should
|
|
|
|
* re-search.
|
|
|
|
*/
|
|
|
|
if (!ret && need_find_last_extent)
|
|
|
|
ret = 1;
|
2010-05-16 16:49:59 +02:00
|
|
|
return ret;
|
2008-09-11 22:17:57 +02:00
|
|
|
}
|
|
|
|
|
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 19:14:17 +02:00
|
|
|
static int extent_cmp(void *priv, struct list_head *a, struct list_head *b)
|
|
|
|
{
|
|
|
|
struct extent_map *em1, *em2;
|
|
|
|
|
|
|
|
em1 = list_entry(a, struct extent_map, list);
|
|
|
|
em2 = list_entry(b, struct extent_map, list);
|
|
|
|
|
|
|
|
if (em1->start < em2->start)
|
|
|
|
return -1;
|
|
|
|
else if (em1->start > em2->start)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
static int wait_ordered_extents(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *inode,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
const struct extent_map *em,
|
|
|
|
const struct list_head *logged_list,
|
|
|
|
bool *ordered_io_error)
|
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 19:14:17 +02:00
|
|
|
{
|
2012-10-12 21:27:49 +02:00
|
|
|
struct btrfs_ordered_extent *ordered;
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
struct btrfs_root *log = root->log_root;
|
2012-10-12 21:27:49 +02:00
|
|
|
u64 mod_start = em->mod_start;
|
|
|
|
u64 mod_len = em->mod_len;
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
const bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
|
2012-10-12 21:27:49 +02:00
|
|
|
u64 csum_offset;
|
|
|
|
u64 csum_len;
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
LIST_HEAD(ordered_sums);
|
|
|
|
int ret = 0;
|
2012-09-19 21:42:38 +02:00
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
*ordered_io_error = false;
|
2012-09-19 21:42:38 +02:00
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||
|
|
|
|
em->block_start == EXTENT_MAP_HOLE)
|
2012-10-11 22:54:30 +02:00
|
|
|
return 0;
|
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 19:14:17 +02:00
|
|
|
|
2012-10-12 21:27:49 +02:00
|
|
|
/*
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
* Wait far any ordered extent that covers our extent map. If it
|
|
|
|
* finishes without an error, first check and see if our csums are on
|
|
|
|
* our outstanding ordered extents.
|
2012-10-12 21:27:49 +02:00
|
|
|
*/
|
2014-01-14 13:31:51 +01:00
|
|
|
list_for_each_entry(ordered, logged_list, log_list) {
|
2012-10-12 21:27:49 +02:00
|
|
|
struct btrfs_ordered_sum *sum;
|
|
|
|
|
|
|
|
if (!mod_len)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (ordered->file_offset + ordered->len <= mod_start ||
|
|
|
|
mod_start + mod_len <= ordered->file_offset)
|
|
|
|
continue;
|
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
if (!test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags) &&
|
|
|
|
!test_bit(BTRFS_ORDERED_IOERR, &ordered->flags) &&
|
|
|
|
!test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags)) {
|
|
|
|
const u64 start = ordered->file_offset;
|
|
|
|
const u64 end = ordered->file_offset + ordered->len - 1;
|
|
|
|
|
|
|
|
WARN_ON(ordered->inode != inode);
|
|
|
|
filemap_fdatawrite_range(inode->i_mapping, start, end);
|
|
|
|
}
|
|
|
|
|
|
|
|
wait_event(ordered->wait,
|
|
|
|
(test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags) ||
|
|
|
|
test_bit(BTRFS_ORDERED_IOERR, &ordered->flags)));
|
|
|
|
|
|
|
|
if (test_bit(BTRFS_ORDERED_IOERR, &ordered->flags)) {
|
Btrfs: ensure ordered extent errors aren't missed on fsync
When doing a fsync with a fast path we have a time window where we can miss
the fact that writeback of some file data failed, and therefore we endup
returning success (0) from fsync when we should return an error.
The steps that lead to this are the following:
1) We start all ordered extents by calling filemap_fdatawrite_range();
2) We do some other work like locking the inode's i_mutex, start a transaction,
start a log transaction, etc;
3) We enter btrfs_log_inode(), acquire the inode's log_mutex and collect all the
ordered extents from inode's ordered tree into a list;
4) But by the time we do ordered extent collection, some ordered extents we started
at step 1) might have already completed with an error, and therefore we didn't
found them in the ordered tree and had no idea they finished with an error. This
makes our fsync return success (0) to userspace, but has no bad effects on the log
like for example insertion of file extent items into the log that point to unwritten
extents, because the invalid extent maps were removed before the ordered extent
completed (in inode.c:btrfs_finish_ordered_io).
So after collecting the ordered extents just check if the inode's i_mapping has any
error flags set (AS_EIO or AS_ENOSPC) and leave with an error if it does. Whenever
writeback fails for a page of an ordered extent, we call mapping_set_error (done in
extent_io.c:end_extent_writepage, called by extent_io.c:end_bio_extent_writepage)
that sets one of those error flags in the inode's i_mapping flags.
This change also has the side effect of fixing the issue where for fast fsyncs we
never checked/cleared the error flags from the inode's i_mapping flags, which means
that a full fsync performed after a fast fsync could get such errors that belonged
to the fast fsync - because the full fsync calls btrfs_wait_ordered_range() which
calls filemap_fdatawait_range(), and the later checks for and clears those flags,
while for fast fsyncs we never call filemap_fdatawait_range() or anything else
that checks for and clears the error flags from the inode's i_mapping.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-11-13 18:01:45 +01:00
|
|
|
/*
|
|
|
|
* Clear the AS_EIO/AS_ENOSPC flags from the inode's
|
|
|
|
* i_mapping flags, so that the next fsync won't get
|
|
|
|
* an outdated io error too.
|
|
|
|
*/
|
|
|
|
btrfs_inode_check_errors(inode);
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
*ordered_io_error = true;
|
|
|
|
break;
|
|
|
|
}
|
2012-10-12 21:27:49 +02:00
|
|
|
/*
|
|
|
|
* We are going to copy all the csums on this ordered extent, so
|
|
|
|
* go ahead and adjust mod_start and mod_len in case this
|
|
|
|
* ordered extent has already been logged.
|
|
|
|
*/
|
|
|
|
if (ordered->file_offset > mod_start) {
|
|
|
|
if (ordered->file_offset + ordered->len >=
|
|
|
|
mod_start + mod_len)
|
|
|
|
mod_len = ordered->file_offset - mod_start;
|
|
|
|
/*
|
|
|
|
* If we have this case
|
|
|
|
*
|
|
|
|
* |--------- logged extent ---------|
|
|
|
|
* |----- ordered extent ----|
|
|
|
|
*
|
|
|
|
* Just don't mess with mod_start and mod_len, we'll
|
|
|
|
* just end up logging more csums than we need and it
|
|
|
|
* will be ok.
|
|
|
|
*/
|
|
|
|
} else {
|
|
|
|
if (ordered->file_offset + ordered->len <
|
|
|
|
mod_start + mod_len) {
|
|
|
|
mod_len = (mod_start + mod_len) -
|
|
|
|
(ordered->file_offset + ordered->len);
|
|
|
|
mod_start = ordered->file_offset +
|
|
|
|
ordered->len;
|
|
|
|
} else {
|
|
|
|
mod_len = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
if (skip_csum)
|
|
|
|
continue;
|
|
|
|
|
2012-10-12 21:27:49 +02:00
|
|
|
/*
|
|
|
|
* To keep us from looping for the above case of an ordered
|
|
|
|
* extent that falls inside of the logged extent.
|
|
|
|
*/
|
|
|
|
if (test_and_set_bit(BTRFS_ORDERED_LOGGED_CSUM,
|
|
|
|
&ordered->flags))
|
|
|
|
continue;
|
|
|
|
|
2014-01-14 13:31:52 +01:00
|
|
|
if (ordered->csum_bytes_left) {
|
|
|
|
btrfs_start_ordered_extent(inode, ordered, 0);
|
|
|
|
wait_event(ordered->wait,
|
|
|
|
ordered->csum_bytes_left == 0);
|
|
|
|
}
|
2012-10-12 21:27:49 +02:00
|
|
|
|
|
|
|
list_for_each_entry(sum, &ordered->list, list) {
|
|
|
|
ret = btrfs_csum_file_blocks(trans, log, sum);
|
2014-01-14 13:31:51 +01:00
|
|
|
if (ret)
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
break;
|
2012-10-12 21:27:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
if (*ordered_io_error || !mod_len || ret || skip_csum)
|
2012-10-12 21:27:49 +02:00
|
|
|
return ret;
|
|
|
|
|
2013-10-28 17:30:29 +01:00
|
|
|
if (em->compress_type) {
|
|
|
|
csum_offset = 0;
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
csum_len = max(em->block_len, em->orig_block_len);
|
2013-10-28 17:30:29 +01:00
|
|
|
} else {
|
|
|
|
csum_offset = mod_start - em->start;
|
|
|
|
csum_len = mod_len;
|
|
|
|
}
|
2012-10-12 21:27:49 +02:00
|
|
|
|
2012-10-11 22:54:30 +02:00
|
|
|
/* block start is already adjusted for the file extent offset. */
|
|
|
|
ret = btrfs_lookup_csums_range(log->fs_info->csum_root,
|
|
|
|
em->block_start + csum_offset,
|
|
|
|
em->block_start + csum_offset +
|
|
|
|
csum_len - 1, &ordered_sums, 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
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 19:14:17 +02:00
|
|
|
|
2012-10-11 22:54:30 +02:00
|
|
|
while (!list_empty(&ordered_sums)) {
|
|
|
|
struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
|
|
|
|
struct btrfs_ordered_sum,
|
|
|
|
list);
|
|
|
|
if (!ret)
|
|
|
|
ret = btrfs_csum_file_blocks(trans, log, sums);
|
|
|
|
list_del(&sums->list);
|
|
|
|
kfree(sums);
|
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 19:14:17 +02:00
|
|
|
}
|
|
|
|
|
2012-10-11 22:54:30 +02:00
|
|
|
return ret;
|
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 19:14:17 +02:00
|
|
|
}
|
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
static int log_one_extent(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *inode, struct btrfs_root *root,
|
|
|
|
const struct extent_map *em,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
const struct list_head *logged_list,
|
|
|
|
struct btrfs_log_ctx *ctx)
|
|
|
|
{
|
|
|
|
struct btrfs_root *log = root->log_root;
|
|
|
|
struct btrfs_file_extent_item *fi;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_map_token token;
|
|
|
|
struct btrfs_key key;
|
|
|
|
u64 extent_offset = em->start - em->orig_start;
|
|
|
|
u64 block_len;
|
|
|
|
int ret;
|
|
|
|
int extent_inserted = 0;
|
|
|
|
bool ordered_io_err = false;
|
|
|
|
|
|
|
|
ret = wait_ordered_extents(trans, inode, root, em, logged_list,
|
|
|
|
&ordered_io_err);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (ordered_io_err) {
|
|
|
|
ctx->io_err = -EIO;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_init_map_token(&token);
|
|
|
|
|
|
|
|
ret = __btrfs_drop_extents(trans, log, inode, path, em->start,
|
|
|
|
em->start + em->len, NULL, 0, 1,
|
|
|
|
sizeof(*fi), &extent_inserted);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (!extent_inserted) {
|
|
|
|
key.objectid = btrfs_ino(inode);
|
|
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
|
|
|
key.offset = em->start;
|
|
|
|
|
|
|
|
ret = btrfs_insert_empty_item(trans, log, path, &key,
|
|
|
|
sizeof(*fi));
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
|
|
struct btrfs_file_extent_item);
|
|
|
|
|
2014-11-21 20:52:38 +01:00
|
|
|
btrfs_set_token_file_extent_generation(leaf, fi, trans->transid,
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
&token);
|
|
|
|
if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
|
|
|
|
btrfs_set_token_file_extent_type(leaf, fi,
|
|
|
|
BTRFS_FILE_EXTENT_PREALLOC,
|
|
|
|
&token);
|
|
|
|
else
|
|
|
|
btrfs_set_token_file_extent_type(leaf, fi,
|
|
|
|
BTRFS_FILE_EXTENT_REG,
|
|
|
|
&token);
|
|
|
|
|
|
|
|
block_len = max(em->block_len, em->orig_block_len);
|
|
|
|
if (em->compress_type != BTRFS_COMPRESS_NONE) {
|
|
|
|
btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
|
|
|
|
em->block_start,
|
|
|
|
&token);
|
|
|
|
btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
|
|
|
|
&token);
|
|
|
|
} else if (em->block_start < EXTENT_MAP_LAST_BYTE) {
|
|
|
|
btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
|
|
|
|
em->block_start -
|
|
|
|
extent_offset, &token);
|
|
|
|
btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
|
|
|
|
&token);
|
|
|
|
} else {
|
|
|
|
btrfs_set_token_file_extent_disk_bytenr(leaf, fi, 0, &token);
|
|
|
|
btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, 0,
|
|
|
|
&token);
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_set_token_file_extent_offset(leaf, fi, extent_offset, &token);
|
|
|
|
btrfs_set_token_file_extent_num_bytes(leaf, fi, em->len, &token);
|
|
|
|
btrfs_set_token_file_extent_ram_bytes(leaf, fi, em->ram_bytes, &token);
|
|
|
|
btrfs_set_token_file_extent_compression(leaf, fi, em->compress_type,
|
|
|
|
&token);
|
|
|
|
btrfs_set_token_file_extent_encryption(leaf, fi, 0, &token);
|
|
|
|
btrfs_set_token_file_extent_other_encoding(leaf, fi, 0, &token);
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
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 19:14:17 +02:00
|
|
|
static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct inode *inode,
|
2014-01-14 13:31:51 +01:00
|
|
|
struct btrfs_path *path,
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
struct list_head *logged_list,
|
|
|
|
struct btrfs_log_ctx *ctx)
|
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 19:14:17 +02:00
|
|
|
{
|
|
|
|
struct extent_map *em, *n;
|
|
|
|
struct list_head extents;
|
|
|
|
struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
|
|
|
|
u64 test_gen;
|
|
|
|
int ret = 0;
|
2012-10-12 21:27:49 +02:00
|
|
|
int num = 0;
|
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 19:14:17 +02:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&extents);
|
|
|
|
|
|
|
|
write_lock(&tree->lock);
|
|
|
|
test_gen = root->fs_info->last_trans_committed;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
|
|
|
|
list_del_init(&em->list);
|
2012-10-12 21:27:49 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Just an arbitrary number, this can be really CPU intensive
|
|
|
|
* once we start getting a lot of extents, and really once we
|
|
|
|
* have a bunch of extents we just want to commit since it will
|
|
|
|
* be faster.
|
|
|
|
*/
|
|
|
|
if (++num > 32768) {
|
|
|
|
list_del_init(&tree->modified_extents);
|
|
|
|
ret = -EFBIG;
|
|
|
|
goto process;
|
|
|
|
}
|
|
|
|
|
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 19:14:17 +02:00
|
|
|
if (em->generation <= test_gen)
|
|
|
|
continue;
|
2012-09-14 18:59:20 +02:00
|
|
|
/* Need a ref to keep it from getting evicted from cache */
|
|
|
|
atomic_inc(&em->refs);
|
|
|
|
set_bit(EXTENT_FLAG_LOGGING, &em->flags);
|
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 19:14:17 +02:00
|
|
|
list_add_tail(&em->list, &extents);
|
2012-10-12 21:27:49 +02:00
|
|
|
num++;
|
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 19:14:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
list_sort(NULL, &extents, extent_cmp);
|
|
|
|
|
2012-10-12 21:27:49 +02:00
|
|
|
process:
|
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 19:14:17 +02:00
|
|
|
while (!list_empty(&extents)) {
|
|
|
|
em = list_entry(extents.next, struct extent_map, list);
|
|
|
|
|
|
|
|
list_del_init(&em->list);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we had an error we just need to delete everybody from our
|
|
|
|
* private list.
|
|
|
|
*/
|
2012-09-14 18:59:20 +02:00
|
|
|
if (ret) {
|
2013-01-24 18:02:07 +01:00
|
|
|
clear_em_logging(tree, em);
|
2012-09-14 18:59:20 +02:00
|
|
|
free_extent_map(em);
|
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 19:14:17 +02:00
|
|
|
continue;
|
2012-09-14 18:59:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
write_unlock(&tree->lock);
|
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 19:14:17 +02:00
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
ret = log_one_extent(trans, inode, root, em, path, logged_list,
|
|
|
|
ctx);
|
2012-09-14 18:59:20 +02:00
|
|
|
write_lock(&tree->lock);
|
2013-01-24 18:02:07 +01:00
|
|
|
clear_em_logging(tree, em);
|
|
|
|
free_extent_map(em);
|
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 19:14:17 +02:00
|
|
|
}
|
2012-09-14 18:59:20 +02:00
|
|
|
WARN_ON(!list_empty(&extents));
|
|
|
|
write_unlock(&tree->lock);
|
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 19:14:17 +02:00
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
static int logged_inode_size(struct btrfs_root *log, struct inode *inode,
|
|
|
|
struct btrfs_path *path, u64 *size_ret)
|
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
key.objectid = btrfs_ino(inode);
|
|
|
|
key.type = BTRFS_INODE_ITEM_KEY;
|
|
|
|
key.offset = 0;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, log, &key, path, 0, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
} else if (ret > 0) {
|
|
|
|
*size_ret = i_size_read(inode);
|
|
|
|
} else {
|
|
|
|
struct btrfs_inode_item *item;
|
|
|
|
|
|
|
|
item = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_inode_item);
|
|
|
|
*size_ret = btrfs_inode_size(path->nodes[0], item);
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/* log a single inode in the tree log.
|
|
|
|
* At least one parent directory for this inode must exist in the tree
|
|
|
|
* or be logged already.
|
|
|
|
*
|
|
|
|
* Any items from this inode changed by the current transaction are copied
|
|
|
|
* to the log tree. An extra reference is taken on any extents in this
|
|
|
|
* file, allowing us to avoid a whole pile of corner cases around logging
|
|
|
|
* blocks that have been removed from the tree.
|
|
|
|
*
|
|
|
|
* See LOG_INODE_ALL and related defines for a description of what inode_only
|
|
|
|
* does.
|
|
|
|
*
|
|
|
|
* This handles both files and directories.
|
|
|
|
*/
|
2009-03-24 15:24:20 +01:00
|
|
|
static int btrfs_log_inode(struct btrfs_trans_handle *trans,
|
2014-09-06 23:34:39 +02:00
|
|
|
struct btrfs_root *root, struct inode *inode,
|
|
|
|
int inode_only,
|
|
|
|
const loff_t start,
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
const loff_t end,
|
|
|
|
struct btrfs_log_ctx *ctx)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_path *dst_path;
|
|
|
|
struct btrfs_key min_key;
|
|
|
|
struct btrfs_key max_key;
|
|
|
|
struct btrfs_root *log = root->log_root;
|
2008-09-11 22:17:57 +02:00
|
|
|
struct extent_buffer *src = NULL;
|
2014-01-14 13:31:51 +01:00
|
|
|
LIST_HEAD(logged_list);
|
2013-10-22 18:18:51 +02:00
|
|
|
u64 last_extent = 0;
|
2010-05-16 16:49:59 +02:00
|
|
|
int err = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
int ret;
|
2008-09-11 21:53:37 +02:00
|
|
|
int nritems;
|
2008-09-11 22:17:57 +02:00
|
|
|
int ins_start_slot = 0;
|
|
|
|
int ins_nr;
|
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 19:14:17 +02:00
|
|
|
bool fast_search = false;
|
2011-04-20 04:31:50 +02:00
|
|
|
u64 ino = btrfs_ino(inode);
|
2014-09-06 23:34:39 +02:00
|
|
|
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
u64 logged_isize = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2011-02-01 10:17:35 +01:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2008-09-05 22:13:11 +02:00
|
|
|
dst_path = btrfs_alloc_path();
|
2011-02-01 10:17:35 +01:00
|
|
|
if (!dst_path) {
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2011-04-20 04:31:50 +02:00
|
|
|
min_key.objectid = ino;
|
2008-09-05 22:13:11 +02:00
|
|
|
min_key.type = BTRFS_INODE_ITEM_KEY;
|
|
|
|
min_key.offset = 0;
|
|
|
|
|
2011-04-20 04:31:50 +02:00
|
|
|
max_key.objectid = ino;
|
2009-03-24 15:24:20 +01:00
|
|
|
|
|
|
|
|
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 19:14:17 +02:00
|
|
|
/* today the code can only do partial logging of directories */
|
2012-11-01 08:35:23 +01:00
|
|
|
if (S_ISDIR(inode->i_mode) ||
|
|
|
|
(!test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
|
|
|
|
&BTRFS_I(inode)->runtime_flags) &&
|
|
|
|
inode_only == LOG_INODE_EXISTS))
|
2008-09-05 22:13:11 +02:00
|
|
|
max_key.type = BTRFS_XATTR_ITEM_KEY;
|
|
|
|
else
|
|
|
|
max_key.type = (u8)-1;
|
|
|
|
max_key.offset = (u64)-1;
|
|
|
|
|
Btrfs: fix fsync when extend references are added to an inode
If we added an extended reference to an inode and fsync'ed it, the log
replay code would make our inode have an incorrect link count, which
was lower then the expected/correct count.
This resulted in stale directory index entries after deleting some of
the hard links, and any access to the dangling directory entries resulted
in -ESTALE errors because the entries pointed to inode items that don't
exist anymore.
This is easy to reproduce with the test case I made for xfstests, and
the bulk of that test is:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Add one more link to the inode that ends up being a btrfs extref and fsync
# the inode.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Now after the fsync log replay btrfs left our inode with a wrong link count N,
# which was smaller than the correct link count M (N < M).
# So after removing N hard links, the remaining M - N directory entries were
# still visible to user space but it was impossible to do anything with them
# because they pointed to an inode that didn't exist anymore. This resulted in
# stale file handle errors (-ESTALE) when accessing those dentries for example.
#
# So remove all hard links except the first one and then attempt to read the
# file, to verify we don't get an -ESTALE error when accessing the inodel
#
# The btrfs fsck tool also detected the incorrect inode link count and it
# reported an error message like the following:
#
# root 5 inode 257 errors 2001, no inode item, link count wrong
# unresolved ref dir 256 index 2978 namelen 13 name foo_link_2976 filetype 1 errors 4, no inode ref
#
# The fstests framework automatically calls fsck after a test is run, so we
# don't need to call fsck explicitly here.
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
status=0
exit
So make sure an fsync always flushes the delayed inode item, so that the
fsync log contains it (needed in order to trigger the link count fixup
code) and fix the extref counting function, which always return -ENOENT
to its caller (and made it assume there were always 0 extrefs).
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-13 17:40:04 +01:00
|
|
|
/*
|
|
|
|
* Only run delayed items if we are a dir or a new file.
|
|
|
|
* Otherwise commit the delayed inode only, which is needed in
|
|
|
|
* order for the log replay code to mark inodes for link count
|
|
|
|
* fixup (create temporary BTRFS_TREE_LOG_FIXUP_OBJECTID items).
|
|
|
|
*/
|
2012-09-25 20:56:25 +02:00
|
|
|
if (S_ISDIR(inode->i_mode) ||
|
Btrfs: fix fsync when extend references are added to an inode
If we added an extended reference to an inode and fsync'ed it, the log
replay code would make our inode have an incorrect link count, which
was lower then the expected/correct count.
This resulted in stale directory index entries after deleting some of
the hard links, and any access to the dangling directory entries resulted
in -ESTALE errors because the entries pointed to inode items that don't
exist anymore.
This is easy to reproduce with the test case I made for xfstests, and
the bulk of that test is:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Add one more link to the inode that ends up being a btrfs extref and fsync
# the inode.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Now after the fsync log replay btrfs left our inode with a wrong link count N,
# which was smaller than the correct link count M (N < M).
# So after removing N hard links, the remaining M - N directory entries were
# still visible to user space but it was impossible to do anything with them
# because they pointed to an inode that didn't exist anymore. This resulted in
# stale file handle errors (-ESTALE) when accessing those dentries for example.
#
# So remove all hard links except the first one and then attempt to read the
# file, to verify we don't get an -ESTALE error when accessing the inodel
#
# The btrfs fsck tool also detected the incorrect inode link count and it
# reported an error message like the following:
#
# root 5 inode 257 errors 2001, no inode item, link count wrong
# unresolved ref dir 256 index 2978 namelen 13 name foo_link_2976 filetype 1 errors 4, no inode ref
#
# The fstests framework automatically calls fsck after a test is run, so we
# don't need to call fsck explicitly here.
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
status=0
exit
So make sure an fsync always flushes the delayed inode item, so that the
fsync log contains it (needed in order to trigger the link count fixup
code) and fix the extref counting function, which always return -ENOENT
to its caller (and made it assume there were always 0 extrefs).
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-13 17:40:04 +01:00
|
|
|
BTRFS_I(inode)->generation > root->fs_info->last_trans_committed)
|
2012-09-25 20:56:25 +02:00
|
|
|
ret = btrfs_commit_inode_delayed_items(trans, inode);
|
Btrfs: fix fsync when extend references are added to an inode
If we added an extended reference to an inode and fsync'ed it, the log
replay code would make our inode have an incorrect link count, which
was lower then the expected/correct count.
This resulted in stale directory index entries after deleting some of
the hard links, and any access to the dangling directory entries resulted
in -ESTALE errors because the entries pointed to inode items that don't
exist anymore.
This is easy to reproduce with the test case I made for xfstests, and
the bulk of that test is:
_scratch_mkfs "-O extref" >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 3001 hard links. This number is large enough to
# make btrfs start using extrefs at some point even if the fs has the maximum
# possible leaf/node size (64Kb).
echo "hello world" > $SCRATCH_MNT/foo
for i in `seq 1 3000`; do
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_`printf "%04d" $i`
done
# Make sure all metadata and data are durably persisted.
sync
# Add one more link to the inode that ends up being a btrfs extref and fsync
# the inode.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link_3001
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Now after the fsync log replay btrfs left our inode with a wrong link count N,
# which was smaller than the correct link count M (N < M).
# So after removing N hard links, the remaining M - N directory entries were
# still visible to user space but it was impossible to do anything with them
# because they pointed to an inode that didn't exist anymore. This resulted in
# stale file handle errors (-ESTALE) when accessing those dentries for example.
#
# So remove all hard links except the first one and then attempt to read the
# file, to verify we don't get an -ESTALE error when accessing the inodel
#
# The btrfs fsck tool also detected the incorrect inode link count and it
# reported an error message like the following:
#
# root 5 inode 257 errors 2001, no inode item, link count wrong
# unresolved ref dir 256 index 2978 namelen 13 name foo_link_2976 filetype 1 errors 4, no inode ref
#
# The fstests framework automatically calls fsck after a test is run, so we
# don't need to call fsck explicitly here.
rm -f $SCRATCH_MNT/foo_link_*
cat $SCRATCH_MNT/foo
status=0
exit
So make sure an fsync always flushes the delayed inode item, so that the
fsync log contains it (needed in order to trigger the link count fixup
code) and fix the extref counting function, which always return -ENOENT
to its caller (and made it assume there were always 0 extrefs).
This issue has been present since the introduction of the extrefs feature
(2012).
A test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-13 17:40:04 +01:00
|
|
|
else
|
|
|
|
ret = btrfs_commit_inode_delayed_inode(inode);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
btrfs_free_path(path);
|
|
|
|
btrfs_free_path(dst_path);
|
|
|
|
return ret;
|
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 12:12:22 +02:00
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
mutex_lock(&BTRFS_I(inode)->log_mutex);
|
|
|
|
|
2014-11-13 18:00:35 +01:00
|
|
|
btrfs_get_logged_extents(inode, &logged_list, start, end);
|
2012-10-12 21:27:49 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/*
|
|
|
|
* a brute force approach to making sure we get the most uptodate
|
|
|
|
* copies of everything.
|
|
|
|
*/
|
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
|
|
|
int max_key_type = BTRFS_DIR_LOG_INDEX_KEY;
|
|
|
|
|
Btrfs: don't remove extents and xattrs when logging new names
If we are recording in the tree log that an inode has new names (new hard
links were added), we would drop items, belonging to the inode, that we
shouldn't:
1) When the flag BTRFS_INODE_COPY_EVERYTHING is set in the inode's runtime
flags, we ended up dropping all the extent and xattr items that were
previously logged. This was done only in memory, since logging a new
name doesn't imply syncing the log;
2) When the flag BTRFS_INODE_COPY_EVERYTHING is set in the inode's runtime
flags, we ended up dropping all the xattr items that were previously
logged. Like the case before, this was done only in memory because
logging a new name doesn't imply syncing the log.
This led to some surprises in scenarios such as the following:
1) write some extents to an inode;
2) fsync the inode;
3) truncate the inode or delete/modify some of its xattrs
4) add a new hard link for that inode
5) fsync some other file, to force the log tree to be durably persisted
6) power failure happens
The next time the fs is mounted, the fsync log replay code is executed,
and the resulting file doesn't have the content it had when the last fsync
against it was performed, instead if has a content matching what it had
when the last transaction commit happened.
So change the behaviour such that when a new name is logged, only the inode
item and reference items are processed.
This is easy to reproduce with the test I just made for xfstests, whose
main body is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Now shrink our file to 5000 bytes.
$XFS_IO_PROG -c "truncate 5000" $SCRATCH_MNT/foo
# Now do an expanding truncate to a size larger than what we had when we last
# fsync'ed our file. This is just to verify that after power failure and
# replaying the fsync log, our file matches what it was when we last fsync'ed
# it - 12Kb size, first 8Kb of data had a value of 0xaa and the last 4Kb of
# data had a value of 0xcc.
$XFS_IO_PROG -c "truncate 32K" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs drop all of our file's
# metadata from the fsync log, including the metadata relative to the
# extent we just wrote and fsync'ed. This change was made only to the fsync
# log in memory, so adding the hard link alone doesn't change the persisted
# fsync log. This happened because the previous truncates set the runtime
# flag BTRFS_INODE_NEEDS_FULL_SYNC in the btrfs inode structure.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
# After this our persisted fsync log will no longer have metadata for our file
# foo that points to the extent we wrote and fsync'ed before.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to see a file
# with a size of 32Kb, with its first 5000 bytes having the value 0xaa and all
# the remaining bytes with value 0x00.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The expected result is to see a file with a size of 12Kb, with its first 8Kb
# of data having the value 0xaa and its last 4Kb of data having a value of 0xcc.
# The btrfs bug used to leave the file as it used te be as of the last
# transaction commit - that is, with a size of 8Kb with all bytes having a
# value of 0xaa.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
The test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 17:56:14 +01:00
|
|
|
if (inode_only == LOG_INODE_EXISTS) {
|
|
|
|
max_key_type = BTRFS_INODE_EXTREF_KEY;
|
|
|
|
max_key.type = max_key_type;
|
|
|
|
}
|
2011-04-20 04:31:50 +02:00
|
|
|
ret = drop_objectid_items(trans, log, path, ino, max_key_type);
|
2008-09-05 22:13:11 +02:00
|
|
|
} else {
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
if (inode_only == LOG_INODE_EXISTS) {
|
|
|
|
/*
|
|
|
|
* Make sure the new inode item we write to the log has
|
|
|
|
* the same isize as the current one (if it exists).
|
|
|
|
* This is necessary to prevent data loss after log
|
|
|
|
* replay, and also to prevent doing a wrong expanding
|
|
|
|
* truncate - for e.g. create file, write 4K into offset
|
|
|
|
* 0, fsync, write 4K into offset 4096, add hard link,
|
|
|
|
* fsync some other file (to sync log), power fail - if
|
|
|
|
* we use the inode's current i_size, after log replay
|
|
|
|
* we get a 8Kb file, with the last 4Kb extent as a hole
|
|
|
|
* (zeroes), as if an expanding truncate happened,
|
|
|
|
* instead of getting a file of 4Kb only.
|
|
|
|
*/
|
|
|
|
err = logged_inode_size(log, inode, path,
|
|
|
|
&logged_isize);
|
|
|
|
if (err)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
Btrfs: don't remove extents and xattrs when logging new names
If we are recording in the tree log that an inode has new names (new hard
links were added), we would drop items, belonging to the inode, that we
shouldn't:
1) When the flag BTRFS_INODE_COPY_EVERYTHING is set in the inode's runtime
flags, we ended up dropping all the extent and xattr items that were
previously logged. This was done only in memory, since logging a new
name doesn't imply syncing the log;
2) When the flag BTRFS_INODE_COPY_EVERYTHING is set in the inode's runtime
flags, we ended up dropping all the xattr items that were previously
logged. Like the case before, this was done only in memory because
logging a new name doesn't imply syncing the log.
This led to some surprises in scenarios such as the following:
1) write some extents to an inode;
2) fsync the inode;
3) truncate the inode or delete/modify some of its xattrs
4) add a new hard link for that inode
5) fsync some other file, to force the log tree to be durably persisted
6) power failure happens
The next time the fs is mounted, the fsync log replay code is executed,
and the resulting file doesn't have the content it had when the last fsync
against it was performed, instead if has a content matching what it had
when the last transaction commit happened.
So change the behaviour such that when a new name is logged, only the inode
item and reference items are processed.
This is easy to reproduce with the test I just made for xfstests, whose
main body is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Now shrink our file to 5000 bytes.
$XFS_IO_PROG -c "truncate 5000" $SCRATCH_MNT/foo
# Now do an expanding truncate to a size larger than what we had when we last
# fsync'ed our file. This is just to verify that after power failure and
# replaying the fsync log, our file matches what it was when we last fsync'ed
# it - 12Kb size, first 8Kb of data had a value of 0xaa and the last 4Kb of
# data had a value of 0xcc.
$XFS_IO_PROG -c "truncate 32K" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs drop all of our file's
# metadata from the fsync log, including the metadata relative to the
# extent we just wrote and fsync'ed. This change was made only to the fsync
# log in memory, so adding the hard link alone doesn't change the persisted
# fsync log. This happened because the previous truncates set the runtime
# flag BTRFS_INODE_NEEDS_FULL_SYNC in the btrfs inode structure.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
# After this our persisted fsync log will no longer have metadata for our file
# foo that points to the extent we wrote and fsync'ed before.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to see a file
# with a size of 32Kb, with its first 5000 bytes having the value 0xaa and all
# the remaining bytes with value 0x00.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The expected result is to see a file with a size of 12Kb, with its first 8Kb
# of data having the value 0xaa and its last 4Kb of data having a value of 0xcc.
# The btrfs bug used to leave the file as it used te be as of the last
# transaction commit - that is, with a size of 8Kb with all bytes having a
# value of 0xaa.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
The test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 17:56:14 +01:00
|
|
|
if (test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
|
|
|
|
&BTRFS_I(inode)->runtime_flags)) {
|
|
|
|
if (inode_only == LOG_INODE_EXISTS) {
|
|
|
|
max_key.type = BTRFS_INODE_EXTREF_KEY;
|
|
|
|
ret = drop_objectid_items(trans, log, path, ino,
|
|
|
|
max_key.type);
|
|
|
|
} else {
|
|
|
|
clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
|
|
|
|
&BTRFS_I(inode)->runtime_flags);
|
|
|
|
clear_bit(BTRFS_INODE_COPY_EVERYTHING,
|
|
|
|
&BTRFS_I(inode)->runtime_flags);
|
|
|
|
ret = btrfs_truncate_inode_items(trans, log,
|
|
|
|
inode, 0, 0);
|
|
|
|
}
|
|
|
|
} else if (test_bit(BTRFS_INODE_COPY_EVERYTHING,
|
|
|
|
&BTRFS_I(inode)->runtime_flags) ||
|
2013-11-12 22:25:58 +01:00
|
|
|
inode_only == LOG_INODE_EXISTS) {
|
Btrfs: don't remove extents and xattrs when logging new names
If we are recording in the tree log that an inode has new names (new hard
links were added), we would drop items, belonging to the inode, that we
shouldn't:
1) When the flag BTRFS_INODE_COPY_EVERYTHING is set in the inode's runtime
flags, we ended up dropping all the extent and xattr items that were
previously logged. This was done only in memory, since logging a new
name doesn't imply syncing the log;
2) When the flag BTRFS_INODE_COPY_EVERYTHING is set in the inode's runtime
flags, we ended up dropping all the xattr items that were previously
logged. Like the case before, this was done only in memory because
logging a new name doesn't imply syncing the log.
This led to some surprises in scenarios such as the following:
1) write some extents to an inode;
2) fsync the inode;
3) truncate the inode or delete/modify some of its xattrs
4) add a new hard link for that inode
5) fsync some other file, to force the log tree to be durably persisted
6) power failure happens
The next time the fs is mounted, the fsync log replay code is executed,
and the resulting file doesn't have the content it had when the last fsync
against it was performed, instead if has a content matching what it had
when the last transaction commit happened.
So change the behaviour such that when a new name is logged, only the inode
item and reference items are processed.
This is easy to reproduce with the test I just made for xfstests, whose
main body is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Now shrink our file to 5000 bytes.
$XFS_IO_PROG -c "truncate 5000" $SCRATCH_MNT/foo
# Now do an expanding truncate to a size larger than what we had when we last
# fsync'ed our file. This is just to verify that after power failure and
# replaying the fsync log, our file matches what it was when we last fsync'ed
# it - 12Kb size, first 8Kb of data had a value of 0xaa and the last 4Kb of
# data had a value of 0xcc.
$XFS_IO_PROG -c "truncate 32K" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs drop all of our file's
# metadata from the fsync log, including the metadata relative to the
# extent we just wrote and fsync'ed. This change was made only to the fsync
# log in memory, so adding the hard link alone doesn't change the persisted
# fsync log. This happened because the previous truncates set the runtime
# flag BTRFS_INODE_NEEDS_FULL_SYNC in the btrfs inode structure.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
# After this our persisted fsync log will no longer have metadata for our file
# foo that points to the extent we wrote and fsync'ed before.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to see a file
# with a size of 32Kb, with its first 5000 bytes having the value 0xaa and all
# the remaining bytes with value 0x00.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The expected result is to see a file with a size of 12Kb, with its first 8Kb
# of data having the value 0xaa and its last 4Kb of data having a value of 0xcc.
# The btrfs bug used to leave the file as it used te be as of the last
# transaction commit - that is, with a size of 8Kb with all bytes having a
# value of 0xaa.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
The test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 17:56:14 +01:00
|
|
|
if (inode_only == LOG_INODE_ALL) {
|
|
|
|
clear_bit(BTRFS_INODE_COPY_EVERYTHING,
|
|
|
|
&BTRFS_I(inode)->runtime_flags);
|
2012-11-01 07:38:47 +01:00
|
|
|
fast_search = true;
|
Btrfs: don't remove extents and xattrs when logging new names
If we are recording in the tree log that an inode has new names (new hard
links were added), we would drop items, belonging to the inode, that we
shouldn't:
1) When the flag BTRFS_INODE_COPY_EVERYTHING is set in the inode's runtime
flags, we ended up dropping all the extent and xattr items that were
previously logged. This was done only in memory, since logging a new
name doesn't imply syncing the log;
2) When the flag BTRFS_INODE_COPY_EVERYTHING is set in the inode's runtime
flags, we ended up dropping all the xattr items that were previously
logged. Like the case before, this was done only in memory because
logging a new name doesn't imply syncing the log.
This led to some surprises in scenarios such as the following:
1) write some extents to an inode;
2) fsync the inode;
3) truncate the inode or delete/modify some of its xattrs
4) add a new hard link for that inode
5) fsync some other file, to force the log tree to be durably persisted
6) power failure happens
The next time the fs is mounted, the fsync log replay code is executed,
and the resulting file doesn't have the content it had when the last fsync
against it was performed, instead if has a content matching what it had
when the last transaction commit happened.
So change the behaviour such that when a new name is logged, only the inode
item and reference items are processed.
This is easy to reproduce with the test I just made for xfstests, whose
main body is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Now shrink our file to 5000 bytes.
$XFS_IO_PROG -c "truncate 5000" $SCRATCH_MNT/foo
# Now do an expanding truncate to a size larger than what we had when we last
# fsync'ed our file. This is just to verify that after power failure and
# replaying the fsync log, our file matches what it was when we last fsync'ed
# it - 12Kb size, first 8Kb of data had a value of 0xaa and the last 4Kb of
# data had a value of 0xcc.
$XFS_IO_PROG -c "truncate 32K" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs drop all of our file's
# metadata from the fsync log, including the metadata relative to the
# extent we just wrote and fsync'ed. This change was made only to the fsync
# log in memory, so adding the hard link alone doesn't change the persisted
# fsync log. This happened because the previous truncates set the runtime
# flag BTRFS_INODE_NEEDS_FULL_SYNC in the btrfs inode structure.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
# After this our persisted fsync log will no longer have metadata for our file
# foo that points to the extent we wrote and fsync'ed before.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to see a file
# with a size of 32Kb, with its first 5000 bytes having the value 0xaa and all
# the remaining bytes with value 0x00.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The expected result is to see a file with a size of 12Kb, with its first 8Kb
# of data having the value 0xaa and its last 4Kb of data having a value of 0xcc.
# The btrfs bug used to leave the file as it used te be as of the last
# transaction commit - that is, with a size of 8Kb with all bytes having a
# value of 0xaa.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
The test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 17:56:14 +01:00
|
|
|
max_key.type = BTRFS_XATTR_ITEM_KEY;
|
|
|
|
} else {
|
|
|
|
max_key.type = BTRFS_INODE_EXTREF_KEY;
|
|
|
|
}
|
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 19:14:17 +02:00
|
|
|
ret = drop_objectid_items(trans, log, path, ino,
|
2012-10-11 21:53:56 +02:00
|
|
|
max_key.type);
|
2012-10-11 22:17:34 +02:00
|
|
|
} else {
|
|
|
|
if (inode_only == LOG_INODE_ALL)
|
|
|
|
fast_search = true;
|
|
|
|
ret = log_inode_item(trans, log, dst_path, inode);
|
|
|
|
if (ret) {
|
|
|
|
err = ret;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
goto log_extents;
|
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 19:14:17 +02:00
|
|
|
}
|
2012-10-11 22:17:34 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret) {
|
|
|
|
err = ret;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-11 22:17:57 +02:00
|
|
|
ins_nr = 0;
|
2013-10-01 17:13:42 +02:00
|
|
|
ret = btrfs_search_forward(root, &min_key,
|
2013-01-31 19:21:12 +01:00
|
|
|
path, trans->transid);
|
2008-09-05 22:13:11 +02:00
|
|
|
if (ret != 0)
|
|
|
|
break;
|
2008-09-11 21:53:37 +02:00
|
|
|
again:
|
2008-09-11 22:17:57 +02:00
|
|
|
/* note, ins_nr might be > 0 here, cleanup outside the loop */
|
2011-04-20 04:31:50 +02:00
|
|
|
if (min_key.objectid != ino)
|
2008-09-05 22:13:11 +02:00
|
|
|
break;
|
|
|
|
if (min_key.type > max_key.type)
|
|
|
|
break;
|
2008-09-11 22:17:57 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
src = path->nodes[0];
|
2008-09-11 22:17:57 +02:00
|
|
|
if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) {
|
|
|
|
ins_nr++;
|
|
|
|
goto next_slot;
|
|
|
|
} else if (!ins_nr) {
|
|
|
|
ins_start_slot = path->slots[0];
|
|
|
|
ins_nr = 1;
|
|
|
|
goto next_slot;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
2013-10-22 18:18:51 +02:00
|
|
|
ret = copy_items(trans, inode, dst_path, path, &last_extent,
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
ins_start_slot, ins_nr, inode_only,
|
|
|
|
logged_isize);
|
2013-10-22 18:18:51 +02:00
|
|
|
if (ret < 0) {
|
2010-05-16 16:49:59 +02:00
|
|
|
err = ret;
|
|
|
|
goto out_unlock;
|
2014-06-20 21:51:43 +02:00
|
|
|
}
|
|
|
|
if (ret) {
|
2013-10-22 18:18:51 +02:00
|
|
|
ins_nr = 0;
|
|
|
|
btrfs_release_path(path);
|
|
|
|
continue;
|
2010-05-16 16:49:59 +02:00
|
|
|
}
|
2008-09-11 22:17:57 +02:00
|
|
|
ins_nr = 1;
|
|
|
|
ins_start_slot = path->slots[0];
|
|
|
|
next_slot:
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2008-09-11 21:53:37 +02:00
|
|
|
nritems = btrfs_header_nritems(path->nodes[0]);
|
|
|
|
path->slots[0]++;
|
|
|
|
if (path->slots[0] < nritems) {
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &min_key,
|
|
|
|
path->slots[0]);
|
|
|
|
goto again;
|
|
|
|
}
|
2008-09-11 22:17:57 +02:00
|
|
|
if (ins_nr) {
|
2013-10-22 18:18:51 +02:00
|
|
|
ret = copy_items(trans, inode, dst_path, path,
|
|
|
|
&last_extent, ins_start_slot,
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
ins_nr, inode_only, logged_isize);
|
2013-10-22 18:18:51 +02:00
|
|
|
if (ret < 0) {
|
2010-05-16 16:49:59 +02:00
|
|
|
err = ret;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2013-10-22 18:18:51 +02:00
|
|
|
ret = 0;
|
2008-09-11 22:17:57 +02:00
|
|
|
ins_nr = 0;
|
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-11 21:53:37 +02:00
|
|
|
|
2013-10-01 18:06:53 +02:00
|
|
|
if (min_key.offset < (u64)-1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
min_key.offset++;
|
2013-10-01 18:06:53 +02:00
|
|
|
} else if (min_key.type < max_key.type) {
|
2008-09-05 22:13:11 +02:00
|
|
|
min_key.type++;
|
2013-10-01 18:06:53 +02:00
|
|
|
min_key.offset = 0;
|
|
|
|
} else {
|
2008-09-05 22:13:11 +02:00
|
|
|
break;
|
2013-10-01 18:06:53 +02:00
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2008-09-11 22:17:57 +02:00
|
|
|
if (ins_nr) {
|
2013-10-22 18:18:51 +02:00
|
|
|
ret = copy_items(trans, inode, dst_path, path, &last_extent,
|
Btrfs: fix fsync data loss after adding hard link to inode
We have a scenario where after the fsync log replay we can lose file data
that had been previously fsync'ed if we added an hard link for our inode
and after that we sync'ed the fsync log (for example by fsync'ing some
other file or directory).
This is because when adding an hard link we updated the inode item in the
log tree with an i_size value of 0. At that point the new inode item was
in memory only and a subsequent fsync log replay would not make us lose
the file data. However if after adding the hard link we sync the log tree
to disk, by fsync'ing some other file or directory for example, we ended
up losing the file data after log replay, because the inode item in the
persisted log tree had an an i_size of zero.
This is easy to reproduce, and the following excerpt from my test for
xfstests shows this:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create one file with data and fsync it.
# This made the btrfs fsync log persist the data and the inode metadata with
# a correct inode->i_size (4096 bytes).
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 4K 0 4K" -c "fsync" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Now add one hard link to our file. This made the btrfs code update the fsync
# log, in memory only, with an inode metadata having a size of 0.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now force persistence of the fsync log to disk, for example, by fsyncing some
# other file.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# Before a power loss or crash, we could read the 4Kb of data from our file as
# expected.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After the fsync log replay, because the fsync log had a value of 0 for our
# inode's i_size, we couldn't read anymore the 4Kb of data that we previously
# wrote and fsync'ed. The size of the file became 0 after the fsync log replay.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
Another alternative test, that doesn't need to fsync an inode in the same
transaction it was created, is:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create our test file with some data.
$XFS_IO_PROG -f -c "pwrite -S 0xaa -b 8K 0 8K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Make sure the file is durably persisted.
sync
# Append some data to our file, to increase its size.
$XFS_IO_PROG -f -c "pwrite -S 0xcc -b 4K 8K 4K" \
$SCRATCH_MNT/foo | _filter_xfs_io
# Fsync the file, so from this point on if a crash/power failure happens, our
# new data is guaranteed to be there next time the fs is mounted.
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foo
# Add one hard link to our file. This made btrfs write into the in memory fsync
# log a special inode with generation 0 and an i_size of 0 too. Note that this
# didn't update the inode in the fsync log on disk.
ln $SCRATCH_MNT/foo $SCRATCH_MNT/foo_link
# Now make sure the in memory fsync log is durably persisted.
# Creating and fsync'ing another file will do it.
touch $SCRATCH_MNT/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/bar
# As expected, before the crash/power failure, we should be able to read the
# 12Kb of file data.
echo "File content before:"
od -t x1 $SCRATCH_MNT/foo
# Simulate a crash/power loss.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# After mounting the fs again, the fsync log was replayed.
# The btrfs fsync log replay code didn't update the i_size of the persisted
# inode because the inode item in the log had a special generation with a
# value of 0 (and it couldn't know the correct i_size, since that inode item
# had a 0 i_size too). This made the last 4Kb of file data inaccessible and
# effectively lost.
echo "File content after:"
od -t x1 $SCRATCH_MNT/foo
This isn't a new issue/regression. This problem has been around since the
log tree code was added in 2008:
Btrfs: Add a write ahead tree log to optimize synchronous operations
(commit e02119d5a7b4396c5a872582fddc8bd6d305a70a)
Test cases for xfstests follow soon.
CC: <stable@vger.kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-02-13 13:30:56 +01:00
|
|
|
ins_start_slot, ins_nr, inode_only,
|
|
|
|
logged_isize);
|
2013-10-22 18:18:51 +02:00
|
|
|
if (ret < 0) {
|
2010-05-16 16:49:59 +02:00
|
|
|
err = ret;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2013-10-22 18:18:51 +02:00
|
|
|
ret = 0;
|
2008-09-11 22:17:57 +02:00
|
|
|
ins_nr = 0;
|
|
|
|
}
|
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 19:14:17 +02:00
|
|
|
|
2012-10-11 22:17:34 +02:00
|
|
|
log_extents:
|
2013-07-22 18:54:30 +02:00
|
|
|
btrfs_release_path(path);
|
|
|
|
btrfs_release_path(dst_path);
|
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 19:14:17 +02:00
|
|
|
if (fast_search) {
|
Btrfs: ensure ordered extent errors aren't missed on fsync
When doing a fsync with a fast path we have a time window where we can miss
the fact that writeback of some file data failed, and therefore we endup
returning success (0) from fsync when we should return an error.
The steps that lead to this are the following:
1) We start all ordered extents by calling filemap_fdatawrite_range();
2) We do some other work like locking the inode's i_mutex, start a transaction,
start a log transaction, etc;
3) We enter btrfs_log_inode(), acquire the inode's log_mutex and collect all the
ordered extents from inode's ordered tree into a list;
4) But by the time we do ordered extent collection, some ordered extents we started
at step 1) might have already completed with an error, and therefore we didn't
found them in the ordered tree and had no idea they finished with an error. This
makes our fsync return success (0) to userspace, but has no bad effects on the log
like for example insertion of file extent items into the log that point to unwritten
extents, because the invalid extent maps were removed before the ordered extent
completed (in inode.c:btrfs_finish_ordered_io).
So after collecting the ordered extents just check if the inode's i_mapping has any
error flags set (AS_EIO or AS_ENOSPC) and leave with an error if it does. Whenever
writeback fails for a page of an ordered extent, we call mapping_set_error (done in
extent_io.c:end_extent_writepage, called by extent_io.c:end_bio_extent_writepage)
that sets one of those error flags in the inode's i_mapping flags.
This change also has the side effect of fixing the issue where for fast fsyncs we
never checked/cleared the error flags from the inode's i_mapping flags, which means
that a full fsync performed after a fast fsync could get such errors that belonged
to the fast fsync - because the full fsync calls btrfs_wait_ordered_range() which
calls filemap_fdatawait_range(), and the later checks for and clears those flags,
while for fast fsyncs we never call filemap_fdatawait_range() or anything else
that checks for and clears the error flags from the inode's i_mapping.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-11-13 18:01:45 +01:00
|
|
|
/*
|
|
|
|
* Some ordered extents started by fsync might have completed
|
|
|
|
* before we collected the ordered extents in logged_list, which
|
|
|
|
* means they're gone, not in our logged_list nor in the inode's
|
|
|
|
* ordered tree. We want the application/user space to know an
|
|
|
|
* error happened while attempting to persist file data so that
|
|
|
|
* it can take proper action. If such error happened, we leave
|
|
|
|
* without writing to the log tree and the fsync must report the
|
|
|
|
* file data write error and not commit the current transaction.
|
|
|
|
*/
|
|
|
|
err = btrfs_inode_check_errors(inode);
|
|
|
|
if (err) {
|
|
|
|
ctx->io_err = err;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2014-01-14 13:31:51 +01:00
|
|
|
ret = btrfs_log_changed_extents(trans, root, inode, dst_path,
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
&logged_list, ctx);
|
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 19:14:17 +02:00
|
|
|
if (ret) {
|
|
|
|
err = ret;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2013-11-13 02:54:09 +01:00
|
|
|
} else if (inode_only == LOG_INODE_ALL) {
|
2012-08-27 18:52:19 +02:00
|
|
|
struct extent_map *em, *n;
|
|
|
|
|
2014-09-06 23:34:39 +02:00
|
|
|
write_lock(&em_tree->lock);
|
|
|
|
/*
|
|
|
|
* We can't just remove every em if we're called for a ranged
|
|
|
|
* fsync - that is, one that doesn't cover the whole possible
|
|
|
|
* file range (0 to LLONG_MAX). This is because we can have
|
|
|
|
* em's that fall outside the range we're logging and therefore
|
|
|
|
* their ordered operations haven't completed yet
|
|
|
|
* (btrfs_finish_ordered_io() not invoked yet). This means we
|
|
|
|
* didn't get their respective file extent item in the fs/subvol
|
|
|
|
* tree yet, and need to let the next fast fsync (one which
|
|
|
|
* consults the list of modified extent maps) find the em so
|
|
|
|
* that it logs a matching file extent item and waits for the
|
|
|
|
* respective ordered operation to complete (if it's still
|
|
|
|
* running).
|
|
|
|
*
|
|
|
|
* Removing every em outside the range we're logging would make
|
|
|
|
* the next fast fsync not log their matching file extent items,
|
|
|
|
* therefore making us lose data after a log replay.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_safe(em, n, &em_tree->modified_extents,
|
|
|
|
list) {
|
|
|
|
const u64 mod_end = em->mod_start + em->mod_len - 1;
|
|
|
|
|
|
|
|
if (em->mod_start >= start && mod_end <= end)
|
|
|
|
list_del_init(&em->list);
|
|
|
|
}
|
|
|
|
write_unlock(&em_tree->lock);
|
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 19:14:17 +02:00
|
|
|
}
|
|
|
|
|
2008-09-11 23:42:42 +02:00
|
|
|
if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = log_directory_changes(trans, root, inode, path, dst_path);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret) {
|
|
|
|
err = ret;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2014-09-06 23:34:39 +02:00
|
|
|
|
2014-09-11 22:22:14 +02:00
|
|
|
BTRFS_I(inode)->logged_trans = trans->transid;
|
|
|
|
BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->last_sub_trans;
|
2010-05-16 16:49:59 +02:00
|
|
|
out_unlock:
|
2014-01-14 13:31:51 +01:00
|
|
|
if (unlikely(err))
|
|
|
|
btrfs_put_logged_extents(&logged_list);
|
|
|
|
else
|
|
|
|
btrfs_submit_logged_extents(&logged_list, log);
|
2008-09-05 22:13:11 +02:00
|
|
|
mutex_unlock(&BTRFS_I(inode)->log_mutex);
|
|
|
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
btrfs_free_path(dst_path);
|
2010-05-16 16:49:59 +02:00
|
|
|
return err;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
/*
|
|
|
|
* follow the dentry parent pointers up the chain and see if any
|
|
|
|
* of the directories in it require a full commit before they can
|
|
|
|
* be logged. Returns zero if nothing special needs to be done or 1 if
|
|
|
|
* a full commit is required.
|
|
|
|
*/
|
|
|
|
static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *inode,
|
|
|
|
struct dentry *parent,
|
|
|
|
struct super_block *sb,
|
|
|
|
u64 last_committed)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
2009-03-24 15:24:20 +01:00
|
|
|
int ret = 0;
|
|
|
|
struct btrfs_root *root;
|
2010-11-20 10:48:00 +01:00
|
|
|
struct dentry *old_parent = NULL;
|
2013-09-11 15:36:30 +02:00
|
|
|
struct inode *orig_inode = inode;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-03-24 15:24:31 +01:00
|
|
|
/*
|
|
|
|
* for regular files, if its inode is already on disk, we don't
|
|
|
|
* have to worry about the parents at all. This is because
|
|
|
|
* we can use the last_unlink_trans field to record renames
|
|
|
|
* and other fun in this file.
|
|
|
|
*/
|
|
|
|
if (S_ISREG(inode->i_mode) &&
|
|
|
|
BTRFS_I(inode)->generation <= last_committed &&
|
|
|
|
BTRFS_I(inode)->last_unlink_trans <= last_committed)
|
|
|
|
goto out;
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
if (!S_ISDIR(inode->i_mode)) {
|
|
|
|
if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
|
|
|
|
goto out;
|
|
|
|
inode = parent->d_inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (1) {
|
2013-09-11 15:36:30 +02:00
|
|
|
/*
|
|
|
|
* If we are logging a directory then we start with our inode,
|
|
|
|
* not our parents inode, so we need to skipp setting the
|
|
|
|
* logged_trans so that further down in the log code we don't
|
|
|
|
* think this inode has already been logged.
|
|
|
|
*/
|
|
|
|
if (inode != orig_inode)
|
|
|
|
BTRFS_I(inode)->logged_trans = trans->transid;
|
2009-03-24 15:24:20 +01:00
|
|
|
smp_mb();
|
|
|
|
|
|
|
|
if (BTRFS_I(inode)->last_unlink_trans > last_committed) {
|
|
|
|
root = BTRFS_I(inode)->root;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* make sure any commits to the log are forced
|
|
|
|
* to be full commits
|
|
|
|
*/
|
2014-04-02 13:51:06 +02:00
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
2009-03-24 15:24:20 +01:00
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
|
|
|
|
break;
|
|
|
|
|
2009-09-21 22:00:26 +02:00
|
|
|
if (IS_ROOT(parent))
|
2009-03-24 15:24:20 +01:00
|
|
|
break;
|
|
|
|
|
2010-11-20 10:48:00 +01:00
|
|
|
parent = dget_parent(parent);
|
|
|
|
dput(old_parent);
|
|
|
|
old_parent = parent;
|
2009-03-24 15:24:20 +01:00
|
|
|
inode = parent->d_inode;
|
|
|
|
|
|
|
|
}
|
2010-11-20 10:48:00 +01:00
|
|
|
dput(old_parent);
|
2009-03-24 15:24:20 +01:00
|
|
|
out:
|
2008-09-05 22:13:11 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function around btrfs_log_inode to make sure newly created
|
|
|
|
* parent directories also end up in the log. A minimal inode and backref
|
|
|
|
* only logging is done of any parent directories that are older than
|
|
|
|
* the last committed transaction
|
|
|
|
*/
|
2013-04-25 22:41:01 +02:00
|
|
|
static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, struct inode *inode,
|
2014-09-06 23:34:39 +02:00
|
|
|
struct dentry *parent,
|
|
|
|
const loff_t start,
|
|
|
|
const loff_t end,
|
|
|
|
int exists_only,
|
2014-02-20 11:08:58 +01:00
|
|
|
struct btrfs_log_ctx *ctx)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
2009-03-24 15:24:20 +01:00
|
|
|
int inode_only = exists_only ? LOG_INODE_EXISTS : LOG_INODE_ALL;
|
2008-09-05 22:13:11 +02:00
|
|
|
struct super_block *sb;
|
2010-11-20 10:48:00 +01:00
|
|
|
struct dentry *old_parent = NULL;
|
2009-03-24 15:24:20 +01:00
|
|
|
int ret = 0;
|
|
|
|
u64 last_committed = root->fs_info->last_trans_committed;
|
Btrfs: fix directory inconsistency after fsync log replay
If we have an inode (file) with a link count greater than 1, remove
one of its hard links, fsync the inode, power fail/crash and then
replay the fsync log on the next mount, we end up getting the parent
directory's metadata inconsistent - its i_size still reflects the
deleted hard link and has dangling index entries (with no matching
inode reference entries). This prevents the directory from ever being
deletable, as its i_size can never decrease to BTRFS_EMPTY_DIR_SIZE
even if all of its children inodes are deleted, and the dangling index
entries can never be removed (as they point to an inode that does not
exist anymore).
This is easy to reproduce with the following excerpt from the test case
for xfstests that I just made:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 2 hard links in the same directory.
mkdir -p $SCRATCH_MNT/a/b
echo "hello world" > $SCRATCH_MNT/a/b/foo
ln $SCRATCH_MNT/a/b/foo $SCRATCH_MNT/a/b/bar
# Make sure all metadata and data are durably persisted.
sync
# Now remove one of the hard links and fsync the inode.
rm -f $SCRATCH_MNT/a/b/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/a/b/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Remove the last hard link of the file and attempt to remove its parent
# directory - this failed in btrfs because the fsync log and replay code
# didn't decrement the parent directory's i_size and left dangling directory
# index entries - this made the btrfs rmdir implementation always fail with
# the error -ENOTEMPTY.
#
# The dangling directory index entries were visible to user space, but it was
# impossible to do anything on them (unlink, open, read, write, stat, etc)
# because the inode they pointed to did not exist anymore.
#
# The parent directory's metadata inconsistency (stale index entries) was
# also detected by btrfs' fsck tool, which is run automatically by the fstests
# framework when the test finishes. The error message reported by fsck was:
#
# root 5 inode 259 errors 2001, no inode item, link count wrong
# unresolved ref dir 258 index 3 namelen 3 name bar filetype 1 errors 4, no inode ref
#
rm -f $SCRATCH_MNT/a/b/*
rmdir $SCRATCH_MNT/a/b
rmdir $SCRATCH_MNT/a
To fix this just make sure that after an unlink, if the inode is fsync'ed,
he parent inode is fully logged in the fsync log.
A test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-10 11:56:48 +01:00
|
|
|
const struct dentry * const first_parent = parent;
|
|
|
|
const bool did_unlink = (BTRFS_I(inode)->last_unlink_trans >
|
|
|
|
last_committed);
|
2009-03-24 15:24:20 +01:00
|
|
|
|
|
|
|
sb = inode->i_sb;
|
|
|
|
|
2009-04-02 22:49:40 +02:00
|
|
|
if (btrfs_test_opt(root, NOTREELOG)) {
|
|
|
|
ret = 1;
|
|
|
|
goto end_no_trans;
|
|
|
|
}
|
|
|
|
|
2014-04-02 13:51:06 +02:00
|
|
|
/*
|
|
|
|
* The prev transaction commit doesn't complete, we need do
|
|
|
|
* full commit by ourselves.
|
|
|
|
*/
|
2009-03-24 15:24:20 +01:00
|
|
|
if (root->fs_info->last_trans_log_full_commit >
|
|
|
|
root->fs_info->last_trans_committed) {
|
|
|
|
ret = 1;
|
|
|
|
goto end_no_trans;
|
|
|
|
}
|
|
|
|
|
2009-09-21 22:00:26 +02:00
|
|
|
if (root != BTRFS_I(inode)->root ||
|
|
|
|
btrfs_root_refs(&root->root_item) == 0) {
|
|
|
|
ret = 1;
|
|
|
|
goto end_no_trans;
|
|
|
|
}
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
ret = check_parent_dirs_for_sync(trans, inode, parent,
|
|
|
|
sb, last_committed);
|
|
|
|
if (ret)
|
|
|
|
goto end_no_trans;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2012-05-29 22:57:49 +02:00
|
|
|
if (btrfs_inode_in_log(inode, trans->transid)) {
|
2009-10-13 19:21:08 +02:00
|
|
|
ret = BTRFS_NO_LOG_SYNC;
|
|
|
|
goto end_no_trans;
|
|
|
|
}
|
|
|
|
|
2014-02-20 11:08:58 +01:00
|
|
|
ret = start_log_trans(trans, root, ctx);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret)
|
2014-02-20 11:08:53 +01:00
|
|
|
goto end_no_trans;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
ret = btrfs_log_inode(trans, root, inode, inode_only, start, end, ctx);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret)
|
|
|
|
goto end_trans;
|
2009-03-24 15:24:20 +01:00
|
|
|
|
2009-03-24 15:24:31 +01:00
|
|
|
/*
|
|
|
|
* for regular files, if its inode is already on disk, we don't
|
|
|
|
* have to worry about the parents at all. This is because
|
|
|
|
* we can use the last_unlink_trans field to record renames
|
|
|
|
* and other fun in this file.
|
|
|
|
*/
|
|
|
|
if (S_ISREG(inode->i_mode) &&
|
|
|
|
BTRFS_I(inode)->generation <= last_committed &&
|
2010-05-16 16:49:59 +02:00
|
|
|
BTRFS_I(inode)->last_unlink_trans <= last_committed) {
|
|
|
|
ret = 0;
|
|
|
|
goto end_trans;
|
|
|
|
}
|
2009-03-24 15:24:31 +01:00
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
while (1) {
|
|
|
|
if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
|
2008-09-05 22:13:11 +02:00
|
|
|
break;
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
inode = parent->d_inode;
|
2009-09-21 22:00:26 +02:00
|
|
|
if (root != BTRFS_I(inode)->root)
|
|
|
|
break;
|
|
|
|
|
Btrfs: fix directory inconsistency after fsync log replay
If we have an inode (file) with a link count greater than 1, remove
one of its hard links, fsync the inode, power fail/crash and then
replay the fsync log on the next mount, we end up getting the parent
directory's metadata inconsistent - its i_size still reflects the
deleted hard link and has dangling index entries (with no matching
inode reference entries). This prevents the directory from ever being
deletable, as its i_size can never decrease to BTRFS_EMPTY_DIR_SIZE
even if all of its children inodes are deleted, and the dangling index
entries can never be removed (as they point to an inode that does not
exist anymore).
This is easy to reproduce with the following excerpt from the test case
for xfstests that I just made:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 2 hard links in the same directory.
mkdir -p $SCRATCH_MNT/a/b
echo "hello world" > $SCRATCH_MNT/a/b/foo
ln $SCRATCH_MNT/a/b/foo $SCRATCH_MNT/a/b/bar
# Make sure all metadata and data are durably persisted.
sync
# Now remove one of the hard links and fsync the inode.
rm -f $SCRATCH_MNT/a/b/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/a/b/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Remove the last hard link of the file and attempt to remove its parent
# directory - this failed in btrfs because the fsync log and replay code
# didn't decrement the parent directory's i_size and left dangling directory
# index entries - this made the btrfs rmdir implementation always fail with
# the error -ENOTEMPTY.
#
# The dangling directory index entries were visible to user space, but it was
# impossible to do anything on them (unlink, open, read, write, stat, etc)
# because the inode they pointed to did not exist anymore.
#
# The parent directory's metadata inconsistency (stale index entries) was
# also detected by btrfs' fsck tool, which is run automatically by the fstests
# framework when the test finishes. The error message reported by fsck was:
#
# root 5 inode 259 errors 2001, no inode item, link count wrong
# unresolved ref dir 258 index 3 namelen 3 name bar filetype 1 errors 4, no inode ref
#
rm -f $SCRATCH_MNT/a/b/*
rmdir $SCRATCH_MNT/a/b
rmdir $SCRATCH_MNT/a
To fix this just make sure that after an unlink, if the inode is fsync'ed,
he parent inode is fully logged in the fsync log.
A test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-10 11:56:48 +01:00
|
|
|
/*
|
|
|
|
* On unlink we must make sure our immediate parent directory
|
|
|
|
* inode is fully logged. This is to prevent leaving dangling
|
|
|
|
* directory index entries and a wrong directory inode's i_size.
|
|
|
|
* Not doing so can result in a directory being impossible to
|
|
|
|
* delete after log replay (rmdir will always fail with error
|
|
|
|
* -ENOTEMPTY).
|
|
|
|
*/
|
|
|
|
if (did_unlink && parent == first_parent)
|
|
|
|
inode_only = LOG_INODE_ALL;
|
|
|
|
else
|
|
|
|
inode_only = LOG_INODE_EXISTS;
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
if (BTRFS_I(inode)->generation >
|
Btrfs: fix directory inconsistency after fsync log replay
If we have an inode (file) with a link count greater than 1, remove
one of its hard links, fsync the inode, power fail/crash and then
replay the fsync log on the next mount, we end up getting the parent
directory's metadata inconsistent - its i_size still reflects the
deleted hard link and has dangling index entries (with no matching
inode reference entries). This prevents the directory from ever being
deletable, as its i_size can never decrease to BTRFS_EMPTY_DIR_SIZE
even if all of its children inodes are deleted, and the dangling index
entries can never be removed (as they point to an inode that does not
exist anymore).
This is easy to reproduce with the following excerpt from the test case
for xfstests that I just made:
_scratch_mkfs >> $seqres.full 2>&1
_init_flakey
_mount_flakey
# Create a test file with 2 hard links in the same directory.
mkdir -p $SCRATCH_MNT/a/b
echo "hello world" > $SCRATCH_MNT/a/b/foo
ln $SCRATCH_MNT/a/b/foo $SCRATCH_MNT/a/b/bar
# Make sure all metadata and data are durably persisted.
sync
# Now remove one of the hard links and fsync the inode.
rm -f $SCRATCH_MNT/a/b/bar
$XFS_IO_PROG -c "fsync" $SCRATCH_MNT/a/b/foo
# Simulate a crash/power loss. This makes sure the next mount
# will see an fsync log and will replay that log.
_load_flakey_table $FLAKEY_DROP_WRITES
_unmount_flakey
_load_flakey_table $FLAKEY_ALLOW_WRITES
_mount_flakey
# Remove the last hard link of the file and attempt to remove its parent
# directory - this failed in btrfs because the fsync log and replay code
# didn't decrement the parent directory's i_size and left dangling directory
# index entries - this made the btrfs rmdir implementation always fail with
# the error -ENOTEMPTY.
#
# The dangling directory index entries were visible to user space, but it was
# impossible to do anything on them (unlink, open, read, write, stat, etc)
# because the inode they pointed to did not exist anymore.
#
# The parent directory's metadata inconsistency (stale index entries) was
# also detected by btrfs' fsck tool, which is run automatically by the fstests
# framework when the test finishes. The error message reported by fsck was:
#
# root 5 inode 259 errors 2001, no inode item, link count wrong
# unresolved ref dir 258 index 3 namelen 3 name bar filetype 1 errors 4, no inode ref
#
rm -f $SCRATCH_MNT/a/b/*
rmdir $SCRATCH_MNT/a/b
rmdir $SCRATCH_MNT/a
To fix this just make sure that after an unlink, if the inode is fsync'ed,
he parent inode is fully logged in the fsync log.
A test case for xfstests follows soon.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-01-10 11:56:48 +01:00
|
|
|
root->fs_info->last_trans_committed ||
|
|
|
|
inode_only == LOG_INODE_ALL) {
|
2014-09-06 23:34:39 +02:00
|
|
|
ret = btrfs_log_inode(trans, root, inode, inode_only,
|
Btrfs: fix data corruption after fast fsync and writeback error
When we do a fast fsync, we start all ordered operations and then while
they're running in parallel we visit the list of modified extent maps
and construct their matching file extent items and write them to the
log btree. After that, in btrfs_sync_log() we wait for all the ordered
operations to finish (via btrfs_wait_logged_extents).
The problem with this is that we were completely ignoring errors that
can happen in the extent write path, such as -ENOSPC, a temporary -ENOMEM
or -EIO errors for example. When such error happens, it means we have parts
of the on disk extent that weren't written to, and so we end up logging
file extent items that point to these extents that contain garbage/random
data - so after a crash/reboot plus log replay, we get our inode's metadata
pointing to those extents.
This worked in contrast with the full (non-fast) fsync path, where we
start all ordered operations, wait for them to finish and then write
to the log btree. In this path, after each ordered operation completes
we check if it's flagged with an error (BTRFS_ORDERED_IOERR) and return
-EIO if so (via btrfs_wait_ordered_range).
So if an error happens with any ordered operation, just return a -EIO
error to userspace, so that it knows that not all of its previous writes
were durably persisted and the application can take proper action (like
redo the writes for e.g.) - and definitely not leave any file extent items
in the log refer to non fully written extents.
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-09-05 16:14:39 +02:00
|
|
|
0, LLONG_MAX, ctx);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret)
|
|
|
|
goto end_trans;
|
2009-03-24 15:24:20 +01:00
|
|
|
}
|
2009-09-21 22:00:26 +02:00
|
|
|
if (IS_ROOT(parent))
|
2008-09-05 22:13:11 +02:00
|
|
|
break;
|
2009-03-24 15:24:20 +01:00
|
|
|
|
2010-11-20 10:48:00 +01:00
|
|
|
parent = dget_parent(parent);
|
|
|
|
dput(old_parent);
|
|
|
|
old_parent = parent;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2009-03-24 15:24:20 +01:00
|
|
|
ret = 0;
|
2010-05-16 16:49:59 +02:00
|
|
|
end_trans:
|
2010-11-20 10:48:00 +01:00
|
|
|
dput(old_parent);
|
2010-05-16 16:49:59 +02:00
|
|
|
if (ret < 0) {
|
2014-04-02 13:51:06 +02:00
|
|
|
btrfs_set_log_full_commit(root->fs_info, trans);
|
2010-05-16 16:49:59 +02:00
|
|
|
ret = 1;
|
|
|
|
}
|
2014-02-20 11:08:58 +01:00
|
|
|
|
|
|
|
if (ret)
|
|
|
|
btrfs_remove_log_ctx(root, ctx);
|
2009-03-24 15:24:20 +01:00
|
|
|
btrfs_end_log_trans(root);
|
|
|
|
end_no_trans:
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* it is not safe to log dentry if the chunk root has added new
|
|
|
|
* chunks. This returns 0 if the dentry was logged, and 1 otherwise.
|
|
|
|
* If this returns 1, you must commit the transaction to safely get your
|
|
|
|
* data on disk.
|
|
|
|
*/
|
|
|
|
int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
|
2014-02-20 11:08:58 +01:00
|
|
|
struct btrfs_root *root, struct dentry *dentry,
|
2014-09-06 23:34:39 +02:00
|
|
|
const loff_t start,
|
|
|
|
const loff_t end,
|
2014-02-20 11:08:58 +01:00
|
|
|
struct btrfs_log_ctx *ctx)
|
2008-09-05 22:13:11 +02:00
|
|
|
{
|
2010-11-20 10:48:00 +01:00
|
|
|
struct dentry *parent = dget_parent(dentry);
|
|
|
|
int ret;
|
|
|
|
|
2014-02-20 11:08:58 +01:00
|
|
|
ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent,
|
2014-09-06 23:34:39 +02:00
|
|
|
start, end, 0, ctx);
|
2010-11-20 10:48:00 +01:00
|
|
|
dput(parent);
|
|
|
|
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* should be called during mount to recover any replay any log trees
|
|
|
|
* from the FS
|
|
|
|
*/
|
|
|
|
int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
struct btrfs_key tmp_key;
|
|
|
|
struct btrfs_root *log;
|
|
|
|
struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
|
|
|
|
struct walk_control wc = {
|
|
|
|
.process_func = process_one_buffer,
|
|
|
|
.stage = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2011-03-23 09:14:16 +01:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
fs_info->log_root_recovering = 1;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2010-05-16 16:49:59 +02:00
|
|
|
trans = btrfs_start_transaction(fs_info->tree_root, 0);
|
2012-03-12 16:03:00 +01:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
goto error;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
wc.trans = trans;
|
|
|
|
wc.pin = 1;
|
|
|
|
|
2011-03-23 09:14:16 +01:00
|
|
|
ret = walk_log_tree(trans, log_root_tree, &wc);
|
2012-03-12 16:03:00 +01:00
|
|
|
if (ret) {
|
|
|
|
btrfs_error(fs_info, ret, "Failed to pin buffers while "
|
|
|
|
"recovering log root tree.");
|
|
|
|
goto error;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
again:
|
|
|
|
key.objectid = BTRFS_TREE_LOG_OBJECTID;
|
|
|
|
key.offset = (u64)-1;
|
2014-06-04 18:41:45 +02:00
|
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
|
2012-03-12 16:03:00 +01:00
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
btrfs_error(fs_info, ret,
|
|
|
|
"Couldn't find tree log root.");
|
|
|
|
goto error;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
if (ret > 0) {
|
|
|
|
if (path->slots[0] == 0)
|
|
|
|
break;
|
|
|
|
path->slots[0]--;
|
|
|
|
}
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &found_key,
|
|
|
|
path->slots[0]);
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
if (found_key.objectid != BTRFS_TREE_LOG_OBJECTID)
|
|
|
|
break;
|
|
|
|
|
2013-05-15 09:48:19 +02:00
|
|
|
log = btrfs_read_fs_root(log_root_tree, &found_key);
|
2012-03-12 16:03:00 +01:00
|
|
|
if (IS_ERR(log)) {
|
|
|
|
ret = PTR_ERR(log);
|
|
|
|
btrfs_error(fs_info, ret,
|
|
|
|
"Couldn't read tree log root.");
|
|
|
|
goto error;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
tmp_key.objectid = found_key.offset;
|
|
|
|
tmp_key.type = BTRFS_ROOT_ITEM_KEY;
|
|
|
|
tmp_key.offset = (u64)-1;
|
|
|
|
|
|
|
|
wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key);
|
2012-03-12 16:03:00 +01:00
|
|
|
if (IS_ERR(wc.replay_dest)) {
|
|
|
|
ret = PTR_ERR(wc.replay_dest);
|
2013-04-25 21:55:30 +02:00
|
|
|
free_extent_buffer(log->node);
|
|
|
|
free_extent_buffer(log->commit_root);
|
|
|
|
kfree(log);
|
2012-03-12 16:03:00 +01:00
|
|
|
btrfs_error(fs_info, ret, "Couldn't read target root "
|
|
|
|
"for tree log recovery.");
|
|
|
|
goto error;
|
|
|
|
}
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2009-01-06 17:42:00 +01:00
|
|
|
wc.replay_dest->log_root = log;
|
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 16:45:14 +02:00
|
|
|
btrfs_record_root_in_trans(trans, wc.replay_dest);
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = walk_log_tree(trans, log, &wc);
|
|
|
|
|
2013-04-25 21:55:30 +02:00
|
|
|
if (!ret && wc.stage == LOG_WALK_REPLAY_ALL) {
|
2008-09-05 22:13:11 +02:00
|
|
|
ret = fixup_inode_link_counts(trans, wc.replay_dest,
|
|
|
|
path);
|
|
|
|
}
|
|
|
|
|
|
|
|
key.offset = found_key.offset - 1;
|
2009-01-06 17:42:00 +01:00
|
|
|
wc.replay_dest->log_root = NULL;
|
2008-09-05 22:13:11 +02:00
|
|
|
free_extent_buffer(log->node);
|
2009-06-11 17:24:47 +02:00
|
|
|
free_extent_buffer(log->commit_root);
|
2008-09-05 22:13:11 +02:00
|
|
|
kfree(log);
|
|
|
|
|
2013-04-25 21:55:30 +02:00
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
if (found_key.offset == 0)
|
|
|
|
break;
|
|
|
|
}
|
2011-04-21 01:20:15 +02:00
|
|
|
btrfs_release_path(path);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
/* step one is to pin it all, step two is to replay just inodes */
|
|
|
|
if (wc.pin) {
|
|
|
|
wc.pin = 0;
|
|
|
|
wc.process_func = replay_one_buffer;
|
|
|
|
wc.stage = LOG_WALK_REPLAY_INODES;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
/* step three is to replay everything */
|
|
|
|
if (wc.stage < LOG_WALK_REPLAY_ALL) {
|
|
|
|
wc.stage++;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
2013-04-24 22:40:05 +02:00
|
|
|
/* step 4: commit the transaction, which also unpins the blocks */
|
|
|
|
ret = btrfs_commit_transaction(trans, fs_info->tree_root);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
free_extent_buffer(log_root_tree->node);
|
|
|
|
log_root_tree->log_root = NULL;
|
|
|
|
fs_info->log_root_recovering = 0;
|
|
|
|
kfree(log_root_tree);
|
2012-03-12 16:03:00 +01:00
|
|
|
|
2013-04-24 22:40:05 +02:00
|
|
|
return 0;
|
2012-03-12 16:03:00 +01:00
|
|
|
error:
|
2013-04-25 21:55:30 +02:00
|
|
|
if (wc.trans)
|
|
|
|
btrfs_end_transaction(wc.trans, fs_info->tree_root);
|
2012-03-12 16:03:00 +01:00
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
2008-09-05 22:13:11 +02:00
|
|
|
}
|
2009-03-24 15:24:20 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* there are some corner cases where we want to force a full
|
|
|
|
* commit instead of allowing a directory to be logged.
|
|
|
|
*
|
|
|
|
* They revolve around files there were unlinked from the directory, and
|
|
|
|
* this function updates the parent directory so that a full commit is
|
|
|
|
* properly done if it is fsync'd later after the unlinks are done.
|
|
|
|
*/
|
|
|
|
void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *dir, struct inode *inode,
|
|
|
|
int for_rename)
|
|
|
|
{
|
2009-03-24 15:24:31 +01:00
|
|
|
/*
|
|
|
|
* when we're logging a file, if it hasn't been renamed
|
|
|
|
* or unlinked, and its inode is fully committed on disk,
|
|
|
|
* we don't have to worry about walking up the directory chain
|
|
|
|
* to log its parents.
|
|
|
|
*
|
|
|
|
* So, we use the last_unlink_trans field to put this transid
|
|
|
|
* into the file. When the file is logged we check it and
|
|
|
|
* don't log the parents if the file is fully on disk.
|
|
|
|
*/
|
|
|
|
if (S_ISREG(inode->i_mode))
|
|
|
|
BTRFS_I(inode)->last_unlink_trans = trans->transid;
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
/*
|
|
|
|
* if this directory was already logged any new
|
|
|
|
* names for this file/dir will get recorded
|
|
|
|
*/
|
|
|
|
smp_mb();
|
|
|
|
if (BTRFS_I(dir)->logged_trans == trans->transid)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if the inode we're about to unlink was logged,
|
|
|
|
* the log will be properly updated for any new names
|
|
|
|
*/
|
|
|
|
if (BTRFS_I(inode)->logged_trans == trans->transid)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* when renaming files across directories, if the directory
|
|
|
|
* there we're unlinking from gets fsync'd later on, there's
|
|
|
|
* no way to find the destination directory later and fsync it
|
|
|
|
* properly. So, we have to be conservative and force commits
|
|
|
|
* so the new name gets discovered.
|
|
|
|
*/
|
|
|
|
if (for_rename)
|
|
|
|
goto record;
|
|
|
|
|
|
|
|
/* we can safely do the unlink without any special recording */
|
|
|
|
return;
|
|
|
|
|
|
|
|
record:
|
|
|
|
BTRFS_I(dir)->last_unlink_trans = trans->transid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call this after adding a new name for a file and it will properly
|
|
|
|
* update the log to reflect the new name.
|
|
|
|
*
|
|
|
|
* It will return zero if all goes well, and it will return 1 if a
|
|
|
|
* full transaction commit is required.
|
|
|
|
*/
|
|
|
|
int btrfs_log_new_name(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *inode, struct inode *old_dir,
|
|
|
|
struct dentry *parent)
|
|
|
|
{
|
|
|
|
struct btrfs_root * root = BTRFS_I(inode)->root;
|
|
|
|
|
2009-03-24 15:24:31 +01:00
|
|
|
/*
|
|
|
|
* this will force the logging code to walk the dentry chain
|
|
|
|
* up for the file
|
|
|
|
*/
|
|
|
|
if (S_ISREG(inode->i_mode))
|
|
|
|
BTRFS_I(inode)->last_unlink_trans = trans->transid;
|
|
|
|
|
2009-03-24 15:24:20 +01:00
|
|
|
/*
|
|
|
|
* if this inode hasn't been logged and directory we're renaming it
|
|
|
|
* from hasn't been logged, we don't need to log it
|
|
|
|
*/
|
|
|
|
if (BTRFS_I(inode)->logged_trans <=
|
|
|
|
root->fs_info->last_trans_committed &&
|
|
|
|
(!old_dir || BTRFS_I(old_dir)->logged_trans <=
|
|
|
|
root->fs_info->last_trans_committed))
|
|
|
|
return 0;
|
|
|
|
|
2014-09-06 23:34:39 +02:00
|
|
|
return btrfs_log_inode_parent(trans, root, inode, parent, 0,
|
|
|
|
LLONG_MAX, 1, NULL);
|
2009-03-24 15:24:20 +01:00
|
|
|
}
|
|
|
|
|