]> git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/migrate.c
Update bcachefs sources to 380885b0b8 bcachefs: Fix counting iterators for reflink...
[bcachefs-tools-debian] / libbcachefs / migrate.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Code for moving data off a device.
4  */
5
6 #include "bcachefs.h"
7 #include "btree_update.h"
8 #include "btree_update_interior.h"
9 #include "buckets.h"
10 #include "extents.h"
11 #include "io.h"
12 #include "journal.h"
13 #include "keylist.h"
14 #include "migrate.h"
15 #include "move.h"
16 #include "replicas.h"
17 #include "super-io.h"
18
19 static int drop_dev_ptrs(struct bch_fs *c, struct bkey_s k,
20                          unsigned dev_idx, int flags, bool metadata)
21 {
22         unsigned replicas = metadata ? c->opts.metadata_replicas : c->opts.data_replicas;
23         unsigned lost = metadata ? BCH_FORCE_IF_METADATA_LOST : BCH_FORCE_IF_DATA_LOST;
24         unsigned degraded = metadata ? BCH_FORCE_IF_METADATA_DEGRADED : BCH_FORCE_IF_DATA_DEGRADED;
25         unsigned nr_good;
26
27         bch2_bkey_drop_device(k, dev_idx);
28
29         nr_good = bch2_bkey_durability(c, k.s_c);
30         if ((!nr_good && !(flags & lost)) ||
31             (nr_good < replicas && !(flags & degraded)))
32                 return -EINVAL;
33
34         return 0;
35 }
36
37 static int __bch2_dev_usrdata_drop(struct bch_fs *c, unsigned dev_idx, int flags,
38                                    enum btree_id btree_id)
39 {
40         struct btree_trans trans;
41         struct btree_iter *iter;
42         struct bkey_s_c k;
43         BKEY_PADDED(key) tmp;
44         int ret = 0;
45
46         bch2_trans_init(&trans, c, BTREE_ITER_MAX, 0);
47
48         iter = bch2_trans_get_iter(&trans, btree_id, POS_MIN,
49                                    BTREE_ITER_PREFETCH);
50
51         while ((k = bch2_btree_iter_peek(iter)).k &&
52                !(ret = bkey_err(k))) {
53                 if (!bch2_bkey_has_device(k, dev_idx)) {
54                         ret = bch2_mark_bkey_replicas(c, k);
55                         if (ret)
56                                 break;
57                         bch2_btree_iter_next(iter);
58                         continue;
59                 }
60
61                 bkey_reassemble(&tmp.key, k);
62
63                 ret = drop_dev_ptrs(c, bkey_i_to_s(&tmp.key),
64                                     dev_idx, flags, false);
65                 if (ret)
66                         break;
67
68                 /*
69                  * If the new extent no longer has any pointers, bch2_extent_normalize()
70                  * will do the appropriate thing with it (turning it into a
71                  * KEY_TYPE_error key, or just a discard if it was a cached extent)
72                  */
73                 bch2_extent_normalize(c, bkey_i_to_s(&tmp.key));
74
75                 bch2_btree_iter_set_pos(iter, bkey_start_pos(&tmp.key.k));
76
77                 bch2_trans_update(&trans, iter, &tmp.key);
78
79                 ret = bch2_trans_commit(&trans, NULL, NULL,
80                                         BTREE_INSERT_ATOMIC|
81                                         BTREE_INSERT_NOFAIL);
82
83                 /*
84                  * don't want to leave ret == -EINTR, since if we raced and
85                  * something else overwrote the key we could spuriously return
86                  * -EINTR below:
87                  */
88                 if (ret == -EINTR)
89                         ret = 0;
90                 if (ret)
91                         break;
92         }
93
94         ret = bch2_trans_exit(&trans) ?: ret;
95
96         BUG_ON(ret == -EINTR);
97
98         return ret;
99 }
100
101 static int bch2_dev_usrdata_drop(struct bch_fs *c, unsigned dev_idx, int flags)
102 {
103         return  __bch2_dev_usrdata_drop(c, dev_idx, flags, BTREE_ID_EXTENTS) ?:
104                 __bch2_dev_usrdata_drop(c, dev_idx, flags, BTREE_ID_REFLINK);
105 }
106
107 static int bch2_dev_metadata_drop(struct bch_fs *c, unsigned dev_idx, int flags)
108 {
109         struct btree_trans trans;
110         struct btree_iter *iter;
111         struct closure cl;
112         struct btree *b;
113         unsigned id;
114         int ret;
115
116         /* don't handle this yet: */
117         if (flags & BCH_FORCE_IF_METADATA_LOST)
118                 return -EINVAL;
119
120         bch2_trans_init(&trans, c, 0, 0);
121         closure_init_stack(&cl);
122
123         for (id = 0; id < BTREE_ID_NR; id++) {
124                 for_each_btree_node(&trans, iter, id, POS_MIN,
125                                     BTREE_ITER_PREFETCH, b) {
126                         __BKEY_PADDED(k, BKEY_BTREE_PTR_VAL_U64s_MAX) tmp;
127                         struct bkey_i_btree_ptr *new_key;
128 retry:
129                         if (!bch2_bkey_has_device(bkey_i_to_s_c(&b->key),
130                                                   dev_idx)) {
131                                 /*
132                                  * we might have found a btree node key we
133                                  * needed to update, and then tried to update it
134                                  * but got -EINTR after upgrading the iter, but
135                                  * then raced and the node is now gone:
136                                  */
137                                 bch2_btree_iter_downgrade(iter);
138
139                                 ret = bch2_mark_bkey_replicas(c, bkey_i_to_s_c(&b->key));
140                                 if (ret)
141                                         goto err;
142                         } else {
143                                 bkey_copy(&tmp.k, &b->key);
144                                 new_key = bkey_i_to_btree_ptr(&tmp.k);
145
146                                 ret = drop_dev_ptrs(c, bkey_i_to_s(&new_key->k_i),
147                                                     dev_idx, flags, true);
148                                 if (ret)
149                                         goto err;
150
151                                 ret = bch2_btree_node_update_key(c, iter, b, new_key);
152                                 if (ret == -EINTR) {
153                                         b = bch2_btree_iter_peek_node(iter);
154                                         goto retry;
155                                 }
156                                 if (ret)
157                                         goto err;
158                         }
159                 }
160                 bch2_trans_iter_free(&trans, iter);
161         }
162
163         /* flush relevant btree updates */
164         while (1) {
165                 closure_wait_event(&c->btree_interior_update_wait,
166                                    !bch2_btree_interior_updates_nr_pending(c) ||
167                                    c->btree_roots_dirty);
168                 if (!bch2_btree_interior_updates_nr_pending(c))
169                         break;
170                 bch2_journal_meta(&c->journal);
171         }
172
173         ret = 0;
174 err:
175         ret = bch2_trans_exit(&trans) ?: ret;
176
177         BUG_ON(ret == -EINTR);
178
179         return ret;
180 }
181
182 int bch2_dev_data_drop(struct bch_fs *c, unsigned dev_idx, int flags)
183 {
184         return bch2_dev_usrdata_drop(c, dev_idx, flags) ?:
185                 bch2_dev_metadata_drop(c, dev_idx, flags) ?:
186                 bch2_replicas_gc2(c);
187 }