summaryrefslogtreecommitdiff
path: root/libbcache/inode.c
diff options
context:
space:
mode:
Diffstat (limited to 'libbcache/inode.c')
-rw-r--r--libbcache/inode.c288
1 files changed, 217 insertions, 71 deletions
diff --git a/libbcache/inode.c b/libbcache/inode.c
index 200deb0e..b72a1c51 100644
--- a/libbcache/inode.c
+++ b/libbcache/inode.c
@@ -9,51 +9,195 @@
#include <linux/random.h>
-ssize_t bch_inode_status(char *buf, size_t len, const struct bkey *k)
+#include <asm/unaligned.h>
+
+#define FIELD_BYTES() \
+
+static const u8 byte_table[8] = { 1, 2, 3, 4, 6, 8, 10, 13 };
+static const u8 bits_table[8] = {
+ 1 * 8 - 1,
+ 2 * 8 - 2,
+ 3 * 8 - 3,
+ 4 * 8 - 4,
+ 6 * 8 - 5,
+ 8 * 8 - 6,
+ 10 * 8 - 7,
+ 13 * 8 - 8,
+};
+
+static int inode_encode_field(u8 *out, u8 *end, const u64 in[2])
{
- if (k->p.offset)
- return scnprintf(buf, len, "offset nonzero: %llu", k->p.offset);
-
- if (k->size)
- return scnprintf(buf, len, "size nonzero: %u", k->size);
-
- switch (k->type) {
- case KEY_TYPE_DELETED:
- return scnprintf(buf, len, "deleted");
- case KEY_TYPE_DISCARD:
- return scnprintf(buf, len, "discarded");
- case KEY_TYPE_ERROR:
- return scnprintf(buf, len, "error");
- case KEY_TYPE_COOKIE:
- return scnprintf(buf, len, "cookie");
+ unsigned bytes, bits, shift;
- case BCH_INODE_FS:
- if (bkey_val_bytes(k) != sizeof(struct bch_inode))
- return scnprintf(buf, len, "bad size: %zu",
- bkey_val_bytes(k));
+ if (likely(!in[1]))
+ bits = fls64(in[0]);
+ else
+ bits = fls64(in[1]) + 64;
- if (k->p.inode < BLOCKDEV_INODE_MAX)
- return scnprintf(buf, len,
- "fs inode in blockdev range: %llu",
- k->p.inode);
- return 0;
+ for (shift = 1; shift <= 8; shift++)
+ if (bits < bits_table[shift - 1])
+ goto got_shift;
- case BCH_INODE_BLOCKDEV:
- if (bkey_val_bytes(k) != sizeof(struct bch_inode_blockdev))
- return scnprintf(buf, len, "bad size: %zu",
- bkey_val_bytes(k));
+ BUG();
+got_shift:
+ bytes = byte_table[shift - 1];
- if (k->p.inode >= BLOCKDEV_INODE_MAX)
- return scnprintf(buf, len,
- "blockdev inode in fs range: %llu",
- k->p.inode);
- return 0;
+ BUG_ON(out + bytes > end);
- default:
- return scnprintf(buf, len, "unknown inode type: %u", k->type);
+ if (likely(bytes <= 8)) {
+ u64 b = cpu_to_be64(in[0]);
+
+ memcpy(out, (void *) &b + 8 - bytes, bytes);
+ } else {
+ u64 b = cpu_to_be64(in[1]);
+
+ memcpy(out, (void *) &b + 16 - bytes, bytes);
+ put_unaligned_be64(in[0], out + bytes - 8);
+ }
+
+ *out |= (1 << 8) >> shift;
+
+ return bytes;
+}
+
+static int inode_decode_field(const u8 *in, const u8 *end,
+ u64 out[2], unsigned *out_bits)
+{
+ unsigned bytes, bits, shift;
+
+ if (in >= end)
+ return -1;
+
+ if (!*in)
+ return -1;
+
+ /*
+ * position of highest set bit indicates number of bytes:
+ * shift = number of bits to remove in high byte:
+ */
+ shift = 8 - __fls(*in); /* 1 <= shift <= 8 */
+ bytes = byte_table[shift - 1];
+ bits = bytes * 8 - shift;
+
+ if (in + bytes > end)
+ return -1;
+
+ /*
+ * we're assuming it's safe to deref up to 7 bytes < in; this will work
+ * because keys always start quite a bit more than 7 bytes after the
+ * start of the btree node header:
+ */
+ if (likely(bytes <= 8)) {
+ out[0] = get_unaligned_be64(in + bytes - 8);
+ out[0] <<= 64 - bits;
+ out[0] >>= 64 - bits;
+ out[1] = 0;
+ } else {
+ out[0] = get_unaligned_be64(in + bytes - 8);
+ out[1] = get_unaligned_be64(in + bytes - 16);
+ out[1] <<= 128 - bits;
+ out[1] >>= 128 - bits;
+ }
+
+ *out_bits = out[1] ? 64 + fls64(out[1]) : fls64(out[0]);
+ return bytes;
+}
+
+void bch_inode_pack(struct bkey_inode_buf *packed,
+ const struct bch_inode_unpacked *inode)
+{
+ u8 *out = packed->inode.v.fields;
+ u8 *end = (void *) &packed[1];
+ u8 *last_nonzero_field = out;
+ u64 field[2];
+ unsigned nr_fields = 0, last_nonzero_fieldnr = 0;
+
+ bkey_inode_init(&packed->inode.k_i);
+ packed->inode.k.p.inode = inode->inum;
+ packed->inode.v.i_hash_seed = inode->i_hash_seed;
+ packed->inode.v.i_flags = cpu_to_le32(inode->i_flags);
+ packed->inode.v.i_mode = cpu_to_le16(inode->i_mode);
+
+#define BCH_INODE_FIELD(_name, _bits) \
+ field[0] = inode->_name; \
+ field[1] = 0; \
+ out += inode_encode_field(out, end, field); \
+ nr_fields++; \
+ \
+ if (field[0] | field[1]) { \
+ last_nonzero_field = out; \
+ last_nonzero_fieldnr = nr_fields; \
+ }
+
+ BCH_INODE_FIELDS()
+#undef BCH_INODE_FIELD
+
+ out = last_nonzero_field;
+ nr_fields = last_nonzero_fieldnr;
+
+ set_bkey_val_bytes(&packed->inode.k, out - (u8 *) &packed->inode.v);
+ memset(out, 0,
+ (u8 *) &packed->inode.v +
+ bkey_val_bytes(&packed->inode.k) - out);
+
+ SET_INODE_NR_FIELDS(&packed->inode.v, nr_fields);
+
+ if (IS_ENABLED(CONFIG_BCACHE_DEBUG)) {
+ struct bch_inode_unpacked unpacked;
+
+ int ret = bch_inode_unpack(inode_i_to_s_c(&packed->inode),
+ &unpacked);
+ BUG_ON(ret);
+ BUG_ON(unpacked.inum != inode->inum);
+ BUG_ON(unpacked.i_hash_seed != inode->i_hash_seed);
+ BUG_ON(unpacked.i_mode != inode->i_mode);
+
+#define BCH_INODE_FIELD(_name, _bits) BUG_ON(unpacked._name != inode->_name);
+ BCH_INODE_FIELDS()
+#undef BCH_INODE_FIELD
}
}
+int bch_inode_unpack(struct bkey_s_c_inode inode,
+ struct bch_inode_unpacked *unpacked)
+{
+ const u8 *in = inode.v->fields;
+ const u8 *end = (void *) inode.v + bkey_val_bytes(inode.k);
+ u64 field[2];
+ unsigned fieldnr = 0, field_bits;
+ int ret;
+
+ unpacked->inum = inode.k->p.inode;
+ unpacked->i_hash_seed = inode.v->i_hash_seed;
+ unpacked->i_flags = le32_to_cpu(inode.v->i_flags);
+ unpacked->i_mode = le16_to_cpu(inode.v->i_mode);
+
+#define BCH_INODE_FIELD(_name, _bits) \
+ if (fieldnr++ == INODE_NR_FIELDS(inode.v)) { \
+ memset(&unpacked->_name, 0, \
+ sizeof(*unpacked) - \
+ offsetof(struct bch_inode_unpacked, _name)); \
+ return 0; \
+ } \
+ \
+ ret = inode_decode_field(in, end, field, &field_bits); \
+ if (ret < 0) \
+ return ret; \
+ \
+ if (field_bits > sizeof(unpacked->_name) * 8) \
+ return -1; \
+ \
+ unpacked->_name = field[0]; \
+ in += ret;
+
+ BCH_INODE_FIELDS()
+#undef BCH_INODE_FIELD
+
+ /* XXX: signal if there were more fields than expected? */
+
+ return 0;
+}
+
static const char *bch_inode_invalid(const struct cache_set *c,
struct bkey_s_c k)
{
@@ -63,16 +207,20 @@ static const char *bch_inode_invalid(const struct cache_set *c,
switch (k.k->type) {
case BCH_INODE_FS: {
struct bkey_s_c_inode inode = bkey_s_c_to_inode(k);
+ struct bch_inode_unpacked unpacked;
- if (bkey_val_bytes(k.k) != sizeof(struct bch_inode))
+ if (bkey_val_bytes(k.k) < sizeof(struct bch_inode))
return "incorrect value size";
if (k.k->p.inode < BLOCKDEV_INODE_MAX)
return "fs inode in blockdev range";
- if (INODE_STR_HASH_TYPE(inode.v) >= BCH_STR_HASH_NR)
+ if (INODE_STR_HASH(inode.v) >= BCH_STR_HASH_NR)
return "invalid str hash type";
+ if (bch_inode_unpack(inode, &unpacked))
+ return "invalid variable length fields";
+
return NULL;
}
case BCH_INODE_BLOCKDEV:
@@ -92,12 +240,17 @@ static void bch_inode_to_text(struct cache_set *c, char *buf,
size_t size, struct bkey_s_c k)
{
struct bkey_s_c_inode inode;
+ struct bch_inode_unpacked unpacked;
switch (k.k->type) {
case BCH_INODE_FS:
inode = bkey_s_c_to_inode(k);
+ if (bch_inode_unpack(inode, &unpacked)) {
+ scnprintf(buf, size, "(unpack error)");
+ break;
+ }
- scnprintf(buf, size, "i_size %llu", inode.v->i_size);
+ scnprintf(buf, size, "i_size %llu", unpacked.i_size);
break;
}
}
@@ -107,26 +260,25 @@ const struct bkey_ops bch_bkey_inode_ops = {
.val_to_text = bch_inode_to_text,
};
-void bch_inode_init(struct cache_set *c, struct bkey_i_inode *inode,
+void bch_inode_init(struct cache_set *c, struct bch_inode_unpacked *inode_u,
uid_t uid, gid_t gid, umode_t mode, dev_t rdev)
{
- struct timespec ts = CURRENT_TIME;
- s64 now = timespec_to_ns(&ts);
- struct bch_inode *bi;
-
- bi = &bkey_inode_init(&inode->k_i)->v;
- bi->i_uid = cpu_to_le32(uid);
- bi->i_gid = cpu_to_le32(gid);
-
- bi->i_mode = cpu_to_le16(mode);
- bi->i_dev = cpu_to_le32(rdev);
- bi->i_atime = cpu_to_le64(now);
- bi->i_mtime = cpu_to_le64(now);
- bi->i_ctime = cpu_to_le64(now);
- bi->i_nlink = cpu_to_le32(S_ISDIR(mode) ? 2 : 1);
-
- get_random_bytes(&bi->i_hash_seed, sizeof(bi->i_hash_seed));
- SET_INODE_STR_HASH_TYPE(bi, c->sb.str_hash_type);
+ s64 now = timespec_to_bch_time(c, CURRENT_TIME);
+
+ memset(inode_u, 0, sizeof(*inode_u));
+
+ /* ick */
+ inode_u->i_flags |= c->sb.str_hash_type << INODE_STR_HASH_OFFSET;
+ get_random_bytes(&inode_u->i_hash_seed, sizeof(inode_u->i_hash_seed));
+
+ inode_u->i_mode = mode;
+ inode_u->i_uid = uid;
+ inode_u->i_gid = gid;
+ inode_u->i_dev = rdev;
+ inode_u->i_atime = now;
+ inode_u->i_mtime = now;
+ inode_u->i_ctime = now;
+ inode_u->i_otime = now;
}
int bch_inode_create(struct cache_set *c, struct bkey_i *inode,
@@ -200,7 +352,7 @@ int bch_inode_truncate(struct cache_set *c, u64 inode_nr, u64 new_size,
struct extent_insert_hook *hook, u64 *journal_seq)
{
return bch_discard(c, POS(inode_nr, new_size), POS(inode_nr + 1, 0),
- 0, NULL, hook, journal_seq);
+ ZERO_VERSION, NULL, hook, journal_seq);
}
int bch_inode_rm(struct cache_set *c, u64 inode_nr)
@@ -215,7 +367,7 @@ int bch_inode_rm(struct cache_set *c, u64 inode_nr)
ret = bch_btree_delete_range(c, BTREE_ID_XATTRS,
POS(inode_nr, 0),
POS(inode_nr + 1, 0),
- 0, NULL, NULL, NULL);
+ ZERO_VERSION, NULL, NULL, NULL);
if (ret < 0)
return ret;
@@ -230,7 +382,7 @@ int bch_inode_rm(struct cache_set *c, u64 inode_nr)
ret = bch_btree_delete_range(c, BTREE_ID_DIRENTS,
POS(inode_nr, 0),
POS(inode_nr + 1, 0),
- 0, NULL, NULL, NULL);
+ ZERO_VERSION, NULL, NULL, NULL);
if (ret < 0)
return ret;
@@ -241,25 +393,19 @@ int bch_inode_rm(struct cache_set *c, u64 inode_nr)
NULL, NULL, BTREE_INSERT_NOFAIL);
}
-int bch_inode_update(struct cache_set *c, struct bkey_i *inode,
- u64 *journal_seq)
-{
- return bch_btree_update(c, BTREE_ID_INODES, inode, journal_seq);
-}
-
int bch_inode_find_by_inum(struct cache_set *c, u64 inode_nr,
- struct bkey_i_inode *inode)
+ struct bch_inode_unpacked *inode)
{
struct btree_iter iter;
struct bkey_s_c k;
+ int ret = -ENOENT;
for_each_btree_key_with_holes(&iter, c, BTREE_ID_INODES,
POS(inode_nr, 0), k) {
switch (k.k->type) {
case BCH_INODE_FS:
- bkey_reassemble(&inode->k_i, k);
- bch_btree_iter_unlock(&iter);
- return 0;
+ ret = bch_inode_unpack(bkey_s_c_to_inode(k), inode);
+ break;
default:
/* hole, not found */
break;
@@ -269,7 +415,7 @@ int bch_inode_find_by_inum(struct cache_set *c, u64 inode_nr,
}
- return bch_btree_iter_unlock(&iter) ?: -ENOENT;
+ return bch_btree_iter_unlock(&iter) ?: ret;
}
int bch_cached_dev_inode_find_by_uuid(struct cache_set *c, uuid_le *uuid,
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-01 12:11:41 +0000