Update bcachefs sources to 5963d1b1a4 bcacehfs: Fix bch2_get_alloc_in_memory_pos()

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

diff --git a/libbcachefs/extents.c b/libbcachefs/extents.c
index 1274d506085db54277a5a7d6455a1f1e47a8bd81..9b197db78260b0997f056361a179398ee2cce247 100644 (file)
--- a/libbcachefs/extents.c
+++ b/libbcachefs/extents.c
@@ -171,7 +171,7 @@ int bch2_btree_ptr_invalid(const struct bch_fs *c, struct bkey_s_c k,
        if (bkey_val_u64s(k.k) > BCH_REPLICAS_MAX) {
                prt_printf(err, "value too big (%zu > %u)",
                       bkey_val_u64s(k.k), BCH_REPLICAS_MAX);
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        return bch2_bkey_ptrs_invalid(c, k, rw, err);
@@ -191,20 +191,20 @@ int bch2_btree_ptr_v2_invalid(const struct bch_fs *c, struct bkey_s_c k,
        if (bkey_val_bytes(k.k) <= sizeof(*bp.v)) {
                prt_printf(err, "value too small (%zu <= %zu)",
                       bkey_val_bytes(k.k), sizeof(*bp.v));
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        if (bkey_val_u64s(k.k) > BKEY_BTREE_PTR_VAL_U64s_MAX) {
                prt_printf(err, "value too big (%zu > %zu)",
                       bkey_val_u64s(k.k), BKEY_BTREE_PTR_VAL_U64s_MAX);
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        if (c->sb.version < bcachefs_metadata_version_snapshot &&
            bp.v->min_key.snapshot) {
                prt_printf(err, "invalid min_key.snapshot (%u != 0)",
                       bp.v->min_key.snapshot);
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        return bch2_bkey_ptrs_invalid(c, k, rw, err);
@@ -235,7 +235,7 @@ void bch2_btree_ptr_v2_compat(enum btree_id btree_id, unsigned version,
 
        if (version < bcachefs_metadata_version_inode_btree_change &&
            btree_node_type_is_extents(btree_id) &&
-           bkey_cmp(bp.v->min_key, POS_MIN))
+           !bkey_eq(bp.v->min_key, POS_MIN))
                bp.v->min_key = write
                        ? bpos_nosnap_predecessor(bp.v->min_key)
                        : bpos_nosnap_successor(bp.v->min_key);
@@ -396,13 +396,13 @@ int bch2_reservation_invalid(const struct bch_fs *c, struct bkey_s_c k,
        if (bkey_val_bytes(k.k) != sizeof(struct bch_reservation)) {
                prt_printf(err, "incorrect value size (%zu != %zu)",
                       bkey_val_bytes(k.k), sizeof(*r.v));
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        if (!r.v->nr_replicas || r.v->nr_replicas > BCH_REPLICAS_MAX) {
                prt_printf(err, "invalid nr_replicas (%u)",
                       r.v->nr_replicas);
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        return 0;
@@ -706,29 +706,6 @@ void bch2_bkey_extent_entry_drop(struct bkey_i *k, union bch_extent_entry *entry
        k->k.u64s -= extent_entry_u64s(entry);
 }
 
-void bch2_bkey_append_ptr(struct bkey_i *k,
-                         struct bch_extent_ptr ptr)
-{
-       EBUG_ON(bch2_bkey_has_device(bkey_i_to_s_c(k), ptr.dev));
-
-       switch (k->k.type) {
-       case KEY_TYPE_btree_ptr:
-       case KEY_TYPE_btree_ptr_v2:
-       case KEY_TYPE_extent:
-               EBUG_ON(bkey_val_u64s(&k->k) >= BKEY_EXTENT_VAL_U64s_MAX);
-
-               ptr.type = 1 << BCH_EXTENT_ENTRY_ptr;
-
-               memcpy((void *) &k->v + bkey_val_bytes(&k->k),
-                      &ptr,
-                      sizeof(ptr));
-               k->u64s++;
-               break;
-       default:
-               BUG();
-       }
-}
-
 static inline void __extent_entry_insert(struct bkey_i *k,
                                         union bch_extent_entry *dst,
                                         union bch_extent_entry *new)
@@ -1075,14 +1052,14 @@ static int extent_ptr_invalid(const struct bch_fs *c,
 
        if (!bch2_dev_exists2(c, ptr->dev)) {
                prt_printf(err, "pointer to invalid device (%u)", ptr->dev);
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        ca = bch_dev_bkey_exists(c, ptr->dev);
        bkey_for_each_ptr(ptrs, ptr2)
                if (ptr != ptr2 && ptr->dev == ptr2->dev) {
                        prt_printf(err, "multiple pointers to same device (%u)", ptr->dev);
-                       return -EINVAL;
+                       return -BCH_ERR_invalid_bkey;
                }
 
        bucket = sector_to_bucket_and_offset(ca, ptr->offset, &bucket_offset);
@@ -1090,19 +1067,19 @@ static int extent_ptr_invalid(const struct bch_fs *c,
        if (bucket >= ca->mi.nbuckets) {
                prt_printf(err, "pointer past last bucket (%llu > %llu)",
                       bucket, ca->mi.nbuckets);
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        if (ptr->offset < bucket_to_sector(ca, ca->mi.first_bucket)) {
                prt_printf(err, "pointer before first bucket (%llu < %u)",
                       bucket, ca->mi.first_bucket);
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        if (bucket_offset + size_ondisk > ca->mi.bucket_size) {
                prt_printf(err, "pointer spans multiple buckets (%u + %u > %u)",
                       bucket_offset, size_ondisk, ca->mi.bucket_size);
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        return 0;
@@ -1127,13 +1104,13 @@ int bch2_bkey_ptrs_invalid(const struct bch_fs *c, struct bkey_s_c k,
                if (__extent_entry_type(entry) >= BCH_EXTENT_ENTRY_MAX) {
                        prt_printf(err, "invalid extent entry type (got %u, max %u)",
                               __extent_entry_type(entry), BCH_EXTENT_ENTRY_MAX);
-                       return -EINVAL;
+                       return -BCH_ERR_invalid_bkey;
                }
 
                if (bkey_is_btree_ptr(k.k) &&
                    !extent_entry_is_ptr(entry)) {
                        prt_printf(err, "has non ptr field");
-                       return -EINVAL;
+                       return -BCH_ERR_invalid_bkey;
                }
 
                switch (extent_entry_type(entry)) {
@@ -1145,12 +1122,12 @@ int bch2_bkey_ptrs_invalid(const struct bch_fs *c, struct bkey_s_c k,
 
                        if (nr_ptrs && unwritten != entry->ptr.unwritten) {
                                prt_printf(err, "extent with unwritten and written ptrs");
-                               return -EINVAL;
+                               return -BCH_ERR_invalid_bkey;
                        }
 
                        if (k.k->type != KEY_TYPE_extent && entry->ptr.unwritten) {
                                prt_printf(err, "has unwritten ptrs");
-                               return -EINVAL;
+                               return -BCH_ERR_invalid_bkey;
                        }
 
                        unwritten = entry->ptr.unwritten;
@@ -1164,19 +1141,19 @@ int bch2_bkey_ptrs_invalid(const struct bch_fs *c, struct bkey_s_c k,
                        if (crc.offset + crc.live_size >
                            crc.uncompressed_size) {
                                prt_printf(err, "checksum offset + key size > uncompressed size");
-                               return -EINVAL;
+                               return -BCH_ERR_invalid_bkey;
                        }
 
                        size_ondisk = crc.compressed_size;
 
                        if (!bch2_checksum_type_valid(c, crc.csum_type)) {
                                prt_printf(err, "invalid checksum type");
-                               return -EINVAL;
+                               return -BCH_ERR_invalid_bkey;
                        }
 
                        if (crc.compression_type >= BCH_COMPRESSION_TYPE_NR) {
                                prt_printf(err, "invalid compression type");
-                               return -EINVAL;
+                               return -BCH_ERR_invalid_bkey;
                        }
 
                        if (bch2_csum_type_is_encryption(crc.csum_type)) {
@@ -1184,7 +1161,7 @@ int bch2_bkey_ptrs_invalid(const struct bch_fs *c, struct bkey_s_c k,
                                        nonce = crc.offset + crc.nonce;
                                else if (nonce != crc.offset + crc.nonce) {
                                        prt_printf(err, "incorrect nonce");
-                                       return -EINVAL;
+                                       return -BCH_ERR_invalid_bkey;
                                }
                        }
                        break;
@@ -1195,7 +1172,7 @@ int bch2_bkey_ptrs_invalid(const struct bch_fs *c, struct bkey_s_c k,
 
        if (nr_ptrs >= BCH_BKEY_PTRS_MAX) {
                prt_str(err, "too many ptrs");
-               return -EINVAL;
+               return -BCH_ERR_invalid_bkey;
        }
 
        return 0;
@@ -1245,10 +1222,10 @@ int bch2_cut_front_s(struct bpos where, struct bkey_s k)
        int val_u64s_delta;
        u64 sub;
 
-       if (bkey_cmp(where, bkey_start_pos(k.k)) <= 0)
+       if (bkey_le(where, bkey_start_pos(k.k)))
                return 0;
 
-       EBUG_ON(bkey_cmp(where, k.k->p) > 0);
+       EBUG_ON(bkey_gt(where, k.k->p));
 
        sub = where.offset - bkey_start_offset(k.k);
 
@@ -1325,10 +1302,10 @@ int bch2_cut_back_s(struct bpos where, struct bkey_s k)
        int val_u64s_delta;
        u64 len = 0;
 
-       if (bkey_cmp(where, k.k->p) >= 0)
+       if (bkey_ge(where, k.k->p))
                return 0;
 
-       EBUG_ON(bkey_cmp(where, bkey_start_pos(k.k)) < 0);
+       EBUG_ON(bkey_lt(where, bkey_start_pos(k.k)));
 
        len = where.offset - bkey_start_offset(k.k);