2007-06-12 20:07:21 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2008-01-09 03:46:30 +07:00
|
|
|
#ifndef __BTRFS_TRANSACTION__
|
|
|
|
#define __BTRFS_TRANSACTION__
|
2007-05-01 02:25:45 +07:00
|
|
|
#include "btrfs_inode.h"
|
2009-03-13 21:10:06 +07:00
|
|
|
#include "delayed-ref.h"
|
2012-06-28 23:03:02 +07:00
|
|
|
#include "ctree.h"
|
2007-03-17 03:20:31 +07:00
|
|
|
|
Btrfs: make the state of the transaction more readable
We used 3 variants to track the state of the transaction, it was complex
and wasted the memory space. Besides that, it was hard to understand that
which types of the transaction handles should be blocked in each transaction
state, so the developers often made mistakes.
This patch improved the above problem. In this patch, we define 6 states
for the transaction,
enum btrfs_trans_state {
TRANS_STATE_RUNNING = 0,
TRANS_STATE_BLOCKED = 1,
TRANS_STATE_COMMIT_START = 2,
TRANS_STATE_COMMIT_DOING = 3,
TRANS_STATE_UNBLOCKED = 4,
TRANS_STATE_COMPLETED = 5,
TRANS_STATE_MAX = 6,
}
and just use 1 variant to track those state.
In order to make the blocked handle types for each state more clear,
we introduce a array:
unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
[TRANS_STATE_RUNNING] = 0U,
[TRANS_STATE_BLOCKED] = (__TRANS_USERSPACE |
__TRANS_START),
[TRANS_STATE_COMMIT_START] = (__TRANS_USERSPACE |
__TRANS_START |
__TRANS_ATTACH),
[TRANS_STATE_COMMIT_DOING] = (__TRANS_USERSPACE |
__TRANS_START |
__TRANS_ATTACH |
__TRANS_JOIN),
[TRANS_STATE_UNBLOCKED] = (__TRANS_USERSPACE |
__TRANS_START |
__TRANS_ATTACH |
__TRANS_JOIN |
__TRANS_JOIN_NOLOCK),
[TRANS_STATE_COMPLETED] = (__TRANS_USERSPACE |
__TRANS_START |
__TRANS_ATTACH |
__TRANS_JOIN |
__TRANS_JOIN_NOLOCK),
}
it is very intuitionistic.
Besides that, because we remove ->in_commit in transaction structure, so
the lock ->commit_lock which was used to protect it is unnecessary, remove
->commit_lock.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2013-05-17 10:53:43 +07:00
|
|
|
enum btrfs_trans_state {
|
|
|
|
TRANS_STATE_RUNNING = 0,
|
|
|
|
TRANS_STATE_BLOCKED = 1,
|
|
|
|
TRANS_STATE_COMMIT_START = 2,
|
|
|
|
TRANS_STATE_COMMIT_DOING = 3,
|
|
|
|
TRANS_STATE_UNBLOCKED = 4,
|
|
|
|
TRANS_STATE_COMPLETED = 5,
|
|
|
|
TRANS_STATE_MAX = 6,
|
|
|
|
};
|
|
|
|
|
2007-03-23 02:59:16 +07:00
|
|
|
struct btrfs_transaction {
|
|
|
|
u64 transid;
|
2013-05-15 14:48:27 +07:00
|
|
|
/*
|
|
|
|
* total external writers(USERSPACE/START/ATTACH) in this
|
|
|
|
* transaction, it must be zero before the transaction is
|
|
|
|
* being committed
|
|
|
|
*/
|
|
|
|
atomic_t num_extwriters;
|
2009-03-13 07:12:45 +07:00
|
|
|
/*
|
|
|
|
* total writers in this transaction, it must be zero before the
|
|
|
|
* transaction can end
|
|
|
|
*/
|
2011-04-12 02:45:29 +07:00
|
|
|
atomic_t num_writers;
|
2011-04-12 04:25:13 +07:00
|
|
|
atomic_t use_count;
|
2009-03-13 07:12:45 +07:00
|
|
|
|
Btrfs: make the state of the transaction more readable
We used 3 variants to track the state of the transaction, it was complex
and wasted the memory space. Besides that, it was hard to understand that
which types of the transaction handles should be blocked in each transaction
state, so the developers often made mistakes.
This patch improved the above problem. In this patch, we define 6 states
for the transaction,
enum btrfs_trans_state {
TRANS_STATE_RUNNING = 0,
TRANS_STATE_BLOCKED = 1,
TRANS_STATE_COMMIT_START = 2,
TRANS_STATE_COMMIT_DOING = 3,
TRANS_STATE_UNBLOCKED = 4,
TRANS_STATE_COMPLETED = 5,
TRANS_STATE_MAX = 6,
}
and just use 1 variant to track those state.
In order to make the blocked handle types for each state more clear,
we introduce a array:
unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
[TRANS_STATE_RUNNING] = 0U,
[TRANS_STATE_BLOCKED] = (__TRANS_USERSPACE |
__TRANS_START),
[TRANS_STATE_COMMIT_START] = (__TRANS_USERSPACE |
__TRANS_START |
__TRANS_ATTACH),
[TRANS_STATE_COMMIT_DOING] = (__TRANS_USERSPACE |
__TRANS_START |
__TRANS_ATTACH |
__TRANS_JOIN),
[TRANS_STATE_UNBLOCKED] = (__TRANS_USERSPACE |
__TRANS_START |
__TRANS_ATTACH |
__TRANS_JOIN |
__TRANS_JOIN_NOLOCK),
[TRANS_STATE_COMPLETED] = (__TRANS_USERSPACE |
__TRANS_START |
__TRANS_ATTACH |
__TRANS_JOIN |
__TRANS_JOIN_NOLOCK),
}
it is very intuitionistic.
Besides that, because we remove ->in_commit in transaction structure, so
the lock ->commit_lock which was used to protect it is unnecessary, remove
->commit_lock.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2013-05-17 10:53:43 +07:00
|
|
|
/* Be protected by fs_info->trans_lock when we want to change it. */
|
|
|
|
enum btrfs_trans_state state;
|
2007-04-20 08:01:03 +07:00
|
|
|
struct list_head list;
|
2008-01-25 04:13:08 +07:00
|
|
|
struct extent_io_tree dirty_pages;
|
2007-06-09 02:33:54 +07:00
|
|
|
unsigned long start_time;
|
2007-03-23 02:59:16 +07:00
|
|
|
wait_queue_head_t writer_wait;
|
|
|
|
wait_queue_head_t commit_wait;
|
2008-01-09 03:46:30 +07:00
|
|
|
struct list_head pending_snapshots;
|
2013-06-28 00:22:46 +07:00
|
|
|
struct list_head pending_chunks;
|
2014-03-14 02:42:13 +07:00
|
|
|
struct list_head switch_commits;
|
2009-03-13 21:10:06 +07:00
|
|
|
struct btrfs_delayed_ref_root delayed_refs;
|
2012-03-01 23:24:58 +07:00
|
|
|
int aborted;
|
2007-03-23 02:59:16 +07:00
|
|
|
};
|
|
|
|
|
2013-05-15 14:48:27 +07:00
|
|
|
#define __TRANS_FREEZABLE (1U << 0)
|
|
|
|
|
|
|
|
#define __TRANS_USERSPACE (1U << 8)
|
|
|
|
#define __TRANS_START (1U << 9)
|
|
|
|
#define __TRANS_ATTACH (1U << 10)
|
|
|
|
#define __TRANS_JOIN (1U << 11)
|
|
|
|
#define __TRANS_JOIN_NOLOCK (1U << 12)
|
2014-05-08 04:06:09 +07:00
|
|
|
#define __TRANS_DUMMY (1U << 13)
|
2013-05-15 14:48:27 +07:00
|
|
|
|
|
|
|
#define TRANS_USERSPACE (__TRANS_USERSPACE | __TRANS_FREEZABLE)
|
|
|
|
#define TRANS_START (__TRANS_START | __TRANS_FREEZABLE)
|
|
|
|
#define TRANS_ATTACH (__TRANS_ATTACH)
|
|
|
|
#define TRANS_JOIN (__TRANS_JOIN | __TRANS_FREEZABLE)
|
|
|
|
#define TRANS_JOIN_NOLOCK (__TRANS_JOIN_NOLOCK)
|
|
|
|
|
|
|
|
#define TRANS_EXTWRITERS (__TRANS_USERSPACE | __TRANS_START | \
|
|
|
|
__TRANS_ATTACH)
|
2012-09-20 14:51:59 +07:00
|
|
|
|
2014-03-29 04:07:27 +07:00
|
|
|
#define BTRFS_SEND_TRANS_STUB 1
|
|
|
|
|
2007-03-17 03:20:31 +07:00
|
|
|
struct btrfs_trans_handle {
|
|
|
|
u64 transid;
|
2010-05-16 21:46:25 +07:00
|
|
|
u64 bytes_reserved;
|
2011-09-14 20:44:05 +07:00
|
|
|
u64 qgroup_reserved;
|
2011-04-14 02:15:59 +07:00
|
|
|
unsigned long use_count;
|
2007-03-17 03:20:31 +07:00
|
|
|
unsigned long blocks_reserved;
|
|
|
|
unsigned long blocks_used;
|
2009-03-13 21:10:06 +07:00
|
|
|
unsigned long delayed_ref_updates;
|
2010-05-16 21:46:25 +07:00
|
|
|
struct btrfs_transaction *transaction;
|
|
|
|
struct btrfs_block_rsv *block_rsv;
|
2011-04-14 02:15:59 +07:00
|
|
|
struct btrfs_block_rsv *orig_rsv;
|
2012-09-20 14:51:59 +07:00
|
|
|
short aborted;
|
|
|
|
short adding_csums;
|
2012-12-18 21:16:16 +07:00
|
|
|
bool allocating_chunk;
|
2013-09-25 20:47:45 +07:00
|
|
|
bool reloc_reserved;
|
2014-01-16 01:34:13 +07:00
|
|
|
bool sync;
|
2013-05-15 14:48:27 +07:00
|
|
|
unsigned int type;
|
2011-09-13 16:40:09 +07:00
|
|
|
/*
|
|
|
|
* this root is only needed to validate that the root passed to
|
|
|
|
* start_transaction is the same as the one passed to end_transaction.
|
|
|
|
* Subvolume quota depends on this
|
|
|
|
*/
|
|
|
|
struct btrfs_root *root;
|
2012-06-28 23:03:02 +07:00
|
|
|
struct seq_list delayed_ref_elem;
|
|
|
|
struct list_head qgroup_ref_list;
|
2012-09-12 03:57:25 +07:00
|
|
|
struct list_head new_bgs;
|
2007-03-17 03:20:31 +07:00
|
|
|
};
|
|
|
|
|
2008-01-09 03:46:30 +07:00
|
|
|
struct btrfs_pending_snapshot {
|
2008-11-18 09:02:50 +07:00
|
|
|
struct dentry *dentry;
|
2013-02-28 17:01:15 +07:00
|
|
|
struct inode *dir;
|
2008-01-09 03:46:30 +07:00
|
|
|
struct btrfs_root *root;
|
2010-05-16 21:48:46 +07:00
|
|
|
struct btrfs_root *snap;
|
2011-09-14 20:58:21 +07:00
|
|
|
struct btrfs_qgroup_inherit *inherit;
|
2010-05-16 21:48:46 +07:00
|
|
|
/* block reservation for the operation */
|
|
|
|
struct btrfs_block_rsv block_rsv;
|
2013-02-28 17:04:33 +07:00
|
|
|
u64 qgroup_reserved;
|
2010-05-16 21:48:46 +07:00
|
|
|
/* extra metadata reseration for relocation */
|
|
|
|
int error;
|
2010-12-20 15:04:08 +07:00
|
|
|
bool readonly;
|
2008-01-09 03:46:30 +07:00
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
2007-08-11 03:22:09 +07:00
|
|
|
static inline void btrfs_set_inode_last_trans(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
|
|
|
BTRFS_I(inode)->last_trans = trans->transaction->transid;
|
2009-10-14 00:21:08 +07:00
|
|
|
BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
|
2012-08-29 14:07:55 +07:00
|
|
|
BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
|
2007-08-11 03:22:09 +07:00
|
|
|
}
|
|
|
|
|
2007-03-23 02:59:16 +07:00
|
|
|
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root);
|
|
|
|
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
|
2010-05-16 21:48:46 +07:00
|
|
|
int num_items);
|
Btrfs: improve the noflush reservation
In some places(such as: evicting inode), we just can not flush the reserved
space of delalloc, flushing the delayed directory index and delayed inode
is OK, but we don't try to flush those things and just go back when there is
no enough space to be reserved. This patch fixes this problem.
We defined 3 types of the flush operations: NO_FLUSH, FLUSH_LIMIT and FLUSH_ALL.
If we can in the transaction, we should not flush anything, or the deadlock
would happen, so use NO_FLUSH. If we flushing the reserved space of delalloc
would cause deadlock, use FLUSH_LIMIT. In the other cases, FLUSH_ALL is used,
and we will flush all things.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2012-10-16 18:33:38 +07:00
|
|
|
struct btrfs_trans_handle *btrfs_start_transaction_lflush(
|
Btrfs: fix corrupted metadata in the snapshot
When we delete a inode, we will remove all the delayed items including delayed
inode update, and then truncate all the relative metadata. If there is lots of
metadata, we will end the current transaction, and start a new transaction to
truncate the left metadata. In this way, we will leave a inode item that its
link counter is > 0, and also may leave some directory index items in fs/file tree
after the current transaction ends. In other words, the metadata in this fs/file tree
is inconsistent. If we create a snapshot for this tree now, we will find a inode with
corrupted metadata in the new snapshot, and we won't continue to drop the left metadata,
because its link counter is not 0.
We fix this problem by updating the inode item before the current transaction ends.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-07 14:43:32 +07:00
|
|
|
struct btrfs_root *root, int num_items);
|
2011-04-13 23:54:33 +07:00
|
|
|
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root);
|
|
|
|
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root);
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 14:54:00 +07:00
|
|
|
struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root);
|
Btrfs: fix uncompleted transaction
In some cases, we need commit the current transaction, but don't want
to start a new one if there is no running transaction, so we introduce
the function - btrfs_attach_transaction(), which can catch the current
transaction, and return -ENOENT if there is no running transaction.
But no running transaction doesn't mean the current transction completely,
because we removed the running transaction before it completes. In some
cases, it doesn't matter. But in some special cases, such as freeze fs, we
hope the transaction is fully on disk, it will introduce some bugs, for
example, we may feeze the fs and dump the data in the disk, if the transction
doesn't complete, we would dump inconsistent data. So we need fix the above
problem for those cases.
We fixes this problem by introducing a function:
btrfs_attach_transaction_barrier()
if we hope all the transaction is fully on the disk, even they are not
running, we can use this function.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
2013-02-20 16:17:06 +07:00
|
|
|
struct btrfs_trans_handle *btrfs_attach_transaction_barrier(
|
|
|
|
struct btrfs_root *root);
|
2011-04-13 23:54:33 +07:00
|
|
|
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root);
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 02:41:32 +07:00
|
|
|
int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid);
|
2007-03-23 02:59:16 +07:00
|
|
|
int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root);
|
2007-06-09 02:33:54 +07:00
|
|
|
|
2013-07-26 02:11:47 +07:00
|
|
|
void btrfs_add_dead_root(struct btrfs_root *root);
|
2013-02-01 01:21:12 +07:00
|
|
|
int btrfs_defrag_root(struct btrfs_root *root);
|
2013-03-12 22:13:28 +07:00
|
|
|
int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root);
|
2007-10-16 03:14:19 +07:00
|
|
|
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root);
|
2010-10-30 02:37:34 +07:00
|
|
|
int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
int wait_for_unblock);
|
2008-06-26 03:01:31 +07:00
|
|
|
int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root);
|
2010-05-16 21:49:58 +07:00
|
|
|
int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root);
|
2008-07-30 03:15:18 +07:00
|
|
|
void btrfs_throttle(struct btrfs_root *root);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 21:45:14 +07:00
|
|
|
int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root);
|
2009-10-14 00:29:19 +07:00
|
|
|
int btrfs_write_marked_extents(struct btrfs_root *root,
|
2009-11-12 16:33:26 +07:00
|
|
|
struct extent_io_tree *dirty_pages, int mark);
|
2009-10-14 00:29:19 +07:00
|
|
|
int btrfs_wait_marked_extents(struct btrfs_root *root,
|
2009-11-12 16:33:26 +07:00
|
|
|
struct extent_io_tree *dirty_pages, int mark);
|
2010-05-16 21:49:58 +07:00
|
|
|
int btrfs_transaction_blocked(struct btrfs_fs_info *info);
|
2009-07-30 21:04:48 +07:00
|
|
|
int btrfs_transaction_in_commit(struct btrfs_fs_info *info);
|
2013-09-30 22:36:38 +07:00
|
|
|
void btrfs_put_transaction(struct btrfs_transaction *transaction);
|
2007-03-17 03:20:31 +07:00
|
|
|
#endif
|