Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 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 | |
Wang Sheng-Hui | 44a075b | 2012-09-21 08:21:01 +0800 | [diff] [blame] | 21 | /* these are the possible values of struct btrfs_delayed_ref_node->action */ |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 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 */ |
Chris Mason | 1a81af4 | 2009-03-25 09:55:11 -0400 | [diff] [blame] | 25 | #define BTRFS_UPDATE_DELAYED_HEAD 4 /* not changing ref count on head ref */ |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 26 | |
Qu Wenruo | c6fc245 | 2015-03-30 17:03:00 +0800 | [diff] [blame] | 27 | /* |
| 28 | * XXX: Qu: I really hate the design that ref_head and tree/data ref shares the |
| 29 | * same ref_node structure. |
| 30 | * Ref_head is in a higher logic level than tree/data ref, and duplicated |
| 31 | * bytenr/num_bytes in ref_node is really a waste or memory, they should be |
| 32 | * referred from ref_head. |
| 33 | * This gets more disgusting after we use list to store tree/data ref in |
| 34 | * ref_head. Must clean this mess up later. |
| 35 | */ |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 36 | struct btrfs_delayed_ref_node { |
Qu Wenruo | c6fc245 | 2015-03-30 17:03:00 +0800 | [diff] [blame] | 37 | /*data/tree ref use list, stored in ref_head->ref_list. */ |
| 38 | struct list_head list; |
Wang Xiaoguang | 1d57ee9 | 2016-10-26 18:07:33 +0800 | [diff] [blame] | 39 | /* |
| 40 | * If action is BTRFS_ADD_DELAYED_REF, also link this node to |
| 41 | * ref_head->ref_add_list, then we do not need to iterate the |
| 42 | * whole ref_head->ref_list to find BTRFS_ADD_DELAYED_REF nodes. |
| 43 | */ |
| 44 | struct list_head add_list; |
Qu Wenruo | c6fc245 | 2015-03-30 17:03:00 +0800 | [diff] [blame] | 45 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 46 | /* the starting bytenr of the extent */ |
| 47 | u64 bytenr; |
| 48 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 49 | /* the size of the extent */ |
| 50 | u64 num_bytes; |
| 51 | |
Arne Jansen | 00f04b8 | 2011-09-14 12:37:00 +0200 | [diff] [blame] | 52 | /* seq number to keep track of insertion order */ |
| 53 | u64 seq; |
| 54 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 55 | /* ref count on this data structure */ |
| 56 | atomic_t refs; |
| 57 | |
| 58 | /* |
| 59 | * how many refs is this entry adding or deleting. For |
| 60 | * head refs, this may be a negative number because it is keeping |
| 61 | * track of the total mods done to the reference count. |
| 62 | * For individual refs, this will always be a positive number |
| 63 | * |
| 64 | * It may be more than one, since it is possible for a single |
| 65 | * parent to have more than one ref on an extent |
| 66 | */ |
| 67 | int ref_mod; |
| 68 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 69 | unsigned int action:8; |
| 70 | unsigned int type:8; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 71 | /* is this node still in the rbtree? */ |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 72 | unsigned int is_head:1; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 73 | unsigned int in_tree:1; |
| 74 | }; |
| 75 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 76 | struct btrfs_delayed_extent_op { |
| 77 | struct btrfs_disk_key key; |
David Sterba | 35b3ad5 | 2015-11-30 16:51:29 +0100 | [diff] [blame] | 78 | u8 level; |
| 79 | bool update_key; |
| 80 | bool update_flags; |
| 81 | bool is_data; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 82 | u64 flags_to_set; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 83 | }; |
| 84 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 85 | /* |
| 86 | * the head refs are used to hold a lock on a given extent, which allows us |
| 87 | * to make sure that only one process is running the delayed refs |
| 88 | * at a time for a single extent. They also store the sum of all the |
| 89 | * reference count modifications we've queued up. |
| 90 | */ |
| 91 | struct btrfs_delayed_ref_head { |
| 92 | struct btrfs_delayed_ref_node node; |
| 93 | |
| 94 | /* |
| 95 | * the mutex is held while running the refs, and it is also |
| 96 | * held when checking the sum of reference modifications. |
| 97 | */ |
| 98 | struct mutex mutex; |
| 99 | |
Josef Bacik | d7df2c7 | 2014-01-23 09:21:38 -0500 | [diff] [blame] | 100 | spinlock_t lock; |
Qu Wenruo | c6fc245 | 2015-03-30 17:03:00 +0800 | [diff] [blame] | 101 | struct list_head ref_list; |
Wang Xiaoguang | 1d57ee9 | 2016-10-26 18:07:33 +0800 | [diff] [blame] | 102 | /* accumulate add BTRFS_ADD_DELAYED_REF nodes to this ref_add_list. */ |
| 103 | struct list_head ref_add_list; |
Chris Mason | c3e69d5 | 2009-03-13 10:17:05 -0400 | [diff] [blame] | 104 | |
Liu Bo | c46effa | 2013-10-14 12:59:45 +0800 | [diff] [blame] | 105 | struct rb_node href_node; |
| 106 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 107 | struct btrfs_delayed_extent_op *extent_op; |
Josef Bacik | 1262133 | 2015-02-03 07:50:16 -0800 | [diff] [blame] | 108 | |
| 109 | /* |
| 110 | * This is used to track the final ref_mod from all the refs associated |
| 111 | * with this head ref, this is not adjusted as delayed refs are run, |
| 112 | * this is meant to track if we need to do the csum accounting or not. |
| 113 | */ |
| 114 | int total_ref_mod; |
| 115 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 116 | /* |
Qu Wenruo | f64d5ca | 2015-09-08 17:08:36 +0800 | [diff] [blame] | 117 | * For qgroup reserved space freeing. |
| 118 | * |
| 119 | * ref_root and reserved will be recorded after |
| 120 | * BTRFS_ADD_DELAYED_EXTENT is called. |
| 121 | * And will be used to free reserved qgroup space at |
| 122 | * run_delayed_refs() time. |
| 123 | */ |
| 124 | u64 qgroup_ref_root; |
| 125 | u64 qgroup_reserved; |
| 126 | |
| 127 | /* |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 128 | * when a new extent is allocated, it is just reserved in memory |
| 129 | * The actual extent isn't inserted into the extent allocation tree |
| 130 | * until the delayed ref is processed. must_insert_reserved is |
| 131 | * used to flag a delayed ref so the accounting can be updated |
| 132 | * when a full insert is done. |
| 133 | * |
| 134 | * It is possible the extent will be freed before it is ever |
| 135 | * inserted into the extent allocation tree. In this case |
| 136 | * we need to update the in ram accounting to properly reflect |
| 137 | * the free has happened. |
| 138 | */ |
| 139 | unsigned int must_insert_reserved:1; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 140 | unsigned int is_data:1; |
Josef Bacik | d7df2c7 | 2014-01-23 09:21:38 -0500 | [diff] [blame] | 141 | unsigned int processing:1; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 142 | }; |
| 143 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 144 | struct btrfs_delayed_tree_ref { |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 145 | struct btrfs_delayed_ref_node node; |
Arne Jansen | eebe063 | 2011-09-14 14:01:24 +0200 | [diff] [blame] | 146 | u64 root; |
| 147 | u64 parent; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 148 | int level; |
| 149 | }; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 150 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 151 | struct btrfs_delayed_data_ref { |
| 152 | struct btrfs_delayed_ref_node node; |
Arne Jansen | eebe063 | 2011-09-14 14:01:24 +0200 | [diff] [blame] | 153 | u64 root; |
| 154 | u64 parent; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 155 | u64 objectid; |
| 156 | u64 offset; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 157 | }; |
| 158 | |
| 159 | struct btrfs_delayed_ref_root { |
Liu Bo | c46effa | 2013-10-14 12:59:45 +0800 | [diff] [blame] | 160 | /* head ref rbtree */ |
| 161 | struct rb_root href_root; |
| 162 | |
Qu Wenruo | 3368d00 | 2015-04-16 14:34:17 +0800 | [diff] [blame] | 163 | /* dirty extent records */ |
| 164 | struct rb_root dirty_extent_root; |
| 165 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 166 | /* this spin lock protects the rbtree and the entries inside */ |
| 167 | spinlock_t lock; |
| 168 | |
| 169 | /* how many delayed ref updates we've queued, used by the |
| 170 | * throttling code |
| 171 | */ |
Josef Bacik | d7df2c7 | 2014-01-23 09:21:38 -0500 | [diff] [blame] | 172 | atomic_t num_entries; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 173 | |
Chris Mason | c3e69d5 | 2009-03-13 10:17:05 -0400 | [diff] [blame] | 174 | /* total number of head nodes in tree */ |
| 175 | unsigned long num_heads; |
| 176 | |
| 177 | /* total number of head nodes ready for processing */ |
| 178 | unsigned long num_heads_ready; |
| 179 | |
Josef Bacik | 1262133 | 2015-02-03 07:50:16 -0800 | [diff] [blame] | 180 | u64 pending_csums; |
| 181 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 182 | /* |
| 183 | * set when the tree is flushing before a transaction commit, |
| 184 | * used by the throttling code to decide if new updates need |
| 185 | * to be run right away |
| 186 | */ |
| 187 | int flushing; |
Chris Mason | c3e69d5 | 2009-03-13 10:17:05 -0400 | [diff] [blame] | 188 | |
| 189 | u64 run_delayed_start; |
Qu Wenruo | 9086db8 | 2015-04-20 09:53:50 +0800 | [diff] [blame] | 190 | |
| 191 | /* |
| 192 | * To make qgroup to skip given root. |
Nicholas D Steeves | 0132761 | 2016-05-19 21:18:45 -0400 | [diff] [blame] | 193 | * This is for snapshot, as btrfs_qgroup_inherit() will manually |
Qu Wenruo | 9086db8 | 2015-04-20 09:53:50 +0800 | [diff] [blame] | 194 | * modify counters for snapshot and its source, so we should skip |
| 195 | * the snapshot in new_root/old_roots or it will get calculated twice |
| 196 | */ |
| 197 | u64 qgroup_to_skip; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 198 | }; |
| 199 | |
Miao Xie | 78a6184 | 2012-11-21 02:21:28 +0000 | [diff] [blame] | 200 | extern struct kmem_cache *btrfs_delayed_ref_head_cachep; |
| 201 | extern struct kmem_cache *btrfs_delayed_tree_ref_cachep; |
| 202 | extern struct kmem_cache *btrfs_delayed_data_ref_cachep; |
| 203 | extern struct kmem_cache *btrfs_delayed_extent_op_cachep; |
| 204 | |
| 205 | int btrfs_delayed_ref_init(void); |
| 206 | void btrfs_delayed_ref_exit(void); |
| 207 | |
| 208 | static inline struct btrfs_delayed_extent_op * |
| 209 | btrfs_alloc_delayed_extent_op(void) |
| 210 | { |
| 211 | return kmem_cache_alloc(btrfs_delayed_extent_op_cachep, GFP_NOFS); |
| 212 | } |
| 213 | |
| 214 | static inline void |
| 215 | btrfs_free_delayed_extent_op(struct btrfs_delayed_extent_op *op) |
| 216 | { |
| 217 | if (op) |
| 218 | kmem_cache_free(btrfs_delayed_extent_op_cachep, op); |
| 219 | } |
| 220 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 221 | static inline void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref) |
| 222 | { |
| 223 | WARN_ON(atomic_read(&ref->refs) == 0); |
| 224 | if (atomic_dec_and_test(&ref->refs)) { |
| 225 | WARN_ON(ref->in_tree); |
Miao Xie | 78a6184 | 2012-11-21 02:21:28 +0000 | [diff] [blame] | 226 | switch (ref->type) { |
| 227 | case BTRFS_TREE_BLOCK_REF_KEY: |
| 228 | case BTRFS_SHARED_BLOCK_REF_KEY: |
| 229 | kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref); |
| 230 | break; |
| 231 | case BTRFS_EXTENT_DATA_REF_KEY: |
| 232 | case BTRFS_SHARED_DATA_REF_KEY: |
| 233 | kmem_cache_free(btrfs_delayed_data_ref_cachep, ref); |
| 234 | break; |
| 235 | case 0: |
| 236 | kmem_cache_free(btrfs_delayed_ref_head_cachep, ref); |
| 237 | break; |
| 238 | default: |
| 239 | BUG(); |
| 240 | } |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 241 | } |
| 242 | } |
| 243 | |
Arne Jansen | 66d7e7f | 2011-09-12 15:26:38 +0200 | [diff] [blame] | 244 | int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info, |
| 245 | struct btrfs_trans_handle *trans, |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 246 | u64 bytenr, u64 num_bytes, u64 parent, |
| 247 | u64 ref_root, int level, int action, |
Filipe Manana | b06c4bf | 2015-10-23 07:52:54 +0100 | [diff] [blame] | 248 | struct btrfs_delayed_extent_op *extent_op); |
Arne Jansen | 66d7e7f | 2011-09-12 15:26:38 +0200 | [diff] [blame] | 249 | int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info, |
| 250 | struct btrfs_trans_handle *trans, |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 251 | u64 bytenr, u64 num_bytes, |
| 252 | u64 parent, u64 ref_root, |
Qu Wenruo | 5846a3c | 2015-10-26 14:11:18 +0800 | [diff] [blame] | 253 | u64 owner, u64 offset, u64 reserved, int action, |
Filipe Manana | b06c4bf | 2015-10-23 07:52:54 +0100 | [diff] [blame] | 254 | struct btrfs_delayed_extent_op *extent_op); |
Arne Jansen | 66d7e7f | 2011-09-12 15:26:38 +0200 | [diff] [blame] | 255 | int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info, |
| 256 | struct btrfs_trans_handle *trans, |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 257 | u64 bytenr, u64 num_bytes, |
| 258 | struct btrfs_delayed_extent_op *extent_op); |
Josef Bacik | ae1e206 | 2012-08-07 16:00:32 -0400 | [diff] [blame] | 259 | void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans, |
| 260 | struct btrfs_fs_info *fs_info, |
| 261 | struct btrfs_delayed_ref_root *delayed_refs, |
| 262 | struct btrfs_delayed_ref_head *head); |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 263 | |
Chris Mason | 1887be6 | 2009-03-13 10:11:24 -0400 | [diff] [blame] | 264 | struct btrfs_delayed_ref_head * |
| 265 | btrfs_find_delayed_ref_head(struct btrfs_trans_handle *trans, u64 bytenr); |
Chris Mason | c3e69d5 | 2009-03-13 10:17:05 -0400 | [diff] [blame] | 266 | int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans, |
| 267 | struct btrfs_delayed_ref_head *head); |
Miao Xie | 093486c | 2012-12-19 08:10:10 +0000 | [diff] [blame] | 268 | static inline void btrfs_delayed_ref_unlock(struct btrfs_delayed_ref_head *head) |
| 269 | { |
| 270 | mutex_unlock(&head->mutex); |
| 271 | } |
| 272 | |
Josef Bacik | d7df2c7 | 2014-01-23 09:21:38 -0500 | [diff] [blame] | 273 | |
| 274 | struct btrfs_delayed_ref_head * |
| 275 | btrfs_select_ref_head(struct btrfs_trans_handle *trans); |
Arne Jansen | 00f04b8 | 2011-09-14 12:37:00 +0200 | [diff] [blame] | 276 | |
Jan Schmidt | 097b8a7 | 2012-06-21 11:08:04 +0200 | [diff] [blame] | 277 | int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, |
| 278 | struct btrfs_delayed_ref_root *delayed_refs, |
Arne Jansen | 00f04b8 | 2011-09-14 12:37:00 +0200 | [diff] [blame] | 279 | u64 seq); |
| 280 | |
| 281 | /* |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 282 | * a node might live in a head or a regular ref, this lets you |
| 283 | * test for the proper type to use. |
| 284 | */ |
| 285 | static int btrfs_delayed_ref_is_head(struct btrfs_delayed_ref_node *node) |
| 286 | { |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 287 | return node->is_head; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | /* |
| 291 | * helper functions to cast a node into its container |
| 292 | */ |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 293 | static inline struct btrfs_delayed_tree_ref * |
| 294 | btrfs_delayed_node_to_tree_ref(struct btrfs_delayed_ref_node *node) |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 295 | { |
| 296 | WARN_ON(btrfs_delayed_ref_is_head(node)); |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 297 | return container_of(node, struct btrfs_delayed_tree_ref, node); |
| 298 | } |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 299 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 300 | static inline struct btrfs_delayed_data_ref * |
| 301 | btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node) |
| 302 | { |
| 303 | WARN_ON(btrfs_delayed_ref_is_head(node)); |
| 304 | return container_of(node, struct btrfs_delayed_data_ref, node); |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 305 | } |
| 306 | |
| 307 | static inline struct btrfs_delayed_ref_head * |
| 308 | btrfs_delayed_node_to_head(struct btrfs_delayed_ref_node *node) |
| 309 | { |
| 310 | WARN_ON(!btrfs_delayed_ref_is_head(node)); |
| 311 | return container_of(node, struct btrfs_delayed_ref_head, node); |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 312 | } |
| 313 | #endif |