remove any mention of tier from man pages

[bcachefs-tools-debian] / libbcachefs / bkey_methods.c

diff --git a/libbcachefs/bkey_methods.c b/libbcachefs/bkey_methods.c
index 320e17d108d2660b93ecab1a119e90113ff82f1a..36e0c5152b4793b390d37847f8e84dba0d05b88d 100644 (file)
--- a/libbcachefs/bkey_methods.c
+++ b/libbcachefs/bkey_methods.c
@@ -134,7 +134,7 @@ const char *bch2_bkey_invalid(struct bch_fs *c, struct bkey_s_c k,
 
 const char *bch2_bkey_in_btree_node(struct btree *b, struct bkey_s_c k)
 {
-       if (bkey_cmp(bkey_start_pos(k.k), b->data->min_key) < 0)
+       if (bkey_cmp(k.k->p, b->data->min_key) < 0)
                return "key before start of btree node";
 
        if (bkey_cmp(k.k->p, b->data->max_key) > 0)
@@ -176,13 +176,17 @@ void bch2_bpos_to_text(struct printbuf *out, struct bpos pos)
 
 void bch2_bkey_to_text(struct printbuf *out, const struct bkey *k)
 {
-       pr_buf(out, "u64s %u type %s ", k->u64s,
-              bch2_bkey_types[k->type]);
+       if (k) {
+               pr_buf(out, "u64s %u type %s ", k->u64s,
+                      bch2_bkey_types[k->type]);
 
-       bch2_bpos_to_text(out, k->p);
+               bch2_bpos_to_text(out, k->p);
 
-       pr_buf(out, " snap %u len %u ver %llu",
-              k->p.snapshot, k->size, k->version.lo);
+               pr_buf(out, " snap %u len %u ver %llu",
+                      k->p.snapshot, k->size, k->version.lo);
+       } else {
+               pr_buf(out, "(null)");
+       }
 }
 
 void bch2_val_to_text(struct printbuf *out, struct bch_fs *c,
@@ -198,19 +202,19 @@ void bch2_bkey_val_to_text(struct printbuf *out, struct bch_fs *c,
                           struct bkey_s_c k)
 {
        bch2_bkey_to_text(out, k.k);
-       pr_buf(out, ": ");
-       bch2_val_to_text(out, c, k);
+
+       if (k.k) {
+               pr_buf(out, ": ");
+               bch2_val_to_text(out, c, k);
+       }
 }
 
-void bch2_bkey_swab(const struct bkey_format *f,
-                   struct bkey_packed *k)
+void bch2_bkey_swab_val(struct bkey_s k)
 {
-       const struct bkey_ops *ops = &bch2_bkey_ops[k->type];
-
-       bch2_bkey_swab_key(f, k);
+       const struct bkey_ops *ops = &bch2_bkey_ops[k.k->type];
 
        if (ops->swab)
-               ops->swab(f, k);
+               ops->swab(k);
 }
 
 bool bch2_bkey_normalize(struct bch_fs *c, struct bkey_s k)
@@ -276,3 +280,74 @@ void bch2_bkey_renumber(enum btree_node_type btree_node_type,
                        break;
                }
 }
+
+void __bch2_bkey_compat(unsigned level, enum btree_id btree_id,
+                       unsigned version, unsigned big_endian,
+                       int write,
+                       struct bkey_format *f,
+                       struct bkey_packed *k)
+{
+       const struct bkey_ops *ops;
+       struct bkey uk;
+       struct bkey_s u;
+       int i;
+
+       /*
+        * Do these operations in reverse order in the write path:
+        */
+
+       for (i = 0; i < 4; i++)
+       switch (!write ? i : 3 - i) {
+       case 0:
+               if (big_endian != CPU_BIG_ENDIAN)
+                       bch2_bkey_swab_key(f, k);
+               break;
+       case 1:
+               if (version < bcachefs_metadata_version_bkey_renumber)
+                       bch2_bkey_renumber(__btree_node_type(level, btree_id), k, write);
+               break;
+       case 2:
+               if (version < bcachefs_metadata_version_inode_btree_change &&
+                   btree_id == BTREE_ID_INODES) {
+                       if (!bkey_packed(k)) {
+                               struct bkey_i *u = packed_to_bkey(k);
+                               swap(u->k.p.inode, u->k.p.offset);
+                       } else if (f->bits_per_field[BKEY_FIELD_INODE] &&
+                                  f->bits_per_field[BKEY_FIELD_OFFSET]) {
+                               struct bkey_format tmp = *f, *in = f, *out = &tmp;
+
+                               swap(tmp.bits_per_field[BKEY_FIELD_INODE],
+                                    tmp.bits_per_field[BKEY_FIELD_OFFSET]);
+                               swap(tmp.field_offset[BKEY_FIELD_INODE],
+                                    tmp.field_offset[BKEY_FIELD_OFFSET]);
+
+                               if (!write)
+                                       swap(in, out);
+
+                               uk = __bch2_bkey_unpack_key(in, k);
+                               swap(uk.p.inode, uk.p.offset);
+                               BUG_ON(!bch2_bkey_pack_key(k, &uk, out));
+                       }
+               }
+               break;
+       case 3:
+               if (!bkey_packed(k)) {
+                       u = bkey_i_to_s(packed_to_bkey(k));
+               } else {
+                       uk = __bch2_bkey_unpack_key(f, k);
+                       u.k = &uk;
+                       u.v = bkeyp_val(f, k);
+               }
+
+               if (big_endian != CPU_BIG_ENDIAN)
+                       bch2_bkey_swab_val(u);
+
+               ops = &bch2_bkey_ops[k->type];
+
+               if (ops->compat)
+                       ops->compat(btree_id, version, big_endian, write, u);
+               break;
+       default:
+               BUG();
+       }
+}