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 | |
| 27 | struct btrfs_delayed_ref_node { |
| 28 | struct rb_node rb_node; |
| 29 | |
| 30 | /* the starting bytenr of the extent */ |
| 31 | u64 bytenr; |
| 32 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 33 | /* the size of the extent */ |
| 34 | u64 num_bytes; |
| 35 | |
Arne Jansen | 00f04b8 | 2011-09-14 12:37:00 +0200 | [diff] [blame] | 36 | /* seq number to keep track of insertion order */ |
| 37 | u64 seq; |
| 38 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 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 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 53 | unsigned int action:8; |
| 54 | unsigned int type:8; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 55 | /* is this node still in the rbtree? */ |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 56 | unsigned int is_head:1; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 57 | unsigned int in_tree:1; |
| 58 | }; |
| 59 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 60 | struct btrfs_delayed_extent_op { |
| 61 | struct btrfs_disk_key key; |
| 62 | u64 flags_to_set; |
| 63 | unsigned int update_key:1; |
| 64 | unsigned int update_flags:1; |
| 65 | unsigned int is_data:1; |
| 66 | }; |
| 67 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 68 | /* |
| 69 | * the head refs are used to hold a lock on a given extent, which allows us |
| 70 | * to make sure that only one process is running the delayed refs |
| 71 | * at a time for a single extent. They also store the sum of all the |
| 72 | * reference count modifications we've queued up. |
| 73 | */ |
| 74 | struct btrfs_delayed_ref_head { |
| 75 | struct btrfs_delayed_ref_node node; |
| 76 | |
| 77 | /* |
| 78 | * the mutex is held while running the refs, and it is also |
| 79 | * held when checking the sum of reference modifications. |
| 80 | */ |
| 81 | struct mutex mutex; |
| 82 | |
Chris Mason | c3e69d5 | 2009-03-13 10:17:05 -0400 | [diff] [blame] | 83 | struct list_head cluster; |
| 84 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 85 | struct btrfs_delayed_extent_op *extent_op; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 86 | /* |
| 87 | * when a new extent is allocated, it is just reserved in memory |
| 88 | * The actual extent isn't inserted into the extent allocation tree |
| 89 | * until the delayed ref is processed. must_insert_reserved is |
| 90 | * used to flag a delayed ref so the accounting can be updated |
| 91 | * when a full insert is done. |
| 92 | * |
| 93 | * It is possible the extent will be freed before it is ever |
| 94 | * inserted into the extent allocation tree. In this case |
| 95 | * we need to update the in ram accounting to properly reflect |
| 96 | * the free has happened. |
| 97 | */ |
| 98 | unsigned int must_insert_reserved:1; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 99 | unsigned int is_data:1; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 100 | }; |
| 101 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 102 | struct btrfs_delayed_tree_ref { |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 103 | struct btrfs_delayed_ref_node node; |
Arne Jansen | eebe063 | 2011-09-14 14:01:24 +0200 | [diff] [blame] | 104 | u64 root; |
| 105 | u64 parent; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 106 | int level; |
| 107 | }; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 108 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 109 | struct btrfs_delayed_data_ref { |
| 110 | struct btrfs_delayed_ref_node node; |
Arne Jansen | eebe063 | 2011-09-14 14:01:24 +0200 | [diff] [blame] | 111 | u64 root; |
| 112 | u64 parent; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 113 | u64 objectid; |
| 114 | u64 offset; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 115 | }; |
| 116 | |
| 117 | struct btrfs_delayed_ref_root { |
| 118 | struct rb_root root; |
| 119 | |
| 120 | /* this spin lock protects the rbtree and the entries inside */ |
| 121 | spinlock_t lock; |
| 122 | |
| 123 | /* how many delayed ref updates we've queued, used by the |
| 124 | * throttling code |
| 125 | */ |
| 126 | unsigned long num_entries; |
| 127 | |
Chris Mason | c3e69d5 | 2009-03-13 10:17:05 -0400 | [diff] [blame] | 128 | /* total number of head nodes in tree */ |
| 129 | unsigned long num_heads; |
| 130 | |
| 131 | /* total number of head nodes ready for processing */ |
| 132 | unsigned long num_heads_ready; |
| 133 | |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 134 | /* |
| 135 | * set when the tree is flushing before a transaction commit, |
| 136 | * used by the throttling code to decide if new updates need |
| 137 | * to be run right away |
| 138 | */ |
| 139 | int flushing; |
Chris Mason | c3e69d5 | 2009-03-13 10:17:05 -0400 | [diff] [blame] | 140 | |
| 141 | u64 run_delayed_start; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 142 | }; |
| 143 | |
| 144 | static inline void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref) |
| 145 | { |
| 146 | WARN_ON(atomic_read(&ref->refs) == 0); |
| 147 | if (atomic_dec_and_test(&ref->refs)) { |
| 148 | WARN_ON(ref->in_tree); |
| 149 | kfree(ref); |
| 150 | } |
| 151 | } |
| 152 | |
Arne Jansen | 66d7e7f | 2011-09-12 15:26:38 +0200 | [diff] [blame] | 153 | int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info, |
| 154 | struct btrfs_trans_handle *trans, |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 155 | u64 bytenr, u64 num_bytes, u64 parent, |
| 156 | u64 ref_root, int level, int action, |
Arne Jansen | 66d7e7f | 2011-09-12 15:26:38 +0200 | [diff] [blame] | 157 | struct btrfs_delayed_extent_op *extent_op, |
| 158 | int for_cow); |
| 159 | int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info, |
| 160 | struct btrfs_trans_handle *trans, |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 161 | u64 bytenr, u64 num_bytes, |
| 162 | u64 parent, u64 ref_root, |
| 163 | u64 owner, u64 offset, int action, |
Arne Jansen | 66d7e7f | 2011-09-12 15:26:38 +0200 | [diff] [blame] | 164 | struct btrfs_delayed_extent_op *extent_op, |
| 165 | int for_cow); |
| 166 | int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info, |
| 167 | struct btrfs_trans_handle *trans, |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 168 | u64 bytenr, u64 num_bytes, |
| 169 | struct btrfs_delayed_extent_op *extent_op); |
Josef Bacik | ae1e206 | 2012-08-07 16:00:32 -0400 | [diff] [blame] | 170 | void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans, |
| 171 | struct btrfs_fs_info *fs_info, |
| 172 | struct btrfs_delayed_ref_root *delayed_refs, |
| 173 | struct btrfs_delayed_ref_head *head); |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 174 | |
Chris Mason | 1887be6 | 2009-03-13 10:11:24 -0400 | [diff] [blame] | 175 | struct btrfs_delayed_ref_head * |
| 176 | btrfs_find_delayed_ref_head(struct btrfs_trans_handle *trans, u64 bytenr); |
Chris Mason | c3e69d5 | 2009-03-13 10:17:05 -0400 | [diff] [blame] | 177 | int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans, |
| 178 | struct btrfs_delayed_ref_head *head); |
| 179 | int btrfs_find_ref_cluster(struct btrfs_trans_handle *trans, |
| 180 | struct list_head *cluster, u64 search_start); |
Arne Jansen | 00f04b8 | 2011-09-14 12:37:00 +0200 | [diff] [blame] | 181 | |
Jan Schmidt | 097b8a7 | 2012-06-21 11:08:04 +0200 | [diff] [blame] | 182 | int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, |
| 183 | struct btrfs_delayed_ref_root *delayed_refs, |
Arne Jansen | 00f04b8 | 2011-09-14 12:37:00 +0200 | [diff] [blame] | 184 | u64 seq); |
| 185 | |
| 186 | /* |
Jan Schmidt | 546adb0 | 2012-06-14 16:37:44 +0200 | [diff] [blame] | 187 | * delayed refs with a ref_seq > 0 must be held back during backref walking. |
| 188 | * this only applies to items in one of the fs-trees. for_cow items never need |
| 189 | * to be held back, so they won't get a ref_seq number. |
| 190 | */ |
| 191 | static inline int need_ref_seq(int for_cow, u64 rootid) |
| 192 | { |
| 193 | if (for_cow) |
| 194 | return 0; |
| 195 | |
| 196 | if (rootid == BTRFS_FS_TREE_OBJECTID) |
| 197 | return 1; |
| 198 | |
| 199 | if ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID) |
| 200 | return 1; |
| 201 | |
| 202 | return 0; |
| 203 | } |
| 204 | |
| 205 | /* |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 206 | * a node might live in a head or a regular ref, this lets you |
| 207 | * test for the proper type to use. |
| 208 | */ |
| 209 | static int btrfs_delayed_ref_is_head(struct btrfs_delayed_ref_node *node) |
| 210 | { |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 211 | return node->is_head; |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | /* |
| 215 | * helper functions to cast a node into its container |
| 216 | */ |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 217 | static inline struct btrfs_delayed_tree_ref * |
| 218 | btrfs_delayed_node_to_tree_ref(struct btrfs_delayed_ref_node *node) |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 219 | { |
| 220 | WARN_ON(btrfs_delayed_ref_is_head(node)); |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 221 | return container_of(node, struct btrfs_delayed_tree_ref, node); |
| 222 | } |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 223 | |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 224 | static inline struct btrfs_delayed_data_ref * |
| 225 | btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node) |
| 226 | { |
| 227 | WARN_ON(btrfs_delayed_ref_is_head(node)); |
| 228 | return container_of(node, struct btrfs_delayed_data_ref, node); |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | static inline struct btrfs_delayed_ref_head * |
| 232 | btrfs_delayed_node_to_head(struct btrfs_delayed_ref_node *node) |
| 233 | { |
| 234 | WARN_ON(!btrfs_delayed_ref_is_head(node)); |
| 235 | return container_of(node, struct btrfs_delayed_ref_head, node); |
Chris Mason | 56bec29 | 2009-03-13 10:10:06 -0400 | [diff] [blame] | 236 | } |
| 237 | #endif |