Line data Source code
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 :
21 : /* these are the possible values of struct btrfs_delayed_ref_node->action */
22 : #define BTRFS_ADD_DELAYED_REF 1 /* add one backref to the tree */
23 : #define BTRFS_DROP_DELAYED_REF 2 /* delete one backref from the tree */
24 : #define BTRFS_ADD_DELAYED_EXTENT 3 /* record a full extent allocation */
25 : #define BTRFS_UPDATE_DELAYED_HEAD 4 /* not changing ref count on head ref */
26 :
27 : struct btrfs_delayed_ref_node {
28 : struct rb_node rb_node;
29 :
30 : /* the starting bytenr of the extent */
31 : u64 bytenr;
32 :
33 : /* the size of the extent */
34 : u64 num_bytes;
35 :
36 : /* seq number to keep track of insertion order */
37 : u64 seq;
38 :
39 : /* ref count on this data structure */
40 : atomic_t refs;
41 :
42 : /*
43 : * how many refs is this entry adding or deleting. For
44 : * head refs, this may be a negative number because it is keeping
45 : * track of the total mods done to the reference count.
46 : * For individual refs, this will always be a positive number
47 : *
48 : * It may be more than one, since it is possible for a single
49 : * parent to have more than one ref on an extent
50 : */
51 : int ref_mod;
52 :
53 : unsigned int action:8;
54 : unsigned int type:8;
55 : unsigned int no_quota:1;
56 : /* is this node still in the rbtree? */
57 : unsigned int is_head:1;
58 : unsigned int in_tree:1;
59 : };
60 :
61 : struct btrfs_delayed_extent_op {
62 : struct btrfs_disk_key key;
63 : u64 flags_to_set;
64 : int level;
65 : unsigned int update_key:1;
66 : unsigned int update_flags:1;
67 : unsigned int is_data:1;
68 : };
69 :
70 : /*
71 : * the head refs are used to hold a lock on a given extent, which allows us
72 : * to make sure that only one process is running the delayed refs
73 : * at a time for a single extent. They also store the sum of all the
74 : * reference count modifications we've queued up.
75 : */
76 : struct btrfs_delayed_ref_head {
77 : struct btrfs_delayed_ref_node node;
78 :
79 : /*
80 : * the mutex is held while running the refs, and it is also
81 : * held when checking the sum of reference modifications.
82 : */
83 : struct mutex mutex;
84 :
85 : spinlock_t lock;
86 : struct rb_root ref_root;
87 :
88 : struct rb_node href_node;
89 :
90 : struct btrfs_delayed_extent_op *extent_op;
91 : /*
92 : * when a new extent is allocated, it is just reserved in memory
93 : * The actual extent isn't inserted into the extent allocation tree
94 : * until the delayed ref is processed. must_insert_reserved is
95 : * used to flag a delayed ref so the accounting can be updated
96 : * when a full insert is done.
97 : *
98 : * It is possible the extent will be freed before it is ever
99 : * inserted into the extent allocation tree. In this case
100 : * we need to update the in ram accounting to properly reflect
101 : * the free has happened.
102 : */
103 : unsigned int must_insert_reserved:1;
104 : unsigned int is_data:1;
105 : unsigned int processing:1;
106 : };
107 :
108 : struct btrfs_delayed_tree_ref {
109 : struct btrfs_delayed_ref_node node;
110 : u64 root;
111 : u64 parent;
112 : int level;
113 : };
114 :
115 : struct btrfs_delayed_data_ref {
116 : struct btrfs_delayed_ref_node node;
117 : u64 root;
118 : u64 parent;
119 : u64 objectid;
120 : u64 offset;
121 : };
122 :
123 : struct btrfs_delayed_ref_root {
124 : /* head ref rbtree */
125 : struct rb_root href_root;
126 :
127 : /* this spin lock protects the rbtree and the entries inside */
128 : spinlock_t lock;
129 :
130 : /* how many delayed ref updates we've queued, used by the
131 : * throttling code
132 : */
133 : atomic_t num_entries;
134 :
135 : /* total number of head nodes in tree */
136 : unsigned long num_heads;
137 :
138 : /* total number of head nodes ready for processing */
139 : unsigned long num_heads_ready;
140 :
141 : /*
142 : * set when the tree is flushing before a transaction commit,
143 : * used by the throttling code to decide if new updates need
144 : * to be run right away
145 : */
146 : int flushing;
147 :
148 : u64 run_delayed_start;
149 : };
150 :
151 : extern struct kmem_cache *btrfs_delayed_ref_head_cachep;
152 : extern struct kmem_cache *btrfs_delayed_tree_ref_cachep;
153 : extern struct kmem_cache *btrfs_delayed_data_ref_cachep;
154 : extern struct kmem_cache *btrfs_delayed_extent_op_cachep;
155 :
156 : int btrfs_delayed_ref_init(void);
157 : void btrfs_delayed_ref_exit(void);
158 :
159 : static inline struct btrfs_delayed_extent_op *
160 : btrfs_alloc_delayed_extent_op(void)
161 : {
162 56190 : return kmem_cache_alloc(btrfs_delayed_extent_op_cachep, GFP_NOFS);
163 : }
164 :
165 : static inline void
166 : btrfs_free_delayed_extent_op(struct btrfs_delayed_extent_op *op)
167 : {
168 388879 : if (op)
169 56224 : kmem_cache_free(btrfs_delayed_extent_op_cachep, op);
170 : }
171 :
172 395053 : static inline void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref)
173 : {
174 395053 : WARN_ON(atomic_read(&ref->refs) == 0);
175 790114 : if (atomic_dec_and_test(&ref->refs)) {
176 395051 : WARN_ON(ref->in_tree);
177 395053 : switch (ref->type) {
178 : case BTRFS_TREE_BLOCK_REF_KEY:
179 : case BTRFS_SHARED_BLOCK_REF_KEY:
180 108824 : kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref);
181 108825 : break;
182 : case BTRFS_EXTENT_DATA_REF_KEY:
183 : case BTRFS_SHARED_DATA_REF_KEY:
184 92295 : kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);
185 92295 : break;
186 : case 0:
187 193934 : kmem_cache_free(btrfs_delayed_ref_head_cachep, ref);
188 193933 : break;
189 : default:
190 0 : BUG();
191 : }
192 : }
193 395063 : }
194 :
195 : int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info,
196 : struct btrfs_trans_handle *trans,
197 : u64 bytenr, u64 num_bytes, u64 parent,
198 : u64 ref_root, int level, int action,
199 : struct btrfs_delayed_extent_op *extent_op,
200 : int no_quota);
201 : int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info,
202 : struct btrfs_trans_handle *trans,
203 : u64 bytenr, u64 num_bytes,
204 : u64 parent, u64 ref_root,
205 : u64 owner, u64 offset, int action,
206 : struct btrfs_delayed_extent_op *extent_op,
207 : int no_quota);
208 : int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info,
209 : struct btrfs_trans_handle *trans,
210 : u64 bytenr, u64 num_bytes,
211 : struct btrfs_delayed_extent_op *extent_op);
212 : void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans,
213 : struct btrfs_fs_info *fs_info,
214 : struct btrfs_delayed_ref_root *delayed_refs,
215 : struct btrfs_delayed_ref_head *head);
216 :
217 : struct btrfs_delayed_ref_head *
218 : btrfs_find_delayed_ref_head(struct btrfs_trans_handle *trans, u64 bytenr);
219 : int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans,
220 : struct btrfs_delayed_ref_head *head);
221 : static inline void btrfs_delayed_ref_unlock(struct btrfs_delayed_ref_head *head)
222 : {
223 191772 : mutex_unlock(&head->mutex);
224 : }
225 :
226 :
227 : struct btrfs_delayed_ref_head *
228 : btrfs_select_ref_head(struct btrfs_trans_handle *trans);
229 :
230 : int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info,
231 : struct btrfs_delayed_ref_root *delayed_refs,
232 : u64 seq);
233 :
234 : /*
235 : * a node might live in a head or a regular ref, this lets you
236 : * test for the proper type to use.
237 : */
238 : static int btrfs_delayed_ref_is_head(struct btrfs_delayed_ref_node *node)
239 : {
240 1412377 : return node->is_head;
241 : }
242 :
243 : /*
244 : * helper functions to cast a node into its container
245 : */
246 : static inline struct btrfs_delayed_tree_ref *
247 : btrfs_delayed_node_to_tree_ref(struct btrfs_delayed_ref_node *node)
248 : {
249 224046 : WARN_ON(btrfs_delayed_ref_is_head(node));
250 : return container_of(node, struct btrfs_delayed_tree_ref, node);
251 : }
252 :
253 : static inline struct btrfs_delayed_data_ref *
254 : btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node)
255 : {
256 200604 : WARN_ON(btrfs_delayed_ref_is_head(node));
257 : return container_of(node, struct btrfs_delayed_data_ref, node);
258 : }
259 :
260 : static inline struct btrfs_delayed_ref_head *
261 : btrfs_delayed_node_to_head(struct btrfs_delayed_ref_node *node)
262 : {
263 432564 : WARN_ON(!btrfs_delayed_ref_is_head(node));
264 : return container_of(node, struct btrfs_delayed_ref_head, node);
265 : }
266 : #endif
|
