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

   1
   2 #include "bcachefs.h"
   3 #include "bkey_methods.h"
   4 #include "btree_types.h"
   5 #include "alloc.h"
   6 #include "dirent.h"
   7 #include "error.h"
   8 #include "extents.h"
   9 #include "inode.h"
  10 #include "quota.h"
  11 #include "xattr.h"
  12
  13 const struct bkey_ops *bch2_bkey_ops[] = {
  14         [BKEY_TYPE_EXTENTS]     = &bch2_bkey_extent_ops,
  15         [BKEY_TYPE_INODES]      = &bch2_bkey_inode_ops,
  16         [BKEY_TYPE_DIRENTS]     = &bch2_bkey_dirent_ops,
  17         [BKEY_TYPE_XATTRS]      = &bch2_bkey_xattr_ops,
  18         [BKEY_TYPE_ALLOC]       = &bch2_bkey_alloc_ops,
  19         [BKEY_TYPE_QUOTAS]      = &bch2_bkey_quota_ops,
  20         [BKEY_TYPE_BTREE]       = &bch2_bkey_btree_ops,
  21 };
  22
  23 const char *bch2_bkey_val_invalid(struct bch_fs *c, enum bkey_type type,
  24                                   struct bkey_s_c k)
  25 {
  26         const struct bkey_ops *ops = bch2_bkey_ops[type];
  27
  28         switch (k.k->type) {
  29         case KEY_TYPE_DELETED:
  30         case KEY_TYPE_DISCARD:
  31                 return NULL;
  32
  33         case KEY_TYPE_ERROR:
  34                 return bkey_val_bytes(k.k) != 0
  35                         ? "value size should be zero"
  36                         : NULL;
  37
  38         case KEY_TYPE_COOKIE:
  39                 return bkey_val_bytes(k.k) != sizeof(struct bch_cookie)
  40                         ? "incorrect value size"
  41                         : NULL;
  42
  43         default:
  44                 if (k.k->type < KEY_TYPE_GENERIC_NR)
  45                         return "invalid type";
  46
  47                 return ops->key_invalid(c, k);
  48         }
  49 }
  50
  51 const char *__bch2_bkey_invalid(struct bch_fs *c, enum bkey_type type,
  52                               struct bkey_s_c k)
  53 {
  54         const struct bkey_ops *ops = bch2_bkey_ops[type];
  55
  56         if (k.k->u64s < BKEY_U64s)
  57                 return "u64s too small";
  58
  59         if (!ops->is_extents) {
  60                 if (k.k->size)
  61                         return "nonzero size field";
  62         } else {
  63                 if ((k.k->size == 0) != bkey_deleted(k.k))
  64                         return "bad size field";
  65         }
  66
  67         if (ops->is_extents &&
  68             !k.k->size &&
  69             !bkey_deleted(k.k))
  70                 return "zero size field";
  71
  72         if (k.k->p.snapshot)
  73                 return "nonzero snapshot";
  74
  75         return NULL;
  76 }
  77
  78 const char *bch2_bkey_invalid(struct bch_fs *c, enum bkey_type type,
  79                               struct bkey_s_c k)
  80 {
  81         return __bch2_bkey_invalid(c, type, k) ?:
  82                 bch2_bkey_val_invalid(c, type, k);
  83 }
  84
  85 const char *bch2_bkey_in_btree_node(struct btree *b, struct bkey_s_c k)
  86 {
  87         if (bkey_cmp(bkey_start_pos(k.k), b->data->min_key) < 0)
  88                 return "key before start of btree node";
  89
  90         if (bkey_cmp(k.k->p, b->data->max_key) > 0)
  91                 return "key past end of btree node";
  92
  93         return NULL;
  94 }
  95
  96 void bch2_bkey_debugcheck(struct bch_fs *c, struct btree *b, struct bkey_s_c k)
  97 {
  98         enum bkey_type type = btree_node_type(b);
  99         const struct bkey_ops *ops = bch2_bkey_ops[type];
 100         const char *invalid;
 101
 102         BUG_ON(!k.k->u64s);
 103
 104         invalid = bch2_bkey_invalid(c, type, k) ?:
 105                 bch2_bkey_in_btree_node(b, k);
 106         if (invalid) {
 107                 char buf[160];
 108
 109                 bch2_bkey_val_to_text(c, type, buf, sizeof(buf), k);
 110                 bch2_fs_bug(c, "invalid bkey %s: %s", buf, invalid);
 111                 return;
 112         }
 113
 114         if (k.k->type >= KEY_TYPE_GENERIC_NR &&
 115             ops->key_debugcheck)
 116                 ops->key_debugcheck(c, b, k);
 117 }
 118
 119 #define p(...)  (out += scnprintf(out, end - out, __VA_ARGS__))
 120
 121 int bch2_bkey_to_text(char *buf, size_t size, const struct bkey *k)
 122 {
 123         char *out = buf, *end = buf + size;
 124
 125         p("u64s %u type %u ", k->u64s, k->type);
 126
 127         if (bkey_cmp(k->p, POS_MAX))
 128                 p("%llu:%llu", k->p.inode, k->p.offset);
 129         else
 130                 p("POS_MAX");
 131
 132         p(" snap %u len %u ver %llu", k->p.snapshot, k->size, k->version.lo);
 133
 134         return out - buf;
 135 }
 136
 137 int bch2_val_to_text(struct bch_fs *c, enum bkey_type type,
 138                      char *buf, size_t size, struct bkey_s_c k)
 139 {
 140         const struct bkey_ops *ops = bch2_bkey_ops[type];
 141         char *out = buf, *end = buf + size;
 142
 143         switch (k.k->type) {
 144         case KEY_TYPE_DELETED:
 145                 p(" deleted");
 146                 break;
 147         case KEY_TYPE_DISCARD:
 148                 p(" discard");
 149                 break;
 150         case KEY_TYPE_ERROR:
 151                 p(" error");
 152                 break;
 153         case KEY_TYPE_COOKIE:
 154                 p(" cookie");
 155                 break;
 156         default:
 157                 if (k.k->type >= KEY_TYPE_GENERIC_NR && ops->val_to_text)
 158                         ops->val_to_text(c, buf, size, k);
 159                 break;
 160         }
 161
 162         return out - buf;
 163 }
 164
 165 int bch2_bkey_val_to_text(struct bch_fs *c, enum bkey_type type,
 166                           char *buf, size_t size, struct bkey_s_c k)
 167 {
 168         char *out = buf, *end = buf + size;
 169
 170         out += bch2_bkey_to_text(out, end - out, k.k);
 171         out += scnprintf(out, end - out, ": ");
 172         out += bch2_val_to_text(c, type, out, end - out, k);
 173
 174         return out - buf;
 175 }
 176
 177 void bch2_bkey_swab(enum bkey_type type,
 178                    const struct bkey_format *f,
 179                    struct bkey_packed *k)
 180 {
 181         const struct bkey_ops *ops = bch2_bkey_ops[type];
 182
 183         bch2_bkey_swab_key(f, k);
 184
 185         if (ops->swab)
 186                 ops->swab(f, k);
 187 }