git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/reflink.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "bcachefs.h"
   3 #include "btree_update.h"
   4 #include "extents.h"
   5 #include "fs.h"
   6 #include "fs-io.h"
   7 #include "reflink.h"
   8
   9 #include <linux/sched/signal.h>
  10
  11 /* reflink pointers */
  12
  13 const char *bch2_reflink_p_invalid(const struct bch_fs *c, struct bkey_s_c k)
  14 {
  15         struct bkey_s_c_reflink_p p = bkey_s_c_to_reflink_p(k);
  16
  17         if (bkey_val_bytes(p.k) != sizeof(*p.v))
  18                 return "incorrect value size";
  19
  20         return NULL;
  21 }
  22
  23 void bch2_reflink_p_to_text(struct printbuf *out, struct bch_fs *c,
  24                             struct bkey_s_c k)
  25 {
  26         struct bkey_s_c_reflink_p p = bkey_s_c_to_reflink_p(k);
  27
  28         pr_buf(out, "idx %llu", le64_to_cpu(p.v->idx));
  29 }
  30
  31 enum merge_result bch2_reflink_p_merge(struct bch_fs *c,
  32                                        struct bkey_s _l, struct bkey_s _r)
  33 {
  34         struct bkey_s_reflink_p l = bkey_s_to_reflink_p(_l);
  35         struct bkey_s_reflink_p r = bkey_s_to_reflink_p(_r);
  36
  37         if (le64_to_cpu(l.v->idx) + l.k->size != le64_to_cpu(r.v->idx))
  38                 return BCH_MERGE_NOMERGE;
  39
  40         if ((u64) l.k->size + r.k->size > KEY_SIZE_MAX) {
  41                 bch2_key_resize(l.k, KEY_SIZE_MAX);
  42                 __bch2_cut_front(l.k->p, _r);
  43                 return BCH_MERGE_PARTIAL;
  44         }
  45
  46         bch2_key_resize(l.k, l.k->size + r.k->size);
  47
  48         return BCH_MERGE_MERGE;
  49 }
  50
  51 /* indirect extents */
  52
  53 const char *bch2_reflink_v_invalid(const struct bch_fs *c, struct bkey_s_c k)
  54 {
  55         struct bkey_s_c_reflink_v r = bkey_s_c_to_reflink_v(k);
  56
  57         if (bkey_val_bytes(r.k) < sizeof(*r.v))
  58                 return "incorrect value size";
  59
  60         return bch2_bkey_ptrs_invalid(c, k);
  61 }
  62
  63 void bch2_reflink_v_to_text(struct printbuf *out, struct bch_fs *c,
  64                             struct bkey_s_c k)
  65 {
  66         struct bkey_s_c_reflink_v r = bkey_s_c_to_reflink_v(k);
  67
  68         pr_buf(out, "refcount: %llu ", le64_to_cpu(r.v->refcount));
  69
  70         bch2_bkey_ptrs_to_text(out, c, k);
  71 }
  72
  73 /*
  74  * bch2_remap_range() depends on bch2_extent_update(), which depends on various
  75  * things tied to the linux vfs for inode updates, for now:
  76  */
  77 #ifndef NO_BCACHEFS_FS
  78
  79 static int bch2_make_extent_indirect(struct btree_trans *trans,
  80                                      struct btree_iter *extent_iter,
  81                                      struct bkey_i_extent *e)
  82 {
  83         struct bch_fs *c = trans->c;
  84         struct btree_iter *reflink_iter;
  85         struct bkey_s_c k;
  86         struct bkey_i_reflink_v *r_v;
  87         struct bkey_i_reflink_p *r_p;
  88         int ret;
  89
  90         for_each_btree_key(trans, reflink_iter, BTREE_ID_REFLINK,
  91                            POS(0, c->reflink_hint),
  92                            BTREE_ITER_INTENT|BTREE_ITER_SLOTS, k, ret) {
  93                 if (reflink_iter->pos.inode) {
  94                         bch2_btree_iter_set_pos(reflink_iter, POS_MIN);
  95                         continue;
  96                 }
  97
  98                 if (bkey_deleted(k.k) && e->k.size <= k.k->size)
  99                         break;
 100         }
 101
 102         if (ret)
 103                 goto err;
 104
 105         /* rewind iter to start of hole, if necessary: */
 106         bch2_btree_iter_set_pos(reflink_iter, bkey_start_pos(k.k));
 107
 108         r_v = bch2_trans_kmalloc(trans, sizeof(*r_v) + bkey_val_bytes(&e->k));
 109         ret = PTR_ERR_OR_ZERO(r_v);
 110         if (ret)
 111                 goto err;
 112
 113         bkey_reflink_v_init(&r_v->k_i);
 114         r_v->k.p        = reflink_iter->pos;
 115         bch2_key_resize(&r_v->k, e->k.size);
 116         r_v->k.version  = e->k.version;
 117
 118         set_bkey_val_u64s(&r_v->k, bkey_val_u64s(&r_v->k) +
 119                           bkey_val_u64s(&e->k));
 120         r_v->v.refcount = 0;
 121         memcpy(r_v->v.start, e->v.start, bkey_val_bytes(&e->k));
 122
 123         bch2_trans_update(trans, reflink_iter, &r_v->k_i);
 124
 125         r_p = bch2_trans_kmalloc(trans, sizeof(*r_p));
 126         if (IS_ERR(r_p))
 127                 return PTR_ERR(r_p);
 128
 129         e->k.type = KEY_TYPE_reflink_p;
 130         r_p = bkey_i_to_reflink_p(&e->k_i);
 131         set_bkey_val_bytes(&r_p->k, sizeof(r_p->v));
 132         r_p->v.idx = cpu_to_le64(bkey_start_offset(&r_v->k));
 133
 134         bch2_trans_update(trans, extent_iter, &r_p->k_i);
 135 err:
 136         if (!IS_ERR(reflink_iter)) {
 137                 c->reflink_hint = reflink_iter->pos.offset;
 138                 bch2_trans_iter_put(trans, reflink_iter);
 139         }
 140
 141         return ret;
 142 }
 143
 144 static struct bkey_s_c get_next_src(struct btree_iter *iter, struct bpos end)
 145 {
 146         struct bkey_s_c k = bch2_btree_iter_peek(iter);
 147
 148         while (1) {
 149                 if (bkey_err(k))
 150                         return k;
 151
 152                 if (bkey_cmp(iter->pos, end) >= 0)
 153                         return bkey_s_c_null;
 154
 155                 if (k.k->type == KEY_TYPE_extent ||
 156                     k.k->type == KEY_TYPE_reflink_p)
 157                         return k;
 158
 159                 k = bch2_btree_iter_next(iter);
 160         }
 161 }
 162
 163 s64 bch2_remap_range(struct bch_fs *c,
 164                      struct bch_inode_info *dst_inode,
 165                      struct bpos dst_start, struct bpos src_start,
 166                      u64 remap_sectors, u64 new_i_size)
 167 {
 168         struct btree_trans trans;
 169         struct btree_iter *dst_iter, *src_iter;
 170         struct bkey_s_c src_k;
 171         BKEY_PADDED(k) new_dst, new_src;
 172         struct bpos dst_end = dst_start, src_end = src_start;
 173         struct bpos dst_want, src_want;
 174         u64 src_done, dst_done;
 175         int ret = 0;
 176
 177         if (!(c->sb.features & (1ULL << BCH_FEATURE_REFLINK))) {
 178                 mutex_lock(&c->sb_lock);
 179                 if (!(c->sb.features & (1ULL << BCH_FEATURE_REFLINK))) {
 180                         c->disk_sb.sb->features[0] |=
 181                                 cpu_to_le64(1ULL << BCH_FEATURE_REFLINK);
 182
 183                         bch2_write_super(c);
 184                 }
 185                 mutex_unlock(&c->sb_lock);
 186         }
 187
 188         dst_end.offset += remap_sectors;
 189         src_end.offset += remap_sectors;
 190
 191         bch2_trans_init(&trans, c, BTREE_ITER_MAX, 4096);
 192
 193         src_iter = bch2_trans_get_iter(&trans, BTREE_ID_EXTENTS, src_start,
 194                                        BTREE_ITER_INTENT);
 195         dst_iter = bch2_trans_get_iter(&trans, BTREE_ID_EXTENTS, dst_start,
 196                                        BTREE_ITER_INTENT);
 197
 198         while (1) {
 199                 bch2_trans_begin_updates(&trans);
 200                 trans.mem_top = 0;
 201
 202                 if (fatal_signal_pending(current)) {
 203                         ret = -EINTR;
 204                         goto err;
 205                 }
 206
 207                 src_k = get_next_src(src_iter, src_end);
 208                 ret = bkey_err(src_k);
 209                 if (ret)
 210                         goto btree_err;
 211
 212                 src_done = bpos_min(src_iter->pos, src_end).offset -
 213                         src_start.offset;
 214                 dst_want = POS(dst_start.inode, dst_start.offset + src_done);
 215
 216                 if (bkey_cmp(dst_iter->pos, dst_want) < 0) {
 217                         ret = bch2_fpunch_at(&trans, dst_iter, dst_want,
 218                                              dst_inode, new_i_size);
 219                         if (ret)
 220                                 goto btree_err;
 221                         continue;
 222                 }
 223
 224                 BUG_ON(bkey_cmp(dst_iter->pos, dst_want));
 225
 226                 if (!bkey_cmp(dst_iter->pos, dst_end))
 227                         break;
 228
 229                 if (src_k.k->type == KEY_TYPE_extent) {
 230                         bkey_reassemble(&new_src.k, src_k);
 231                         src_k = bkey_i_to_s_c(&new_src.k);
 232
 233                         bch2_cut_front(src_iter->pos,   &new_src.k);
 234                         bch2_cut_back(src_end,          &new_src.k.k);
 235
 236                         ret = bch2_make_extent_indirect(&trans, src_iter,
 237                                                 bkey_i_to_extent(&new_src.k));
 238                         if (ret)
 239                                 goto btree_err;
 240
 241                         BUG_ON(src_k.k->type != KEY_TYPE_reflink_p);
 242                 }
 243
 244                 if (src_k.k->type == KEY_TYPE_reflink_p) {
 245                         struct bkey_s_c_reflink_p src_p =
 246                                 bkey_s_c_to_reflink_p(src_k);
 247                         struct bkey_i_reflink_p *dst_p =
 248                                 bkey_reflink_p_init(&new_dst.k);
 249
 250                         u64 offset = le64_to_cpu(src_p.v->idx) +
 251                                 (src_iter->pos.offset -
 252                                  bkey_start_offset(src_k.k));
 253
 254                         dst_p->v.idx = cpu_to_le64(offset);
 255                 } else {
 256                         BUG();
 257                 }
 258
 259                 new_dst.k.k.p = dst_iter->pos;
 260                 bch2_key_resize(&new_dst.k.k,
 261                                 min(src_k.k->p.offset - src_iter->pos.offset,
 262                                     dst_end.offset - dst_iter->pos.offset));
 263
 264                 ret = bch2_extent_update(&trans, dst_inode, NULL, NULL,
 265                                          dst_iter, &new_dst.k,
 266                                          new_i_size, false, true, NULL);
 267                 if (ret)
 268                         goto btree_err;
 269
 270                 dst_done = dst_iter->pos.offset - dst_start.offset;
 271                 src_want = POS(src_start.inode, src_start.offset + dst_done);
 272                 bch2_btree_iter_set_pos(src_iter, src_want);
 273 btree_err:
 274                 if (ret == -EINTR)
 275                         ret = 0;
 276                 if (ret)
 277                         goto err;
 278         }
 279
 280         BUG_ON(bkey_cmp(dst_iter->pos, dst_end));
 281 err:
 282         BUG_ON(bkey_cmp(dst_iter->pos, dst_end) > 0);
 283
 284         dst_done = dst_iter->pos.offset - dst_start.offset;
 285         new_i_size = min(dst_iter->pos.offset << 9, new_i_size);
 286
 287         ret = bch2_trans_exit(&trans) ?: ret;
 288
 289         mutex_lock(&dst_inode->ei_update_lock);
 290         if (dst_inode->v.i_size < new_i_size) {
 291                 i_size_write(&dst_inode->v, new_i_size);
 292                 ret = bch2_write_inode_size(c, dst_inode, new_i_size,
 293                                             ATTR_MTIME|ATTR_CTIME);
 294         }
 295         mutex_unlock(&dst_inode->ei_update_lock);
 296
 297         return dst_done ?: ret;
 298 }
 299
 300 #endif /* NO_BCACHEFS_FS */