2014-05-13 18:30:47 -06:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2014 Facebook. 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __BTRFS_QGROUP__
|
|
|
|
#define __BTRFS_QGROUP__
|
|
|
|
|
2015-04-16 00:34:17 -06:00
|
|
|
#include "ulist.h"
|
|
|
|
#include "delayed-ref.h"
|
|
|
|
|
2016-10-17 19:31:26 -06:00
|
|
|
/*
|
|
|
|
* Btrfs qgroup overview
|
|
|
|
*
|
|
|
|
* Btrfs qgroup splits into 3 main part:
|
|
|
|
* 1) Reserve
|
|
|
|
* Reserve metadata/data space for incoming operations
|
|
|
|
* Affect how qgroup limit works
|
|
|
|
*
|
|
|
|
* 2) Trace
|
|
|
|
* Tell btrfs qgroup to trace dirty extents.
|
|
|
|
*
|
|
|
|
* Dirty extents including:
|
|
|
|
* - Newly allocated extents
|
|
|
|
* - Extents going to be deleted (in this trans)
|
|
|
|
* - Extents whose owner is going to be modified
|
|
|
|
*
|
|
|
|
* This is the main part affects whether qgroup numbers will stay
|
|
|
|
* consistent.
|
|
|
|
* Btrfs qgroup can trace clean extents and won't cause any problem,
|
|
|
|
* but it will consume extra CPU time, it should be avoided if possible.
|
|
|
|
*
|
|
|
|
* 3) Account
|
|
|
|
* Btrfs qgroup will updates its numbers, based on dirty extents traced
|
|
|
|
* in previous step.
|
|
|
|
*
|
|
|
|
* Normally at qgroup rescan and transaction commit time.
|
|
|
|
*/
|
|
|
|
|
2015-04-16 00:34:17 -06:00
|
|
|
/*
|
|
|
|
* Record a dirty extent, and info qgroup to update quota on it
|
|
|
|
* TODO: Use kmem cache to alloc it.
|
|
|
|
*/
|
|
|
|
struct btrfs_qgroup_extent_record {
|
|
|
|
struct rb_node node;
|
|
|
|
u64 bytenr;
|
|
|
|
u64 num_bytes;
|
|
|
|
struct ulist *old_roots;
|
|
|
|
};
|
|
|
|
|
2015-09-28 02:57:53 -06:00
|
|
|
/*
|
|
|
|
* For qgroup event trace points only
|
|
|
|
*/
|
|
|
|
#define QGROUP_RESERVE (1<<0)
|
|
|
|
#define QGROUP_RELEASE (1<<1)
|
|
|
|
#define QGROUP_FREE (1<<2)
|
|
|
|
|
2014-05-13 18:30:47 -06:00
|
|
|
int btrfs_quota_enable(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info);
|
|
|
|
int btrfs_quota_disable(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info);
|
|
|
|
int btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info);
|
|
|
|
void btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info);
|
2016-08-08 20:08:06 -06:00
|
|
|
int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info,
|
|
|
|
bool interruptible);
|
2014-05-13 18:30:47 -06:00
|
|
|
int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 src, u64 dst);
|
|
|
|
int btrfs_del_qgroup_relation(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 src, u64 dst);
|
|
|
|
int btrfs_create_qgroup(struct btrfs_trans_handle *trans,
|
2015-01-18 08:59:23 -07:00
|
|
|
struct btrfs_fs_info *fs_info, u64 qgroupid);
|
2014-05-13 18:30:47 -06:00
|
|
|
int btrfs_remove_qgroup(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 qgroupid);
|
|
|
|
int btrfs_limit_qgroup(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 qgroupid,
|
|
|
|
struct btrfs_qgroup_limit *limit);
|
|
|
|
int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info);
|
|
|
|
void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info);
|
|
|
|
struct btrfs_delayed_extent_op;
|
2015-04-16 02:40:39 -06:00
|
|
|
int btrfs_qgroup_prepare_account_extents(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info);
|
btrfs: qgroup: Refactor btrfs_qgroup_insert_dirty_extent()
Refactor btrfs_qgroup_insert_dirty_extent() function, to two functions:
1. btrfs_qgroup_insert_dirty_extent_nolock()
Almost the same with original code.
For delayed_ref usage, which has delayed refs locked.
Change the return value type to int, since caller never needs the
pointer, but only needs to know if they need to free the allocated
memory.
2. btrfs_qgroup_insert_dirty_extent()
The more encapsulated version.
Will do the delayed_refs lock, memory allocation, quota enabled check
and other things.
The original design is to keep exported functions to minimal, but since
more btrfs hacks exposed, like replacing path in balance, we need to
record dirty extents manually, so we have to add such functions.
Also, add comment for both functions, to info developers how to keep
qgroup correct when doing hacks.
Cc: Mark Fasheh <mfasheh@suse.de>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-and-Tested-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-14 20:36:50 -06:00
|
|
|
/*
|
2016-10-17 19:31:27 -06:00
|
|
|
* Inform qgroup to trace one dirty extent, its info is recorded in @record.
|
2017-02-14 19:43:03 -07:00
|
|
|
* So qgroup can account it at transaction committing time.
|
btrfs: qgroup: Refactor btrfs_qgroup_insert_dirty_extent()
Refactor btrfs_qgroup_insert_dirty_extent() function, to two functions:
1. btrfs_qgroup_insert_dirty_extent_nolock()
Almost the same with original code.
For delayed_ref usage, which has delayed refs locked.
Change the return value type to int, since caller never needs the
pointer, but only needs to know if they need to free the allocated
memory.
2. btrfs_qgroup_insert_dirty_extent()
The more encapsulated version.
Will do the delayed_refs lock, memory allocation, quota enabled check
and other things.
The original design is to keep exported functions to minimal, but since
more btrfs hacks exposed, like replacing path in balance, we need to
record dirty extents manually, so we have to add such functions.
Also, add comment for both functions, to info developers how to keep
qgroup correct when doing hacks.
Cc: Mark Fasheh <mfasheh@suse.de>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-and-Tested-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-14 20:36:50 -06:00
|
|
|
*
|
2017-02-14 19:43:03 -07:00
|
|
|
* No lock version, caller must acquire delayed ref lock and allocated memory,
|
|
|
|
* then call btrfs_qgroup_trace_extent_post() after exiting lock context.
|
btrfs: qgroup: Refactor btrfs_qgroup_insert_dirty_extent()
Refactor btrfs_qgroup_insert_dirty_extent() function, to two functions:
1. btrfs_qgroup_insert_dirty_extent_nolock()
Almost the same with original code.
For delayed_ref usage, which has delayed refs locked.
Change the return value type to int, since caller never needs the
pointer, but only needs to know if they need to free the allocated
memory.
2. btrfs_qgroup_insert_dirty_extent()
The more encapsulated version.
Will do the delayed_refs lock, memory allocation, quota enabled check
and other things.
The original design is to keep exported functions to minimal, but since
more btrfs hacks exposed, like replacing path in balance, we need to
record dirty extents manually, so we have to add such functions.
Also, add comment for both functions, to info developers how to keep
qgroup correct when doing hacks.
Cc: Mark Fasheh <mfasheh@suse.de>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-and-Tested-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-14 20:36:50 -06:00
|
|
|
*
|
|
|
|
* Return 0 for success insert
|
|
|
|
* Return >0 for existing record, caller can free @record safely.
|
|
|
|
* Error is not possible
|
|
|
|
*/
|
2016-10-17 19:31:27 -06:00
|
|
|
int btrfs_qgroup_trace_extent_nolock(
|
btrfs: qgroup: Refactor btrfs_qgroup_insert_dirty_extent()
Refactor btrfs_qgroup_insert_dirty_extent() function, to two functions:
1. btrfs_qgroup_insert_dirty_extent_nolock()
Almost the same with original code.
For delayed_ref usage, which has delayed refs locked.
Change the return value type to int, since caller never needs the
pointer, but only needs to know if they need to free the allocated
memory.
2. btrfs_qgroup_insert_dirty_extent()
The more encapsulated version.
Will do the delayed_refs lock, memory allocation, quota enabled check
and other things.
The original design is to keep exported functions to minimal, but since
more btrfs hacks exposed, like replacing path in balance, we need to
record dirty extents manually, so we have to add such functions.
Also, add comment for both functions, to info developers how to keep
qgroup correct when doing hacks.
Cc: Mark Fasheh <mfasheh@suse.de>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-and-Tested-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-14 20:36:50 -06:00
|
|
|
struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_delayed_ref_root *delayed_refs,
|
|
|
|
struct btrfs_qgroup_extent_record *record);
|
|
|
|
|
2017-02-14 19:43:03 -07:00
|
|
|
/*
|
|
|
|
* Post handler after qgroup_trace_extent_nolock().
|
|
|
|
*
|
|
|
|
* NOTE: Current qgroup does the expensive backref walk at transaction
|
|
|
|
* committing time with TRANS_STATE_COMMIT_DOING, this blocks incoming
|
|
|
|
* new transaction.
|
|
|
|
* This is designed to allow btrfs_find_all_roots() to get correct new_roots
|
|
|
|
* result.
|
|
|
|
*
|
|
|
|
* However for old_roots there is no need to do backref walk at that time,
|
|
|
|
* since we search commit roots to walk backref and result will always be
|
|
|
|
* correct.
|
|
|
|
*
|
|
|
|
* Due to the nature of no lock version, we can't do backref there.
|
|
|
|
* So we must call btrfs_qgroup_trace_extent_post() after exiting
|
|
|
|
* spinlock context.
|
|
|
|
*
|
|
|
|
* TODO: If we can fix and prove btrfs_find_all_roots() can get correct result
|
|
|
|
* using current root, then we can move all expensive backref walk out of
|
|
|
|
* transaction committing, but not now as qgroup accounting will be wrong again.
|
|
|
|
*/
|
|
|
|
int btrfs_qgroup_trace_extent_post(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_qgroup_extent_record *qrecord);
|
|
|
|
|
btrfs: qgroup: Refactor btrfs_qgroup_insert_dirty_extent()
Refactor btrfs_qgroup_insert_dirty_extent() function, to two functions:
1. btrfs_qgroup_insert_dirty_extent_nolock()
Almost the same with original code.
For delayed_ref usage, which has delayed refs locked.
Change the return value type to int, since caller never needs the
pointer, but only needs to know if they need to free the allocated
memory.
2. btrfs_qgroup_insert_dirty_extent()
The more encapsulated version.
Will do the delayed_refs lock, memory allocation, quota enabled check
and other things.
The original design is to keep exported functions to minimal, but since
more btrfs hacks exposed, like replacing path in balance, we need to
record dirty extents manually, so we have to add such functions.
Also, add comment for both functions, to info developers how to keep
qgroup correct when doing hacks.
Cc: Mark Fasheh <mfasheh@suse.de>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-and-Tested-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-14 20:36:50 -06:00
|
|
|
/*
|
2016-10-17 19:31:27 -06:00
|
|
|
* Inform qgroup to trace one dirty extent, specified by @bytenr and
|
|
|
|
* @num_bytes.
|
|
|
|
* So qgroup can account it at commit trans time.
|
btrfs: qgroup: Refactor btrfs_qgroup_insert_dirty_extent()
Refactor btrfs_qgroup_insert_dirty_extent() function, to two functions:
1. btrfs_qgroup_insert_dirty_extent_nolock()
Almost the same with original code.
For delayed_ref usage, which has delayed refs locked.
Change the return value type to int, since caller never needs the
pointer, but only needs to know if they need to free the allocated
memory.
2. btrfs_qgroup_insert_dirty_extent()
The more encapsulated version.
Will do the delayed_refs lock, memory allocation, quota enabled check
and other things.
The original design is to keep exported functions to minimal, but since
more btrfs hacks exposed, like replacing path in balance, we need to
record dirty extents manually, so we have to add such functions.
Also, add comment for both functions, to info developers how to keep
qgroup correct when doing hacks.
Cc: Mark Fasheh <mfasheh@suse.de>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-and-Tested-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-14 20:36:50 -06:00
|
|
|
*
|
2017-02-14 19:43:03 -07:00
|
|
|
* Better encapsulated version, with memory allocation and backref walk for
|
|
|
|
* commit roots.
|
|
|
|
* So this can sleep.
|
btrfs: qgroup: Refactor btrfs_qgroup_insert_dirty_extent()
Refactor btrfs_qgroup_insert_dirty_extent() function, to two functions:
1. btrfs_qgroup_insert_dirty_extent_nolock()
Almost the same with original code.
For delayed_ref usage, which has delayed refs locked.
Change the return value type to int, since caller never needs the
pointer, but only needs to know if they need to free the allocated
memory.
2. btrfs_qgroup_insert_dirty_extent()
The more encapsulated version.
Will do the delayed_refs lock, memory allocation, quota enabled check
and other things.
The original design is to keep exported functions to minimal, but since
more btrfs hacks exposed, like replacing path in balance, we need to
record dirty extents manually, so we have to add such functions.
Also, add comment for both functions, to info developers how to keep
qgroup correct when doing hacks.
Cc: Mark Fasheh <mfasheh@suse.de>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-and-Tested-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-14 20:36:50 -06:00
|
|
|
*
|
|
|
|
* Return 0 if the operation is done.
|
|
|
|
* Return <0 for error, like memory allocation failure or invalid parameter
|
|
|
|
* (NULL trans)
|
|
|
|
*/
|
2016-10-17 19:31:27 -06:00
|
|
|
int btrfs_qgroup_trace_extent(struct btrfs_trans_handle *trans,
|
btrfs: qgroup: Refactor btrfs_qgroup_insert_dirty_extent()
Refactor btrfs_qgroup_insert_dirty_extent() function, to two functions:
1. btrfs_qgroup_insert_dirty_extent_nolock()
Almost the same with original code.
For delayed_ref usage, which has delayed refs locked.
Change the return value type to int, since caller never needs the
pointer, but only needs to know if they need to free the allocated
memory.
2. btrfs_qgroup_insert_dirty_extent()
The more encapsulated version.
Will do the delayed_refs lock, memory allocation, quota enabled check
and other things.
The original design is to keep exported functions to minimal, but since
more btrfs hacks exposed, like replacing path in balance, we need to
record dirty extents manually, so we have to add such functions.
Also, add comment for both functions, to info developers how to keep
qgroup correct when doing hacks.
Cc: Mark Fasheh <mfasheh@suse.de>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-and-Tested-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2016-08-14 20:36:50 -06:00
|
|
|
struct btrfs_fs_info *fs_info, u64 bytenr, u64 num_bytes,
|
|
|
|
gfp_t gfp_flag);
|
|
|
|
|
2016-10-17 19:31:28 -06:00
|
|
|
/*
|
|
|
|
* Inform qgroup to trace all leaf items of data
|
|
|
|
*
|
|
|
|
* Return 0 for success
|
|
|
|
* Return <0 for error(ENOMEM)
|
|
|
|
*/
|
|
|
|
int btrfs_qgroup_trace_leaf_items(struct btrfs_trans_handle *trans,
|
2016-06-22 16:54:24 -06:00
|
|
|
struct btrfs_fs_info *fs_info,
|
2016-10-17 19:31:28 -06:00
|
|
|
struct extent_buffer *eb);
|
|
|
|
/*
|
|
|
|
* Inform qgroup to trace a whole subtree, including all its child tree
|
|
|
|
* blocks and data.
|
|
|
|
* The root tree block is specified by @root_eb.
|
|
|
|
*
|
|
|
|
* Normally used by relocation(tree block swap) and subvolume deletion.
|
|
|
|
*
|
|
|
|
* Return 0 for success
|
|
|
|
* Return <0 for error(ENOMEM or tree search error)
|
|
|
|
*/
|
|
|
|
int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct extent_buffer *root_eb,
|
|
|
|
u64 root_gen, int root_level);
|
2015-04-16 03:18:36 -06:00
|
|
|
int
|
|
|
|
btrfs_qgroup_account_extent(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info,
|
|
|
|
u64 bytenr, u64 num_bytes,
|
|
|
|
struct ulist *old_roots, struct ulist *new_roots);
|
2015-04-16 01:37:33 -06:00
|
|
|
int btrfs_qgroup_account_extents(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info);
|
2014-05-13 18:30:47 -06:00
|
|
|
int btrfs_run_qgroups(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info);
|
|
|
|
int btrfs_qgroup_inherit(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 srcid, u64 objectid,
|
|
|
|
struct btrfs_qgroup_inherit *inherit);
|
2015-09-08 03:08:37 -06:00
|
|
|
void btrfs_qgroup_free_refroot(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 ref_root, u64 num_bytes);
|
|
|
|
/*
|
|
|
|
* TODO: Add proper trace point for it, as btrfs_qgroup_free() is
|
|
|
|
* called by everywhere, can't provide good trace for delayed ref case.
|
|
|
|
*/
|
|
|
|
static inline void btrfs_qgroup_free_delayed_ref(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 ref_root, u64 num_bytes)
|
|
|
|
{
|
|
|
|
btrfs_qgroup_free_refroot(fs_info, ref_root, num_bytes);
|
2016-06-09 15:27:55 -06:00
|
|
|
trace_btrfs_qgroup_free_delayed_ref(fs_info, ref_root, num_bytes);
|
2015-09-08 03:08:37 -06:00
|
|
|
}
|
2014-05-13 18:30:47 -06:00
|
|
|
void assert_qgroups_uptodate(struct btrfs_trans_handle *trans);
|
|
|
|
|
|
|
|
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
|
|
|
|
int btrfs_verify_qgroup_counts(struct btrfs_fs_info *fs_info, u64 qgroupid,
|
|
|
|
u64 rfer, u64 excl);
|
|
|
|
#endif
|
|
|
|
|
2015-10-12 02:05:40 -06:00
|
|
|
/* New io_tree based accurate qgroup reserve API */
|
|
|
|
int btrfs_qgroup_reserve_data(struct inode *inode, u64 start, u64 len);
|
2015-10-12 02:28:06 -06:00
|
|
|
int btrfs_qgroup_release_data(struct inode *inode, u64 start, u64 len);
|
|
|
|
int btrfs_qgroup_free_data(struct inode *inode, u64 start, u64 len);
|
2015-09-08 03:08:38 -06:00
|
|
|
|
2017-01-25 07:50:33 -07:00
|
|
|
int btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes,
|
|
|
|
bool enforce);
|
2015-09-08 03:08:38 -06:00
|
|
|
void btrfs_qgroup_free_meta_all(struct btrfs_root *root);
|
|
|
|
void btrfs_qgroup_free_meta(struct btrfs_root *root, int num_bytes);
|
2015-10-12 19:53:10 -06:00
|
|
|
void btrfs_qgroup_check_reserved_leak(struct inode *inode);
|
2014-05-13 18:30:47 -06:00
|
|
|
#endif /* __BTRFS_QGROUP__ */
|