fs/btrfs/delayed-ref.h

   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 #include <linux/refcount.h>
  22
  23 /* these are the possible values of struct btrfs_delayed_ref_node->action */
  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 */
  27 #define BTRFS_UPDATE_DELAYED_HEAD 4 /* not changing ref count on head ref */
  28
  29 struct btrfs_delayed_ref_node {
  30         struct rb_node ref_node;
  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;
  37
  38         /* the starting bytenr of the extent */
  39         u64 bytenr;
  40
  41         /* the size of the extent */
  42         u64 num_bytes;
  43
  44         /* seq number to keep track of insertion order */
  45         u64 seq;
  46
  47         /* ref count on this data structure */
  48         refcount_t refs;
  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
  61         unsigned int action:8;
  62         unsigned int type:8;
  63         /* is this node still in the rbtree? */
  64         unsigned int is_head:1;
  65         unsigned int in_tree:1;
  66 };
  67
  68 struct btrfs_delayed_extent_op {
  69         struct btrfs_disk_key key;
  70         u8 level;
  71         bool update_key;
  72         bool update_flags;
  73         bool is_data;
  74         u64 flags_to_set;
  75 };
  76
  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 {
  84         u64 bytenr;
  85         u64 num_bytes;
  86         refcount_t refs;
  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
  93         spinlock_t lock;
  94         struct rb_root ref_tree;
  95         /* accumulate add BTRFS_ADD_DELAYED_REF nodes to this ref_add_list. */
  96         struct list_head ref_add_list;
  97
  98         struct rb_node href_node;
  99
 100         struct btrfs_delayed_extent_op *extent_op;
 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
 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
 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
 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;
 141         unsigned int is_data:1;
 142         unsigned int processing:1;
 143 };
 144
 145 struct btrfs_delayed_tree_ref {
 146         struct btrfs_delayed_ref_node node;
 147         u64 root;
 148         u64 parent;
 149         int level;
 150 };
 151
 152 struct btrfs_delayed_data_ref {
 153         struct btrfs_delayed_ref_node node;
 154         u64 root;
 155         u64 parent;
 156         u64 objectid;
 157         u64 offset;
 158 };
 159
 160 struct btrfs_delayed_ref_root {
 161         /* head ref rbtree */
 162         struct rb_root href_root;
 163
 164         /* dirty extent records */
 165         struct rb_root dirty_extent_root;
 166
 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          */
 173         atomic_t num_entries;
 174
 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
 181         u64 pending_csums;
 182
 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;
 189
 190         u64 run_delayed_start;
 191
 192         /*
 193          * To make qgroup to skip given root.
 194          * This is for snapshot, as btrfs_qgroup_inherit() will manually
 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;
 199 };
 200
 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
 206 int btrfs_delayed_ref_init(void);
 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
 222 static inline void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref)
 223 {
 224         WARN_ON(refcount_read(&ref->refs) == 0);
 225         if (refcount_dec_and_test(&ref->refs)) {
 226                 WARN_ON(ref->in_tree);
 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;
 236                 default:
 237                         BUG();
 238                 }
 239         }
 240 }
 241
 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
 248 int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info,
 249                                struct btrfs_trans_handle *trans,
 250                                u64 bytenr, u64 num_bytes, u64 parent,
 251                                u64 ref_root, int level, int action,
 252                                struct btrfs_delayed_extent_op *extent_op,
 253                                int *old_ref_mod, int *new_ref_mod);
 254 int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info,
 255                                struct btrfs_trans_handle *trans,
 256                                u64 bytenr, u64 num_bytes,
 257                                u64 parent, u64 ref_root,
 258                                u64 owner, u64 offset, u64 reserved, int action,
 259                                int *old_ref_mod, int *new_ref_mod);
 260 int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info,
 261                                 struct btrfs_trans_handle *trans,
 262                                 u64 bytenr, u64 num_bytes,
 263                                 struct btrfs_delayed_extent_op *extent_op);
 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);
 268
 269 struct btrfs_delayed_ref_head *
 270 btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs,
 271                             u64 bytenr);
 272 int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans,
 273                            struct btrfs_delayed_ref_head *head);
 274 static inline void btrfs_delayed_ref_unlock(struct btrfs_delayed_ref_head *head)
 275 {
 276         mutex_unlock(&head->mutex);
 277 }
 278
 279
 280 struct btrfs_delayed_ref_head *
 281 btrfs_select_ref_head(struct btrfs_trans_handle *trans);
 282
 283 int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info,
 284                             struct btrfs_delayed_ref_root *delayed_refs,
 285                             u64 seq);
 286
 287 /*
 288  * helper functions to cast a node into its container
 289  */
 290 static inline struct btrfs_delayed_tree_ref *
 291 btrfs_delayed_node_to_tree_ref(struct btrfs_delayed_ref_node *node)
 292 {
 293         return container_of(node, struct btrfs_delayed_tree_ref, node);
 294 }
 295
 296 static inline struct btrfs_delayed_data_ref *
 297 btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node)
 298 {
 299         return container_of(node, struct btrfs_delayed_data_ref, node);
 300 }
 301 #endif