X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Fcloudlog.c;h=ec168e82380aaaa4f94234c8d65bded9c3c157ab;hb=7daddca3715fee8a3bfff417e769ff08dd7f4cbf;hp=0581bfc10dfc245be995f01c08e011a8953f3a58;hpb=0f7a0642cd1b9d98af851b9cf2ed14c9a83ddfc2;p=bluesky.git

diff --git a/bluesky/cloudlog.c b/bluesky/cloudlog.c
index 0581bfc..ec168e8 100644
--- a/bluesky/cloudlog.c
+++ b/bluesky/cloudlog.c
@@ -147,7 +147,10 @@ void bluesky_cloudlog_unref(BlueSkyCloudLog *log)
             return;
         }
 
-        g_hash_table_remove(fs->locations, &log->id);
+        if (!g_hash_table_remove(fs->locations, &log->id)) {
+            if (bluesky_verbose)
+                g_warning("Could not find and remove cloud log item from hash table!");
+        }
         g_mutex_unlock(fs->lock);
 
         bluesky_cloudlog_stats_update(log, -1);
@@ -165,6 +168,61 @@ void bluesky_cloudlog_unref(BlueSkyCloudLog *log)
     }
 }
 
+/* For locking reasons cloudlog unrefs may sometimes need to be performed in
+ * the future.  We launch a thread for handling these delayed unreference
+ * requests. */
+static gpointer cloudlog_unref_thread(gpointer q)
+{
+    GAsyncQueue *queue = (GAsyncQueue *)q;
+
+    while (TRUE) {
+        BlueSkyCloudLog *item = (BlueSkyCloudLog *)g_async_queue_pop(queue);
+        bluesky_cloudlog_unref(item);
+    }
+
+    return NULL;
+}
+
+void bluesky_cloudlog_unref_delayed(BlueSkyCloudLog *log)
+{
+    if (log != NULL)
+        g_async_queue_push(log->fs->unref_queue, log);
+}
+
+void bluesky_cloudlog_threads_init(BlueSkyFS *fs)
+{
+    fs->unref_queue = g_async_queue_new();
+    g_thread_create(cloudlog_unref_thread, fs->unref_queue, FALSE, NULL);
+}
+
+/* Erase the information contained within the in-memory cloud log
+ * representation.  This does not free up the item itself, but frees the data
+ * and references to other log items and resets the type back to unknown.  If
+ * the object was written out to persistent storage, all state about it can be
+ * recovered by loading the object back in.  The object must be locked before
+ * calling this function. */
+void bluesky_cloudlog_erase(BlueSkyCloudLog *log)
+{
+    g_assert(log->data_lock_count == 0);
+
+    if (log->type == LOGTYPE_UNKNOWN)
+        return;
+
+    log->type = LOGTYPE_UNKNOWN;
+    log->data_size = 0;
+    bluesky_string_unref(log->data);
+    log->data = NULL;
+    log->data_lock_count = 0;
+
+    for (int i = 0; i < log->links->len; i++) {
+        BlueSkyCloudLog *c = g_array_index(log->links,
+                                           BlueSkyCloudLog *, i);
+        bluesky_cloudlog_unref(c);
+    }
+    g_array_unref(log->links);
+    log->links = g_array_new(FALSE, TRUE, sizeof(BlueSkyCloudLog *));
+}
+
 /* Start a write of the object to the local log. */
 void bluesky_cloudlog_sync(BlueSkyCloudLog *log)
 {
@@ -173,10 +231,15 @@ void bluesky_cloudlog_sync(BlueSkyCloudLog *log)
 
 /* Add the given entry to the global hash table containing cloud log entries.
  * Takes ownership of the caller's reference. */
+void bluesky_cloudlog_insert_locked(BlueSkyCloudLog *log)
+{
+    g_hash_table_insert(log->fs->locations, &log->id, log);
+}
+
 void bluesky_cloudlog_insert(BlueSkyCloudLog *log)
 {
     g_mutex_lock(log->fs->lock);
-    g_hash_table_insert(log->fs->locations, &log->id, log);
+    bluesky_cloudlog_insert_locked(log);
     g_mutex_unlock(log->fs->lock);
 }
 
@@ -196,7 +259,7 @@ BlueSkyCloudLog *bluesky_cloudlog_get(BlueSkyFS *fs, BlueSkyCloudID id)
     item = g_hash_table_lookup(fs->locations, &id);
     if (item == NULL) {
         item = bluesky_cloudlog_new(fs, &id);
-        g_hash_table_insert(fs->locations, &id, item);
+        bluesky_cloudlog_insert_locked(item);
     } else {
         bluesky_cloudlog_ref(item);
     }
@@ -295,19 +358,20 @@ BlueSkyCloudPointer bluesky_cloudlog_serialize(BlueSkyCloudLog *log,
     GString *data3 = g_string_new("");
     bluesky_serialize_cloudlog(log, data1, data2, data3);
 
-    /* TODO: Right now offset/size are set to the raw data, but we should add
-     * header parsing to the code which loads objects back in. */
     log->location = state->location;
     log->location.offset = state->data->len;
     log->data_size = data1->len;
 
     struct cloudlog_header header;
     memcpy(header.magic, CLOUDLOG_MAGIC, 4);
+    memset(header.crypt_auth, sizeof(header.crypt_auth), 0);
+    memset(header.crypt_iv, sizeof(header.crypt_iv), 0);
     header.type = log->type + '0';
     header.size1 = GUINT32_TO_LE(data1->len);
     header.size2 = GUINT32_TO_LE(data2->len);
     header.size3 = GUINT32_TO_LE(data3->len);
     header.id = log->id;
+    header.inum = GUINT64_TO_LE(log->inum);
 
     g_string_append_len(state->data, (const char *)&header, sizeof(header));
     g_string_append_len(state->data, data1->str, data1->len);
@@ -316,13 +380,15 @@ BlueSkyCloudPointer bluesky_cloudlog_serialize(BlueSkyCloudLog *log,
 
     log->location.size = state->data->len - log->location.offset;
 
+    g_string_free(data1, TRUE);
+    g_string_free(data2, TRUE);
+    g_string_free(data3, TRUE);
+
     /* If the object we flushed was an inode, update the inode map. */
     if (log->type == LOGTYPE_INODE) {
         g_mutex_lock(fs->lock);
         InodeMapEntry *entry = bluesky_inode_map_lookup(fs->inode_map,
                                                         log->inum, 1);
-        entry->id = log->id;
-        entry->location = log->location;
         entry->item = log;
         bluesky_cloudlog_ref(entry->item);
         g_mutex_unlock(fs->lock);