]>
Commit | Line | Data |
---|---|---|
56bec294 CM |
1 | /* |
2 | * Copyright (C) 2008 Oracle. All rights reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU General Public | |
6 | * License v2 as published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
11 | * General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public | |
14 | * License along with this program; if not, write to the | |
15 | * Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
16 | * Boston, MA 021110-1307, USA. | |
17 | */ | |
18 | #ifndef __DELAYED_REF__ | |
19 | #define __DELAYED_REF__ | |
20 | ||
6df8cdf5 ER |
21 | #include <linux/refcount.h> |
22 | ||
44a075bd | 23 | /* these are the possible values of struct btrfs_delayed_ref_node->action */ |
56bec294 CM |
24 | #define BTRFS_ADD_DELAYED_REF 1 /* add one backref to the tree */ |
25 | #define BTRFS_DROP_DELAYED_REF 2 /* delete one backref from the tree */ | |
26 | #define BTRFS_ADD_DELAYED_EXTENT 3 /* record a full extent allocation */ | |
1a81af4d | 27 | #define BTRFS_UPDATE_DELAYED_HEAD 4 /* not changing ref count on head ref */ |
56bec294 CM |
28 | |
29 | struct btrfs_delayed_ref_node { | |
0e0adbcf | 30 | struct rb_node ref_node; |
1d57ee94 WX |
31 | /* |
32 | * If action is BTRFS_ADD_DELAYED_REF, also link this node to | |
33 | * ref_head->ref_add_list, then we do not need to iterate the | |
34 | * whole ref_head->ref_list to find BTRFS_ADD_DELAYED_REF nodes. | |
35 | */ | |
36 | struct list_head add_list; | |
c6fc2454 | 37 | |
56bec294 CM |
38 | /* the starting bytenr of the extent */ |
39 | u64 bytenr; | |
40 | ||
56bec294 CM |
41 | /* the size of the extent */ |
42 | u64 num_bytes; | |
43 | ||
00f04b88 AJ |
44 | /* seq number to keep track of insertion order */ |
45 | u64 seq; | |
46 | ||
56bec294 | 47 | /* ref count on this data structure */ |
6df8cdf5 | 48 | refcount_t refs; |
56bec294 CM |
49 | |
50 | /* | |
51 | * how many refs is this entry adding or deleting. For | |
52 | * head refs, this may be a negative number because it is keeping | |
53 | * track of the total mods done to the reference count. | |
54 | * For individual refs, this will always be a positive number | |
55 | * | |
56 | * It may be more than one, since it is possible for a single | |
57 | * parent to have more than one ref on an extent | |
58 | */ | |
59 | int ref_mod; | |
60 | ||
5d4f98a2 YZ |
61 | unsigned int action:8; |
62 | unsigned int type:8; | |
56bec294 | 63 | /* is this node still in the rbtree? */ |
5d4f98a2 | 64 | unsigned int is_head:1; |
56bec294 CM |
65 | unsigned int in_tree:1; |
66 | }; | |
67 | ||
5d4f98a2 YZ |
68 | struct btrfs_delayed_extent_op { |
69 | struct btrfs_disk_key key; | |
35b3ad50 DS |
70 | u8 level; |
71 | bool update_key; | |
72 | bool update_flags; | |
73 | bool is_data; | |
5d4f98a2 | 74 | u64 flags_to_set; |
5d4f98a2 YZ |
75 | }; |
76 | ||
56bec294 CM |
77 | /* |
78 | * the head refs are used to hold a lock on a given extent, which allows us | |
79 | * to make sure that only one process is running the delayed refs | |
80 | * at a time for a single extent. They also store the sum of all the | |
81 | * reference count modifications we've queued up. | |
82 | */ | |
83 | struct btrfs_delayed_ref_head { | |
d278850e JB |
84 | u64 bytenr; |
85 | u64 num_bytes; | |
86 | refcount_t refs; | |
56bec294 CM |
87 | /* |
88 | * the mutex is held while running the refs, and it is also | |
89 | * held when checking the sum of reference modifications. | |
90 | */ | |
91 | struct mutex mutex; | |
92 | ||
d7df2c79 | 93 | spinlock_t lock; |
0e0adbcf | 94 | struct rb_root ref_tree; |
1d57ee94 WX |
95 | /* accumulate add BTRFS_ADD_DELAYED_REF nodes to this ref_add_list. */ |
96 | struct list_head ref_add_list; | |
c3e69d58 | 97 | |
c46effa6 LB |
98 | struct rb_node href_node; |
99 | ||
5d4f98a2 | 100 | struct btrfs_delayed_extent_op *extent_op; |
1262133b JB |
101 | |
102 | /* | |
103 | * This is used to track the final ref_mod from all the refs associated | |
104 | * with this head ref, this is not adjusted as delayed refs are run, | |
105 | * this is meant to track if we need to do the csum accounting or not. | |
106 | */ | |
107 | int total_ref_mod; | |
108 | ||
d278850e JB |
109 | /* |
110 | * This is the current outstanding mod references for this bytenr. This | |
111 | * is used with lookup_extent_info to get an accurate reference count | |
112 | * for a bytenr, so it is adjusted as delayed refs are run so that any | |
113 | * on disk reference count + ref_mod is accurate. | |
114 | */ | |
115 | int ref_mod; | |
116 | ||
f64d5ca8 QW |
117 | /* |
118 | * For qgroup reserved space freeing. | |
119 | * | |
120 | * ref_root and reserved will be recorded after | |
121 | * BTRFS_ADD_DELAYED_EXTENT is called. | |
122 | * And will be used to free reserved qgroup space at | |
123 | * run_delayed_refs() time. | |
124 | */ | |
125 | u64 qgroup_ref_root; | |
126 | u64 qgroup_reserved; | |
127 | ||
56bec294 CM |
128 | /* |
129 | * when a new extent is allocated, it is just reserved in memory | |
130 | * The actual extent isn't inserted into the extent allocation tree | |
131 | * until the delayed ref is processed. must_insert_reserved is | |
132 | * used to flag a delayed ref so the accounting can be updated | |
133 | * when a full insert is done. | |
134 | * | |
135 | * It is possible the extent will be freed before it is ever | |
136 | * inserted into the extent allocation tree. In this case | |
137 | * we need to update the in ram accounting to properly reflect | |
138 | * the free has happened. | |
139 | */ | |
140 | unsigned int must_insert_reserved:1; | |
5d4f98a2 | 141 | unsigned int is_data:1; |
d7df2c79 | 142 | unsigned int processing:1; |
56bec294 CM |
143 | }; |
144 | ||
5d4f98a2 | 145 | struct btrfs_delayed_tree_ref { |
56bec294 | 146 | struct btrfs_delayed_ref_node node; |
eebe063b AJ |
147 | u64 root; |
148 | u64 parent; | |
5d4f98a2 YZ |
149 | int level; |
150 | }; | |
56bec294 | 151 | |
5d4f98a2 YZ |
152 | struct btrfs_delayed_data_ref { |
153 | struct btrfs_delayed_ref_node node; | |
eebe063b AJ |
154 | u64 root; |
155 | u64 parent; | |
5d4f98a2 YZ |
156 | u64 objectid; |
157 | u64 offset; | |
56bec294 CM |
158 | }; |
159 | ||
160 | struct btrfs_delayed_ref_root { | |
c46effa6 LB |
161 | /* head ref rbtree */ |
162 | struct rb_root href_root; | |
163 | ||
3368d001 QW |
164 | /* dirty extent records */ |
165 | struct rb_root dirty_extent_root; | |
166 | ||
56bec294 CM |
167 | /* this spin lock protects the rbtree and the entries inside */ |
168 | spinlock_t lock; | |
169 | ||
170 | /* how many delayed ref updates we've queued, used by the | |
171 | * throttling code | |
172 | */ | |
d7df2c79 | 173 | atomic_t num_entries; |
56bec294 | 174 | |
c3e69d58 CM |
175 | /* total number of head nodes in tree */ |
176 | unsigned long num_heads; | |
177 | ||
178 | /* total number of head nodes ready for processing */ | |
179 | unsigned long num_heads_ready; | |
180 | ||
1262133b JB |
181 | u64 pending_csums; |
182 | ||
56bec294 CM |
183 | /* |
184 | * set when the tree is flushing before a transaction commit, | |
185 | * used by the throttling code to decide if new updates need | |
186 | * to be run right away | |
187 | */ | |
188 | int flushing; | |
c3e69d58 CM |
189 | |
190 | u64 run_delayed_start; | |
9086db86 QW |
191 | |
192 | /* | |
193 | * To make qgroup to skip given root. | |
01327610 | 194 | * This is for snapshot, as btrfs_qgroup_inherit() will manually |
9086db86 QW |
195 | * modify counters for snapshot and its source, so we should skip |
196 | * the snapshot in new_root/old_roots or it will get calculated twice | |
197 | */ | |
198 | u64 qgroup_to_skip; | |
56bec294 CM |
199 | }; |
200 | ||
78a6184a MX |
201 | extern struct kmem_cache *btrfs_delayed_ref_head_cachep; |
202 | extern struct kmem_cache *btrfs_delayed_tree_ref_cachep; | |
203 | extern struct kmem_cache *btrfs_delayed_data_ref_cachep; | |
204 | extern struct kmem_cache *btrfs_delayed_extent_op_cachep; | |
205 | ||
f5c29bd9 | 206 | int __init btrfs_delayed_ref_init(void); |
78a6184a MX |
207 | void btrfs_delayed_ref_exit(void); |
208 | ||
209 | static inline struct btrfs_delayed_extent_op * | |
210 | btrfs_alloc_delayed_extent_op(void) | |
211 | { | |
212 | return kmem_cache_alloc(btrfs_delayed_extent_op_cachep, GFP_NOFS); | |
213 | } | |
214 | ||
215 | static inline void | |
216 | btrfs_free_delayed_extent_op(struct btrfs_delayed_extent_op *op) | |
217 | { | |
218 | if (op) | |
219 | kmem_cache_free(btrfs_delayed_extent_op_cachep, op); | |
220 | } | |
221 | ||
56bec294 CM |
222 | static inline void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref) |
223 | { | |
6df8cdf5 ER |
224 | WARN_ON(refcount_read(&ref->refs) == 0); |
225 | if (refcount_dec_and_test(&ref->refs)) { | |
56bec294 | 226 | WARN_ON(ref->in_tree); |
78a6184a MX |
227 | switch (ref->type) { |
228 | case BTRFS_TREE_BLOCK_REF_KEY: | |
229 | case BTRFS_SHARED_BLOCK_REF_KEY: | |
230 | kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref); | |
231 | break; | |
232 | case BTRFS_EXTENT_DATA_REF_KEY: | |
233 | case BTRFS_SHARED_DATA_REF_KEY: | |
234 | kmem_cache_free(btrfs_delayed_data_ref_cachep, ref); | |
235 | break; | |
78a6184a MX |
236 | default: |
237 | BUG(); | |
238 | } | |
56bec294 CM |
239 | } |
240 | } | |
241 | ||
d278850e JB |
242 | static inline void btrfs_put_delayed_ref_head(struct btrfs_delayed_ref_head *head) |
243 | { | |
244 | if (refcount_dec_and_test(&head->refs)) | |
245 | kmem_cache_free(btrfs_delayed_ref_head_cachep, head); | |
246 | } | |
247 | ||
66d7e7f0 AJ |
248 | int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info, |
249 | struct btrfs_trans_handle *trans, | |
5d4f98a2 YZ |
250 | u64 bytenr, u64 num_bytes, u64 parent, |
251 | u64 ref_root, int level, int action, | |
7be07912 OS |
252 | struct btrfs_delayed_extent_op *extent_op, |
253 | int *old_ref_mod, int *new_ref_mod); | |
66d7e7f0 AJ |
254 | int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info, |
255 | struct btrfs_trans_handle *trans, | |
5d4f98a2 YZ |
256 | u64 bytenr, u64 num_bytes, |
257 | u64 parent, u64 ref_root, | |
7be07912 OS |
258 | u64 owner, u64 offset, u64 reserved, int action, |
259 | int *old_ref_mod, int *new_ref_mod); | |
66d7e7f0 AJ |
260 | int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info, |
261 | struct btrfs_trans_handle *trans, | |
5d4f98a2 YZ |
262 | u64 bytenr, u64 num_bytes, |
263 | struct btrfs_delayed_extent_op *extent_op); | |
ae1e206b JB |
264 | void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans, |
265 | struct btrfs_fs_info *fs_info, | |
266 | struct btrfs_delayed_ref_root *delayed_refs, | |
267 | struct btrfs_delayed_ref_head *head); | |
56bec294 | 268 | |
1887be66 | 269 | struct btrfs_delayed_ref_head * |
f72ad18e LB |
270 | btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs, |
271 | u64 bytenr); | |
c3e69d58 CM |
272 | int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans, |
273 | struct btrfs_delayed_ref_head *head); | |
093486c4 MX |
274 | static inline void btrfs_delayed_ref_unlock(struct btrfs_delayed_ref_head *head) |
275 | { | |
276 | mutex_unlock(&head->mutex); | |
277 | } | |
278 | ||
d7df2c79 JB |
279 | |
280 | struct btrfs_delayed_ref_head * | |
281 | btrfs_select_ref_head(struct btrfs_trans_handle *trans); | |
00f04b88 | 282 | |
097b8a7c JS |
283 | int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, |
284 | struct btrfs_delayed_ref_root *delayed_refs, | |
00f04b88 AJ |
285 | u64 seq); |
286 | ||
56bec294 CM |
287 | /* |
288 | * helper functions to cast a node into its container | |
289 | */ | |
5d4f98a2 YZ |
290 | static inline struct btrfs_delayed_tree_ref * |
291 | btrfs_delayed_node_to_tree_ref(struct btrfs_delayed_ref_node *node) | |
56bec294 | 292 | { |
5d4f98a2 YZ |
293 | return container_of(node, struct btrfs_delayed_tree_ref, node); |
294 | } | |
56bec294 | 295 | |
5d4f98a2 YZ |
296 | static inline struct btrfs_delayed_data_ref * |
297 | btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node) | |
298 | { | |
5d4f98a2 | 299 | return container_of(node, struct btrfs_delayed_data_ref, node); |
56bec294 | 300 | } |
56bec294 | 301 | #endif |