Fix filesystem locking when creating a new inode.
[bluesky.git] / bluesky / inode.c
1 /* Blue Sky: File Systems in the Cloud
2  *
3  * Copyright (C) 2009  The Regents of the University of California
4  * Written by Michael Vrable <mvrable@cs.ucsd.edu>
5  *
6  * TODO: Licensing
7  */
8
9 #include <stdio.h>
10 #include <stdint.h>
11 #include <inttypes.h>
12 #include <glib.h>
13 #include <string.h>
14
15 #include "bluesky-private.h"
16
17 /* Core filesystem.  Different proxies, such as the NFSv3 one, interface to
18  * this, but the core actually tracks the data which is stored.  So far we just
19  * implement an in-memory filesystem, but eventually this will be state which
20  * is persisted to the cloud. */
21
22 /* Return the current time, in microseconds since the epoch. */
23 int64_t bluesky_get_current_time()
24 {
25     GTimeVal t;
26     g_get_current_time(&t);
27     return (int64_t)t.tv_sec * 1000000 + t.tv_usec;
28 }
29
30 /* Update an inode to indicate that a modification was made.  This increases
31  * the change counter, updates the ctime to the current time, and optionally
32  * updates the mtime.  This also makes the inode contents subject to writeback
33  * to storage in the future.  inode must already be locked. */
34 void bluesky_inode_update_ctime(BlueSkyInode *inode, gboolean update_mtime)
35 {
36     int64_t now = bluesky_get_current_time();
37     inode->change_count++;
38     inode->ctime = now;
39     if (update_mtime)
40         inode->mtime = now;
41
42     if (inode->change_time == 0)
43         inode->change_time = now;
44
45     if (bluesky_options.writethrough_cache)
46         bluesky_file_flush(inode, NULL);
47
48     g_mutex_lock(inode->fs->lock);
49     bluesky_list_unlink(&inode->fs->dirty_list, inode->dirty_list);
50     inode->dirty_list = bluesky_list_prepend(&inode->fs->dirty_list, inode);
51     bluesky_list_unlink(&inode->fs->accessed_list, inode->accessed_list);
52     inode->accessed_list = bluesky_list_prepend(&inode->fs->accessed_list, inode);
53     g_mutex_unlock(inode->fs->lock);
54 }
55
56 /* Unfortunately a glib hash table is only guaranteed to be able to store
57  * 32-bit keys if we use the key directly.  If we want 64-bit inode numbers,
58  * we'll have to allocate memory to store the 64-bit inumber, and use a pointer
59  * to it.  Rather than allocate the memory for the key, we'll just include a
60  * pointer to the 64-bit inum stored in the inode itself, so that we don't need
61  * to do any more memory management.  */
62 static guint bluesky_fs_key_hash_func(gconstpointer key)
63 {
64     uint64_t inum = *(const uint64_t *)key;
65     return (guint)inum;
66 }
67
68 static gboolean bluesky_fs_key_equal_func(gconstpointer a, gconstpointer b)
69 {
70     uint64_t i1 = *(const uint64_t *)a;
71     uint64_t i2 = *(const uint64_t *)b;
72     return i1 == i2;
73 }
74
75 /* Filesystem-level operations.  A filesystem is like a directory tree that we
76  * are willing to export. */
77 BlueSkyFS *bluesky_new_fs(gchar *name)
78 {
79     BlueSkyFS *fs = g_new0(BlueSkyFS, 1);
80     fs->lock = g_mutex_new();
81     fs->name = g_strdup(name);
82     fs->inodes = g_hash_table_new(bluesky_fs_key_hash_func,
83                                   bluesky_fs_key_equal_func);
84     fs->next_inum = BLUESKY_ROOT_INUM + 1;
85     fs->store = bluesky_store_new("file");
86     fs->flushd_lock = g_mutex_new();
87
88     return fs;
89 }
90
91 BlueSkyFS *bluesky_init_fs(gchar *name, BlueSkyStore *store)
92 {
93     BlueSkyRCStr *data = bluesky_store_get(store, "superblock");
94     if (data != NULL) {
95         BlueSkyFS *fs = bluesky_deserialize_superblock(data->data);
96         if (fs != NULL) {
97             fs->store = store;
98             g_print("Loaded filesystem superblock\n");
99             g_free(fs->name);
100             fs->name = g_strdup(name);
101             return fs;
102         }
103         bluesky_string_unref(data);
104     }
105
106     g_print("Initializing fresh filesystem\n");
107     BlueSkyFS *fs = bluesky_new_fs(name);
108     fs->store = store;
109
110     BlueSkyInode *root = bluesky_new_inode(BLUESKY_ROOT_INUM, fs,
111                                            BLUESKY_DIRECTORY);
112     root->nlink = 1;
113     root->mode = 0755;
114     bluesky_insert_inode(fs, root);
115     bluesky_inode_update_ctime(root, TRUE);
116
117     bluesky_inode_flush(fs, root);
118     bluesky_superblock_flush(fs);
119
120     return fs;
121 }
122
123 /* Inode reference counting. */
124 void bluesky_inode_ref(BlueSkyInode *inode)
125 {
126     g_atomic_int_inc(&inode->refcount);
127 }
128
129 void bluesky_inode_unref(BlueSkyInode *inode)
130 {
131     if (g_atomic_int_dec_and_test(&inode->refcount)) {
132         if (bluesky_verbose) {
133             g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
134                   "Reference count for inode %"PRIu64" dropped to zero.",
135                   inode->inum);
136         }
137
138         /* Sanity check: Is the inode clean? */
139         if (inode->change_commit < inode->change_count
140                 || inode->accessed_list != NULL
141                 || inode->dirty_list != NULL) {
142             g_warning("Dropping inode which is not clean (commit %"PRIi64" < change %"PRIi64"; accessed_list = %p; dirty_list = %p)\n", inode->change_commit, inode->change_count, inode->accessed_list, inode->dirty_list);
143         }
144
145         /* These shouldn't be needed, but in case the above warning fires and
146          * we delete the inode anyway, we ought to be sure the inode is not on
147          * any LRU list. */
148         g_mutex_lock(inode->fs->lock);
149         bluesky_list_unlink(&inode->fs->accessed_list, inode->accessed_list);
150         bluesky_list_unlink(&inode->fs->dirty_list, inode->dirty_list);
151         g_mutex_unlock(inode->fs->lock);
152
153         /* Free file type specific data.  It should be an error for there to be
154          * dirty data to commit when the reference count has reaches zero. */
155         switch (inode->type) {
156         case BLUESKY_REGULAR:
157             for (int i = 0; i < inode->blocks->len; i++) {
158                 BlueSkyBlock *b = &g_array_index(inode->blocks,
159                                                  BlueSkyBlock, i);
160                 if (b->type == BLUESKY_BLOCK_DIRTY) {
161                     g_error("Deleting an inode with dirty file data!");
162                 }
163                 g_free(b->ref);
164                 bluesky_string_unref(b->data);
165             }
166             g_array_unref(inode->blocks);
167             break;
168
169         case BLUESKY_DIRECTORY:
170             g_hash_table_destroy(inode->dirhash);
171             g_hash_table_destroy(inode->dirhash_folded);
172             g_sequence_free(inode->dirents);
173             break;
174
175         case BLUESKY_SYMLINK:
176             g_free(inode->symlink_contents);
177             break;
178
179         default:
180             break;
181         }
182
183         g_mutex_free(inode->lock);
184
185         g_free(inode);
186     }
187 }
188
189 /* Allocate a fresh inode number which has not been used before within a
190  * filesystem.  fs must already be locked. */
191 uint64_t bluesky_fs_alloc_inode(BlueSkyFS *fs)
192 {
193     uint64_t inum;
194
195     inum = fs->next_inum;
196     fs->next_inum++;
197
198     bluesky_superblock_flush(fs);
199
200     return inum;
201 }
202
203 /* Perform type-specification initialization of an inode.  Normally performed
204  * in bluesky_new_inode, but can be separated if an inode is created first,
205  * then deserialized. */
206 void bluesky_init_inode(BlueSkyInode *i, BlueSkyFileType type)
207 {
208     i->type = type;
209
210     switch (type) {
211     case BLUESKY_REGULAR:
212         i->blocks = g_array_new(FALSE, TRUE, sizeof(BlueSkyBlock));
213         break;
214     case BLUESKY_DIRECTORY:
215         i->dirents = g_sequence_new(bluesky_dirent_destroy);
216         i->dirhash = g_hash_table_new(g_str_hash, g_str_equal);
217         i->dirhash_folded = g_hash_table_new(g_str_hash, g_str_equal);
218         break;
219     default:
220         break;
221     }
222 }
223
224 BlueSkyInode *bluesky_new_inode(uint64_t inum, BlueSkyFS *fs,
225                                 BlueSkyFileType type)
226 {
227     BlueSkyInode *i = g_new0(BlueSkyInode, 1);
228
229     i->lock = g_mutex_new();
230     i->refcount = 1;
231     i->fs = fs;
232     i->inum = inum;
233     i->change_count = 1;
234     bluesky_init_inode(i, type);
235
236     return i;
237 }
238
239 /* Retrieve an inode from the filesystem.  Eventually this will be a cache and
240  * so we might need to go fetch the inode from elsewhere; for now all
241  * filesystem state is stored here.  inode is returned with a reference held
242  * but not locked. */
243 BlueSkyInode *bluesky_get_inode(BlueSkyFS *fs, uint64_t inum)
244 {
245     BlueSkyInode *inode = NULL;
246
247     if (inum == 0) {
248         return NULL;
249     }
250
251     g_mutex_lock(fs->lock);
252     inode = (BlueSkyInode *)g_hash_table_lookup(fs->inodes, &inum);
253
254     if (inode == NULL) {
255         bluesky_inode_fetch(fs, inum);
256         inode = (BlueSkyInode *)g_hash_table_lookup(fs->inodes, &inum);
257     }
258
259     if (inode != NULL) {
260         bluesky_inode_ref(inode);
261
262         /* FIXME: We assume we can atomically update the in-memory access time
263          * without a lock. */
264         inode->access_time = bluesky_get_current_time();
265     }
266
267     g_mutex_unlock(fs->lock);
268
269     return inode;
270 }
271
272 /* Insert an inode into the filesystem inode cache.  fs should be locked. */
273 void bluesky_insert_inode(BlueSkyFS *fs, BlueSkyInode *inode)
274 {
275     g_hash_table_insert(fs->inodes, &inode->inum, inode);
276 }
277
278 /* Deprecated: Synchronize an inode to stable storage. */
279 void bluesky_inode_flush(BlueSkyFS *fs, BlueSkyInode *inode)
280 {
281     GString *buf = g_string_new("");
282     bluesky_serialize_inode(buf, inode);
283     BlueSkyRCStr *data = bluesky_string_new_from_gstring(buf);
284
285     char key[64];
286     sprintf(key, "inode-%016"PRIx64, inode->inum);
287
288     BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
289     async->op = STORE_OP_PUT;
290     async->key = g_strdup(key);
291     async->data = data;
292     bluesky_store_async_submit(async);
293     bluesky_store_async_unref(async);
294 }
295
296 /* Start writeback of an inode and all associated data. */
297 void bluesky_inode_start_sync(BlueSkyInode *inode, BlueSkyStoreAsync *barrier)
298 {
299     BlueSkyFS *fs = inode->fs;
300
301     if (inode->type == BLUESKY_REGULAR)
302         bluesky_file_flush(inode, barrier);
303
304     GString *buf = g_string_new("");
305     bluesky_serialize_inode(buf, inode);
306     BlueSkyRCStr *data = bluesky_string_new_from_gstring(buf);
307
308     char key[64];
309     sprintf(key, "inode-%016"PRIx64, inode->inum);
310
311     BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
312     async->op = STORE_OP_PUT;
313     async->key = g_strdup(key);
314     async->data = data;
315     bluesky_store_async_submit(async);
316     if (barrier != NULL)
317         bluesky_store_add_barrier(barrier, async);
318     bluesky_store_async_unref(async);
319 }
320
321 /* Write back an inode and all associated data and wait for completion.  Inode
322  * should already be locked. */
323 void bluesky_inode_do_sync(BlueSkyInode *inode)
324 {
325     BlueSkyStoreAsync *barrier = bluesky_store_async_new(inode->fs->store);
326     barrier->op = STORE_OP_BARRIER;
327
328     if (bluesky_verbose) {
329         g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
330             "Synchronous writeback for inode %"PRIu64"...", inode->inum);
331     }
332     bluesky_inode_start_sync(inode, barrier);
333     bluesky_store_async_submit(barrier);
334     bluesky_store_async_wait(barrier);
335     bluesky_store_async_unref(barrier);
336     if (bluesky_verbose) {
337         g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
338               "Writeback for inode %"PRIu64" complete", inode->inum);
339     }
340 }
341
342 static void complete_inode_fetch(BlueSkyStoreAsync *async, BlueSkyInode *inode)
343 {
344     if (bluesky_verbose) {
345         g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
346               "Completing fetch of inode %"PRIu64"...", inode->inum);
347     }
348
349     if (async->result != 0
350         || !bluesky_deserialize_inode(inode, async->data->data))
351     {
352         if (bluesky_verbose) {
353             g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
354                   "    failed to load inode, cleaning up");
355         }
356         g_mutex_lock(inode->fs->lock);
357         g_hash_table_remove(inode->fs->inodes, &inode->inum);
358         bluesky_list_unlink(&inode->fs->accessed_list, inode->accessed_list);
359         inode->accessed_list = NULL;
360         g_mutex_unlock(inode->fs->lock);
361         bluesky_inode_unref(inode);
362     }
363
364     inode->access_time = bluesky_get_current_time();
365     g_mutex_lock(inode->fs->lock);
366     bluesky_list_unlink(&inode->fs->accessed_list, inode->accessed_list);
367     inode->accessed_list = bluesky_list_prepend(&inode->fs->accessed_list, inode);
368     g_mutex_unlock(inode->fs->lock);
369
370     g_mutex_unlock(inode->lock);
371     bluesky_inode_unref(inode);
372 }
373
374 /* Fetch an inode from stable storage.  The fetch can be performed
375  * asynchronously: the in-memory inode is allocated, but not filled with data
376  * immediately.  It is kept locked until it has been filled in, so any users
377  * should try to acquire the lock on the inode before accessing any data.  The
378  * fs lock must be held. */
379 void bluesky_inode_fetch(BlueSkyFS *fs, uint64_t inum)
380 {
381     char key[64];
382     sprintf(key, "inode-%016"PRIx64, inum);
383
384     BlueSkyInode *inode = bluesky_new_inode(inum, fs, BLUESKY_PENDING);
385     inode->change_count = 0;
386     bluesky_inode_ref(inode);       // Extra ref held by fetching process
387     g_mutex_lock(inode->lock);
388     bluesky_insert_inode(fs, inode);
389
390     BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
391     async->op = STORE_OP_GET;
392     async->key = g_strdup(key);
393
394     bluesky_store_async_add_notifier(async, (GFunc)complete_inode_fetch, inode);
395     bluesky_store_async_submit(async);
396
397     if (bluesky_options.sync_inode_fetches) {
398         bluesky_store_async_wait(async);
399     }
400
401     bluesky_store_async_unref(async);
402 }
403
404 /* Synchronize filesystem superblock to stable storage. */
405 void bluesky_superblock_flush(BlueSkyFS *fs)
406 {
407     GString *buf = g_string_new("");
408     bluesky_serialize_superblock(buf, fs);
409     BlueSkyRCStr *data = bluesky_string_new_from_gstring(buf);
410
411     BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
412     async->op = STORE_OP_PUT;
413     async->key = g_strdup("superblock");
414     async->data = data;
415     bluesky_store_async_submit(async);
416     bluesky_store_async_unref(async);
417
418     bluesky_store_sync(fs->store);
419 }