X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Fserialize.c;h=fc3cd312a12f08e20ea1af1d2cee85a764cff2c9;hb=HEAD;hp=5eb7c1d2dd1baeba0eeb208d15ebbf187dfcb8da;hpb=d514caf49faff9295d0e497d3b6b8856fe83f8d0;p=bluesky.git diff --git a/bluesky/serialize.c b/bluesky/serialize.c index 5eb7c1d..fc3cd31 100644 --- a/bluesky/serialize.c +++ b/bluesky/serialize.c @@ -3,7 +3,29 @@ * Copyright (C) 2009 The Regents of the University of California * Written by Michael Vrable * - * TODO: Licensing + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. */ #include @@ -67,10 +89,16 @@ BlueSkyFS *bluesky_deserialize_superblock(const gchar *buf) return fs; } -void bluesky_serialize_inode(GString *out, BlueSkyInode *inode) +BlueSkyCloudLog *bluesky_serialize_inode(BlueSkyInode *inode) { + BlueSkyFS *fs = inode->fs; + GString *out = g_string_new(""); struct serialized_inode buf; + BlueSkyCloudLog *cloudlog = bluesky_cloudlog_new(fs, NULL); + cloudlog->type = LOGTYPE_INODE; + cloudlog->inum = inode->inum; + buf.signature = GUINT64_TO_LE(INODE_MAGIC); buf.type = GUINT32_TO_LE(inode->type); buf.mode = GUINT32_TO_LE(inode->mode); @@ -93,9 +121,9 @@ void bluesky_serialize_inode(GString *out, BlueSkyInode *inode) 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); - if (b->ref != NULL) - g_string_append(out, b->ref); - g_string_append_c(out, '\0'); + BlueSkyCloudLog *ref = (b->type == BLUESKY_BLOCK_REF ? b->ref : NULL); + bluesky_cloudlog_ref(ref); + g_array_append_val(cloudlog->links, ref); } break; } @@ -129,19 +157,32 @@ void bluesky_serialize_inode(GString *out, BlueSkyInode *inode) { 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); } + + cloudlog->data = bluesky_string_new_from_gstring(out); + bluesky_cloudlog_insert(cloudlog); + bluesky_cloudlog_stats_update(cloudlog, 1); + + return cloudlog; } /* 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) +gboolean bluesky_deserialize_inode(BlueSkyInode *inode, BlueSkyCloudLog *item) { - g_print("Deserializing inode %lld...\n", (long long)inode->inum); + g_assert(item->data != NULL); + const char *buf = item->data->data; + + 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; @@ -174,11 +215,13 @@ gboolean bluesky_deserialize_inode(BlueSkyInode *inode, const gchar *buf) g_array_set_size(inode->blocks, (inode->size + BLUESKY_BLOCK_SIZE - 1) / BLUESKY_BLOCK_SIZE); + g_assert(inode->blocks->len == item->links->len); 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; + b->ref = g_array_index(item->links, BlueSkyCloudLog *, i); + bluesky_cloudlog_ref(b->ref); + b->dirty = NULL; } break; @@ -204,9 +247,6 @@ gboolean bluesky_deserialize_inode(BlueSkyInode *inode, const gchar *buf) g_hash_table_insert(inode->dirhash_folded, dirent->name_folded, dirent); - g_print(" dirent[%08x]: %s -> %"PRIu64"\n", - dirent->cookie, dirent->name, dirent->inum); - buf = strchr(d->name, '\0') + 1; d = (struct serialized_dirent *)buf; } @@ -216,6 +256,7 @@ gboolean bluesky_deserialize_inode(BlueSkyInode *inode, const gchar *buf) case BLUESKY_SYMLINK: { inode->symlink_contents = g_strdup(buf); + break; } default: @@ -225,3 +266,116 @@ gboolean bluesky_deserialize_inode(BlueSkyInode *inode, const gchar *buf) return TRUE; } + +/* Convert an in-memory cloud log item to a more serialized form, suitable + * either for writing to the local journal or the the cloud. */ +void bluesky_serialize_cloudlog(BlueSkyCloudLog *log, + GString *encrypted, // Raw data payload + GString *authenticated, // Block links + GString *writable) // Writable block links +{ + g_string_append_len(encrypted, log->data->data, log->data->len); + for (int i = 0; i < log->links->len; i++) { + BlueSkyCloudLog *ref = g_array_index(log->links, BlueSkyCloudLog *, i); + if (ref != NULL) { + g_string_append_len(authenticated, + (const char *)&ref->id, + sizeof(BlueSkyCloudID)); + // TODO: Fix endianness of output + g_string_append_len(writable, + (const char *)&ref->location, + sizeof(ref->location)); + } else { + BlueSkyCloudID id; + memset(&id, 0, sizeof(id)); + g_string_append_len(authenticated, (const char *)&id, sizeof(id)); + } + } +} + +/* Deserialize data from the journal or a cloud segment back into the in-memory + * cloud log item format. */ +void bluesky_deserialize_cloudlog(BlueSkyCloudLog *item, + const char *data, + size_t len) +{ + const char *data1, *data2, *data3; + size_t len1, len2, len3; + int type; + BlueSkyCloudID id; + g_assert(len > 4); + + /* Auto-detect the format: either the journal or cloud log, based on the + * magic number at the start */ + if (memcmp(data, JOURNAL_MAGIC, 4) == 0) { + g_assert(len >= sizeof(struct log_header)); + struct log_header *header = (struct log_header *)data; + type = header->type - '0'; + len1 = GUINT32_FROM_LE(header->size1); + len2 = GUINT32_FROM_LE(header->size2); + len3 = GUINT32_FROM_LE(header->size3); + id = header->id; + data1 = data + sizeof(struct log_header); + data2 = data1 + len1; + data3 = data2 + len2; + g_assert(data3 + len3 - data <= len); + item->type = header->type - '0'; + item->inum = GUINT64_FROM_LE(header->inum); + } else if (memcmp(data, CLOUDLOG_MAGIC, 4) == 0) { + g_assert(len >= sizeof(struct cloudlog_header)); + struct cloudlog_header *header = (struct cloudlog_header *)data; + type = header->type - '0'; + len1 = GUINT32_FROM_LE(header->size1); + len2 = GUINT32_FROM_LE(header->size2); + len3 = GUINT32_FROM_LE(header->size3); + id = header->id; + data1 = data + sizeof(struct cloudlog_header); + data2 = data1 + len1; + data3 = data2 + len2; + g_assert(data3 + len3 - data <= len); + item->type = header->type - '0'; + item->inum = GUINT64_FROM_LE(header->inum); + } else { + g_warning("Deserializing garbage cloud log item!"); + return; + } + + if (memcmp(&id, &item->id, sizeof(BlueSkyCloudID)) != 0) { + g_warning("ID does not match expected value!\n"); + } + + BlueSkyFS *fs = item->fs; + + bluesky_string_unref(item->data); + item->data = NULL; + item->data_size = len1; + + int link_count = len2 / sizeof(BlueSkyCloudID); + GArray *new_links = g_array_new(FALSE, TRUE, sizeof(BlueSkyCloudLog *)); + for (int i = 0; i < link_count; i++) { + BlueSkyCloudID id; + g_assert(len2 >= sizeof(id)); + memcpy(&id, data2, sizeof(id)); + data2 += sizeof(id); len2 -= sizeof(id); + + BlueSkyCloudLog *ref = bluesky_cloudlog_get(fs, id); + if (ref != NULL) { + g_mutex_lock(ref->lock); + g_assert(len3 >= sizeof(ref->location)); + memcpy(&ref->location, data3, sizeof(ref->location)); + ref->location_flags |= CLOUDLOG_CLOUD; + data3 += sizeof(ref->location); len3 -= sizeof(ref->location); + g_mutex_unlock(ref->lock); + } + + g_array_append_val(new_links, ref); + } + + for (int i = 0; i < item->links->len; i++) { + BlueSkyCloudLog *c = g_array_index(item->links, + BlueSkyCloudLog *, i); + bluesky_cloudlog_unref(c); + } + g_array_unref(item->links); + item->links = new_links; +}