1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Code for moving data off a device. 4 */ 5 6 #include "bcachefs.h" 7 #include "bkey_buf.h" 8 #include "btree_update.h" 9 #include "btree_update_interior.h" 10 #include "buckets.h" 11 #include "errcode.h" 12 #include "extents.h" 13 #include "io_write.h" 14 #include "journal.h" 15 #include "keylist.h" 16 #include "migrate.h" 17 #include "move.h" 18 #include "replicas.h" 19 #include "super-io.h" 20 21 static int drop_dev_ptrs(struct bch_fs *c, struct bkey_s k, 22 unsigned dev_idx, int flags, bool metadata) 23 { 24 unsigned replicas = metadata ? c->opts.metadata_replicas : c->opts.data_replicas; 25 unsigned lost = metadata ? BCH_FORCE_IF_METADATA_LOST : BCH_FORCE_IF_DATA_LOST; 26 unsigned degraded = metadata ? BCH_FORCE_IF_METADATA_DEGRADED : BCH_FORCE_IF_DATA_DEGRADED; 27 unsigned nr_good; 28 29 bch2_bkey_drop_device(k, dev_idx); 30 31 nr_good = bch2_bkey_durability(c, k.s_c); 32 if ((!nr_good && !(flags & lost)) || 33 (nr_good < replicas && !(flags & degraded))) 34 return -EINVAL; 35 36 return 0; 37 } 38 39 static int bch2_dev_usrdata_drop_key(struct btree_trans *trans, 40 struct btree_iter *iter, 41 struct bkey_s_c k, 42 unsigned dev_idx, 43 int flags) 44 { 45 struct bch_fs *c = trans->c; 46 struct bkey_i *n; 47 int ret; 48 49 if (!bch2_bkey_has_device_c(k, dev_idx)) 50 return 0; 51 52 n = bch2_bkey_make_mut(trans, iter, &k, BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE); 53 ret = PTR_ERR_OR_ZERO(n); 54 if (ret) 55 return ret; 56 57 ret = drop_dev_ptrs(c, bkey_i_to_s(n), dev_idx, flags, false); 58 if (ret) 59 return ret; 60 61 /* 62 * If the new extent no longer has any pointers, bch2_extent_normalize() 63 * will do the appropriate thing with it (turning it into a 64 * KEY_TYPE_error key, or just a discard if it was a cached extent) 65 */ 66 bch2_extent_normalize(c, bkey_i_to_s(n)); 67 68 /* 69 * Since we're not inserting through an extent iterator 70 * (BTREE_ITER_ALL_SNAPSHOTS iterators aren't extent iterators), 71 * we aren't using the extent overwrite path to delete, we're 72 * just using the normal key deletion path: 73 */ 74 if (bkey_deleted(&n->k)) 75 n->k.size = 0; 76 return 0; 77 } 78 79 static int bch2_dev_usrdata_drop(struct bch_fs *c, unsigned dev_idx, int flags) 80 { 81 struct btree_trans *trans = bch2_trans_get(c); 82 struct btree_iter iter; 83 struct bkey_s_c k; 84 enum btree_id id; 85 int ret = 0; 86 87 for (id = 0; id < BTREE_ID_NR; id++) { 88 if (!btree_type_has_ptrs(id)) 89 continue; 90 91 ret = for_each_btree_key_commit(trans, iter, id, POS_MIN, 92 BTREE_ITER_PREFETCH|BTREE_ITER_ALL_SNAPSHOTS, k, 93 NULL, NULL, BTREE_INSERT_NOFAIL, 94 bch2_dev_usrdata_drop_key(trans, &iter, k, dev_idx, flags)); 95 if (ret) 96 break; 97 } 98 99 bch2_trans_put(trans); 100 101 return ret; 102 } 103 104 static int bch2_dev_metadata_drop(struct bch_fs *c, unsigned dev_idx, int flags) 105 { 106 struct btree_trans *trans; 107 struct btree_iter iter; 108 struct closure cl; 109 struct btree *b; 110 struct bkey_buf k; 111 unsigned id; 112 int ret; 113 114 /* don't handle this yet: */ 115 if (flags & BCH_FORCE_IF_METADATA_LOST) 116 return -EINVAL; 117 118 trans = bch2_trans_get(c); 119 bch2_bkey_buf_init(&k); 120 closure_init_stack(&cl); 121 122 for (id = 0; id < BTREE_ID_NR; id++) { 123 bch2_trans_node_iter_init(trans, &iter, id, POS_MIN, 0, 0, 124 BTREE_ITER_PREFETCH); 125 retry: 126 ret = 0; 127 while (bch2_trans_begin(trans), 128 (b = bch2_btree_iter_peek_node(&iter)) && 129 !(ret = PTR_ERR_OR_ZERO(b))) { 130 if (!bch2_bkey_has_device_c(bkey_i_to_s_c(&b->key), dev_idx)) 131 goto next; 132 133 bch2_bkey_buf_copy(&k, c, &b->key); 134 135 ret = drop_dev_ptrs(c, bkey_i_to_s(k.k), 136 dev_idx, flags, true); 137 if (ret) { 138 bch_err(c, "Cannot drop device without losing data"); 139 break; 140 } 141 142 ret = bch2_btree_node_update_key(trans, &iter, b, k.k, 0, false); 143 if (bch2_err_matches(ret, BCH_ERR_transaction_restart)) { 144 ret = 0; 145 continue; 146 } 147 148 if (ret) { 149 bch_err_msg(c, ret, "updating btree node key"); 150 break; 151 } 152 next: 153 bch2_btree_iter_next_node(&iter); 154 } 155 if (bch2_err_matches(ret, BCH_ERR_transaction_restart)) 156 goto retry; 157 158 bch2_trans_iter_exit(trans, &iter); 159 160 if (ret) 161 goto err; 162 } 163 164 bch2_btree_interior_updates_flush(c); 165 ret = 0; 166 err: 167 bch2_bkey_buf_exit(&k, c); 168 bch2_trans_put(trans); 169 170 BUG_ON(bch2_err_matches(ret, BCH_ERR_transaction_restart)); 171 172 return ret; 173 } 174 175 int bch2_dev_data_drop(struct bch_fs *c, unsigned dev_idx, int flags) 176 { 177 return bch2_dev_usrdata_drop(c, dev_idx, flags) ?: 178 bch2_dev_metadata_drop(c, dev_idx, flags); 179 } 180