git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/snapshot.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _BCACHEFS_SNAPSHOT_H
   3 #define _BCACHEFS_SNAPSHOT_H
   4
   5 enum bkey_invalid_flags;
   6
   7 void bch2_snapshot_tree_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
   8 int bch2_snapshot_tree_invalid(struct bch_fs *, struct bkey_s_c,
   9                                enum bkey_invalid_flags, struct printbuf *);
  10
  11 #define bch2_bkey_ops_snapshot_tree ((struct bkey_ops) {        \
  12         .key_invalid    = bch2_snapshot_tree_invalid,           \
  13         .val_to_text    = bch2_snapshot_tree_to_text,           \
  14         .min_val_size   = 8,                                    \
  15 })
  16
  17 struct bkey_i_snapshot_tree *__bch2_snapshot_tree_create(struct btree_trans *);
  18
  19 int bch2_snapshot_tree_lookup(struct btree_trans *, u32, struct bch_snapshot_tree *);
  20
  21 void bch2_snapshot_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
  22 int bch2_snapshot_invalid(struct bch_fs *, struct bkey_s_c,
  23                           enum bkey_invalid_flags, struct printbuf *);
  24 int bch2_mark_snapshot(struct btree_trans *, enum btree_id, unsigned,
  25                        struct bkey_s_c, struct bkey_s_c, unsigned);
  26
  27 #define bch2_bkey_ops_snapshot ((struct bkey_ops) {             \
  28         .key_invalid    = bch2_snapshot_invalid,                \
  29         .val_to_text    = bch2_snapshot_to_text,                \
  30         .atomic_trigger = bch2_mark_snapshot,                   \
  31         .min_val_size   = 24,                                   \
  32 })
  33
  34 static inline struct snapshot_t *__snapshot_t(struct snapshot_table *t, u32 id)
  35 {
  36         return &t->s[U32_MAX - id];
  37 }
  38
  39 static inline const struct snapshot_t *snapshot_t(struct bch_fs *c, u32 id)
  40 {
  41         return __snapshot_t(rcu_dereference(c->snapshots), id);
  42 }
  43
  44 static inline u32 bch2_snapshot_tree(struct bch_fs *c, u32 id)
  45 {
  46         rcu_read_lock();
  47         id = snapshot_t(c, id)->tree;
  48         rcu_read_unlock();
  49
  50         return id;
  51 }
  52
  53 static inline u32 __bch2_snapshot_parent_early(struct bch_fs *c, u32 id)
  54 {
  55         return snapshot_t(c, id)->parent;
  56 }
  57
  58 static inline u32 bch2_snapshot_parent_early(struct bch_fs *c, u32 id)
  59 {
  60         rcu_read_lock();
  61         id = __bch2_snapshot_parent_early(c, id);
  62         rcu_read_unlock();
  63
  64         return id;
  65 }
  66
  67 static inline u32 __bch2_snapshot_parent(struct bch_fs *c, u32 id)
  68 {
  69 #ifdef CONFIG_BCACHEFS_DEBUG
  70         u32 parent = snapshot_t(c, id)->parent;
  71
  72         if (parent &&
  73             snapshot_t(c, id)->depth != snapshot_t(c, parent)->depth + 1)
  74                 panic("id %u depth=%u parent %u depth=%u\n",
  75                       id, snapshot_t(c, id)->depth,
  76                       parent, snapshot_t(c, parent)->depth);
  77
  78         return parent;
  79 #else
  80         return snapshot_t(c, id)->parent;
  81 #endif
  82 }
  83
  84 static inline u32 bch2_snapshot_parent(struct bch_fs *c, u32 id)
  85 {
  86         rcu_read_lock();
  87         id = __bch2_snapshot_parent(c, id);
  88         rcu_read_unlock();
  89
  90         return id;
  91 }
  92
  93 static inline u32 bch2_snapshot_nth_parent(struct bch_fs *c, u32 id, u32 n)
  94 {
  95         rcu_read_lock();
  96         while (n--)
  97                 id = __bch2_snapshot_parent(c, id);
  98         rcu_read_unlock();
  99
 100         return id;
 101 }
 102
 103 u32 bch2_snapshot_skiplist_get(struct bch_fs *, u32);
 104
 105 static inline u32 bch2_snapshot_root(struct bch_fs *c, u32 id)
 106 {
 107         u32 parent;
 108
 109         rcu_read_lock();
 110         while ((parent = __bch2_snapshot_parent(c, id)))
 111                 id = parent;
 112         rcu_read_unlock();
 113
 114         return id;
 115 }
 116
 117 static inline u32 __bch2_snapshot_equiv(struct bch_fs *c, u32 id)
 118 {
 119         return snapshot_t(c, id)->equiv;
 120 }
 121
 122 static inline u32 bch2_snapshot_equiv(struct bch_fs *c, u32 id)
 123 {
 124         rcu_read_lock();
 125         id = __bch2_snapshot_equiv(c, id);
 126         rcu_read_unlock();
 127
 128         return id;
 129 }
 130
 131 static inline bool bch2_snapshot_is_equiv(struct bch_fs *c, u32 id)
 132 {
 133         return id == bch2_snapshot_equiv(c, id);
 134 }
 135
 136 static inline bool bch2_snapshot_is_internal_node(struct bch_fs *c, u32 id)
 137 {
 138         const struct snapshot_t *s;
 139         bool ret;
 140
 141         rcu_read_lock();
 142         s = snapshot_t(c, id);
 143         ret = s->children[0];
 144         rcu_read_unlock();
 145
 146         return ret;
 147 }
 148
 149 static inline u32 bch2_snapshot_is_leaf(struct bch_fs *c, u32 id)
 150 {
 151         return !bch2_snapshot_is_internal_node(c, id);
 152 }
 153
 154 static inline u32 bch2_snapshot_sibling(struct bch_fs *c, u32 id)
 155 {
 156         const struct snapshot_t *s;
 157         u32 parent = __bch2_snapshot_parent(c, id);
 158
 159         if (!parent)
 160                 return 0;
 161
 162         s = snapshot_t(c, __bch2_snapshot_parent(c, id));
 163         if (id == s->children[0])
 164                 return s->children[1];
 165         if (id == s->children[1])
 166                 return s->children[0];
 167         return 0;
 168 }
 169
 170 static inline u32 bch2_snapshot_depth(struct bch_fs *c, u32 parent)
 171 {
 172         u32 depth;
 173
 174         rcu_read_lock();
 175         depth = parent ? snapshot_t(c, parent)->depth + 1 : 0;
 176         rcu_read_unlock();
 177
 178         return depth;
 179 }
 180
 181 bool __bch2_snapshot_is_ancestor(struct bch_fs *, u32, u32);
 182
 183 static inline bool bch2_snapshot_is_ancestor(struct bch_fs *c, u32 id, u32 ancestor)
 184 {
 185         return id == ancestor
 186                 ? true
 187                 : __bch2_snapshot_is_ancestor(c, id, ancestor);
 188 }
 189
 190 static inline bool bch2_snapshot_has_children(struct bch_fs *c, u32 id)
 191 {
 192         const struct snapshot_t *t;
 193         bool ret;
 194
 195         rcu_read_lock();
 196         t = snapshot_t(c, id);
 197         ret = (t->children[0]|t->children[1]) != 0;
 198         rcu_read_unlock();
 199
 200         return ret;
 201 }
 202
 203 static inline bool snapshot_list_has_id(snapshot_id_list *s, u32 id)
 204 {
 205         u32 *i;
 206
 207         darray_for_each(*s, i)
 208                 if (*i == id)
 209                         return true;
 210         return false;
 211 }
 212
 213 static inline bool snapshot_list_has_ancestor(struct bch_fs *c, snapshot_id_list *s, u32 id)
 214 {
 215         u32 *i;
 216
 217         darray_for_each(*s, i)
 218                 if (bch2_snapshot_is_ancestor(c, id, *i))
 219                         return true;
 220         return false;
 221 }
 222
 223 static inline int snapshot_list_add(struct bch_fs *c, snapshot_id_list *s, u32 id)
 224 {
 225         int ret;
 226
 227         BUG_ON(snapshot_list_has_id(s, id));
 228         ret = darray_push(s, id);
 229         if (ret)
 230                 bch_err(c, "error reallocating snapshot_id_list (size %zu)", s->size);
 231         return ret;
 232 }
 233
 234 int bch2_snapshot_lookup(struct btree_trans *trans, u32 id,
 235                          struct bch_snapshot *s);
 236 int bch2_snapshot_get_subvol(struct btree_trans *, u32,
 237                              struct bch_subvolume *);
 238
 239 /* only exported for tests: */
 240 int bch2_snapshot_node_create(struct btree_trans *, u32,
 241                               u32 *, u32 *, unsigned);
 242
 243 int bch2_check_snapshot_trees(struct bch_fs *);
 244 int bch2_check_snapshots(struct bch_fs *);
 245
 246 int bch2_snapshot_node_set_deleted(struct btree_trans *, u32);
 247 void bch2_delete_dead_snapshots_work(struct work_struct *);
 248
 249 int __bch2_key_has_snapshot_overwrites(struct btree_trans *, enum btree_id, struct bpos);
 250
 251 static inline int bch2_key_has_snapshot_overwrites(struct btree_trans *trans,
 252                                           enum btree_id id,
 253                                           struct bpos pos)
 254 {
 255         if (!btree_type_has_snapshots(id) ||
 256             bch2_snapshot_is_leaf(trans->c, pos.snapshot))
 257                 return 0;
 258
 259         return __bch2_key_has_snapshot_overwrites(trans, id, pos);
 260 }
 261
 262 int bch2_propagate_key_to_snapshot_leaves(struct btree_trans *, enum btree_id,
 263                                           struct bkey_s_c, struct bpos *);
 264
 265 int bch2_snapshots_read(struct bch_fs *);
 266 void bch2_fs_snapshots_exit(struct bch_fs *);
 267
 268 #endif /* _BCACHEFS_SNAPSHOT_H */