X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Fserialize.c;h=a9e4182f0912e206e6494161fdf7ab942ac5064e;hb=f2586554fd55cd3cc1be65ac33d1122d00372133;hp=7cb16a5304eb3098cd494a95c7b643d25cd1f798;hpb=da3686c428dbcfdc010f88001325668f0e09bd8b;p=bluesky.git diff --git a/bluesky/serialize.c b/bluesky/serialize.c index 7cb16a5..a9e4182 100644 --- a/bluesky/serialize.c +++ b/bluesky/serialize.c @@ -7,18 +7,28 @@ */ #include +#include #include #include -#include "bluesky.h" +#include "bluesky-private.h" /* Serialization of in-memory filesystem data structures to bytestrings which * can be written to persistent storage. All data is stored in little-endian * format. */ +/* Magic signature and structure of serialized superblocks. */ + +#define SUPERBLOCK_MAGIC 0x65ca91e91b124234ULL + +struct serialized_superblock { + uint64_t signature; /* SUPERBLOCK_MAGIC */ + uint64_t next_inum; +} __attribute__((packed)); + /* Magic signature for serialized inodes. */ -#define INODE_MAGIC 0xa6832100943d71e5ULL +#define INODE_MAGIC 0xa6832100943d71e6ULL struct serialized_inode { uint64_t signature; /* INODE_MAGIC */ @@ -34,6 +44,29 @@ struct serialized_inode { int64_t ntime; } __attribute__((packed)); +void bluesky_serialize_superblock(GString *out, BlueSkyFS *fs) +{ + struct serialized_superblock buf; + + buf.signature = GUINT64_TO_LE(SUPERBLOCK_MAGIC); + buf.next_inum = GUINT64_TO_LE(fs->next_inum); + + g_string_append_len(out, (gchar *)&buf, sizeof(buf)); +} + +BlueSkyFS *bluesky_deserialize_superblock(const gchar *buf) +{ + struct serialized_superblock *raw = (struct serialized_superblock *)buf; + + if (GUINT64_FROM_LE(raw->signature) != SUPERBLOCK_MAGIC) + return NULL; + + BlueSkyFS *fs = bluesky_new_fs("deserialized"); + fs->next_inum = GUINT64_FROM_LE(raw->next_inum); + + return fs; +} + void bluesky_serialize_inode(GString *out, BlueSkyInode *inode) { struct serialized_inode buf; @@ -55,34 +88,83 @@ void bluesky_serialize_inode(GString *out, BlueSkyInode *inode) switch (inode->type) { case BLUESKY_REGULAR: + { + uint64_t size = GUINT64_TO_LE(inode->size); + g_string_append_len(out, (gchar *)&size, sizeof(uint64_t)); for (int i = 0; i < inode->blocks->len; i++) { BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i); + BlueSkyCloudID id; + memset(&id, 0, sizeof(id)); if (b->ref != NULL) - g_string_append(out, b->ref); + id = b->ref->id; + g_string_append_len(out, (const char *)&id, sizeof(id)); + } + break; + } + + case BLUESKY_DIRECTORY: + { + uint32_t seq; + uint64_t inum; + GSequenceIter *i = g_sequence_get_begin_iter(inode->dirents); + + while (!g_sequence_iter_is_end(i)) { + BlueSkyDirent *d = g_sequence_get(i); + + seq = GUINT32_TO_LE(d->cookie); + inum = GUINT64_TO_LE(d->inum); + g_string_append_len(out, (gchar *)&seq, sizeof(uint32_t)); + g_string_append_len(out, (gchar *)&inum, sizeof(uint64_t)); + g_string_append(out, d->name); g_string_append_c(out, '\0'); + + i = g_sequence_iter_next(i); } + + seq = GUINT32_TO_LE(0); + g_string_append_len(out, (gchar *)&seq, sizeof(uint32_t)); + break; + } + + case BLUESKY_SYMLINK: + { + g_string_append(out, inode->symlink_contents); + g_string_append_c(out, '\0'); + break; + } + default: g_warning("Serialization for inode type %d not implemented!\n", inode->type); } } -BlueSkyInode *bluesky_deserialize_inode(BlueSkyFS *fs, const gchar *buf) +/* Deserialize an inode into an in-memory representation. Returns a boolean + * indicating whether the deserialization was successful. */ +gboolean bluesky_deserialize_inode(BlueSkyInode *inode, const gchar *buf) { + if (bluesky_verbose) { + g_log("bluesky/serialize", G_LOG_LEVEL_DEBUG, + "Deserializing inode %lld...", (long long)inode->inum); + } + struct serialized_inode *raw = (struct serialized_inode *)buf; if (GUINT64_FROM_LE(raw->signature) != INODE_MAGIC) - return NULL; + return FALSE; + + if (inode->inum != GUINT64_FROM_LE(raw->inum)) + return FALSE; - BlueSkyInode *inode = bluesky_new_inode(GUINT64_FROM_LE(raw->inum), - fs, GUINT32_FROM_LE(raw->type)); + bluesky_init_inode(inode, GUINT32_FROM_LE(raw->type)); inode->mode = GUINT32_FROM_LE(raw->mode); inode->uid = GUINT32_FROM_LE(raw->uid); inode->gid = GUINT32_FROM_LE(raw->gid); inode->nlink = GUINT32_FROM_LE(raw->nlink); inode->change_count = GUINT64_FROM_LE(raw->change_count); + inode->change_commit = inode->change_count; inode->atime = GINT64_FROM_LE(raw->atime); inode->ctime = GINT64_FROM_LE(raw->ctime); inode->mtime = GINT64_FROM_LE(raw->mtime); @@ -90,20 +172,63 @@ BlueSkyInode *bluesky_deserialize_inode(BlueSkyFS *fs, const gchar *buf) buf += sizeof(struct serialized_inode); + /* TODO: Bounds checking */ switch (inode->type) { case BLUESKY_REGULAR: + inode->size = GINT64_FROM_LE(*(uint64_t *)buf); + buf += sizeof(uint64_t); g_array_set_size(inode->blocks, (inode->size + BLUESKY_BLOCK_SIZE - 1) / BLUESKY_BLOCK_SIZE); + // TODO +#if 0 for (int i = 0; i < inode->blocks->len; i++) { BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i); b->type = BLUESKY_BLOCK_REF; b->ref = g_strdup(buf); buf += strlen(b->ref) + 1; } +#endif + break; + + case BLUESKY_DIRECTORY: + { + struct serialized_dirent { + uint32_t seq; + uint64_t inum; + gchar name[0]; + } __attribute__((packed)); + + struct serialized_dirent *d = (struct serialized_dirent *)buf; + while (GUINT32_FROM_LE(d->seq) != 0) { + BlueSkyDirent *dirent = g_new(BlueSkyDirent, 1); + dirent->cookie = GUINT64_FROM_LE(d->seq); + dirent->inum = GUINT64_FROM_LE(d->inum); + dirent->name = g_strdup(d->name); + dirent->name_folded = bluesky_lowercase(d->name); + + g_sequence_insert_sorted(inode->dirents, dirent, + bluesky_dirent_compare, NULL); + g_hash_table_insert(inode->dirhash, dirent->name, dirent); + g_hash_table_insert(inode->dirhash_folded, dirent->name_folded, + dirent); + + buf = strchr(d->name, '\0') + 1; + d = (struct serialized_dirent *)buf; + } break; + } + + case BLUESKY_SYMLINK: + { + inode->symlink_contents = g_strdup(buf); + break; + } + default: g_warning("Deserialization for inode type %d not implemented!\n", inode->type); } + + return TRUE; }