Minor CMake fix (delete redundant line).
[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 <glib.h>
12 #include <string.h>
13
14 #include "bluesky.h"
15
16 /* Core filesystem.  Different proxies, such as the NFSv3 one, interface to
17  * this, but the core actually tracks the data which is stored.  So far we just
18  * implement an in-memory filesystem, but eventually this will be state which
19  * is persisted to the cloud. */
20
21 /* Return the current time, in microseconds since the epoch. */
22 int64_t bluesky_get_current_time()
23 {
24     GTimeVal t;
25     g_get_current_time(&t);
26     return (int64_t)t.tv_sec * 1000000 + t.tv_usec;
27 }
28
29 /* Update an inode to indicate that a modification was made.  This increases
30  * the change counter, updates the ctime to the current time, and optionally
31  * updates the mtime.  inode must already be locked. */
32 void bluesky_inode_update_ctime(BlueSkyInode *inode, gboolean update_mtime)
33 {
34     int64_t now = bluesky_get_current_time();
35     inode->change_count++;
36     inode->ctime = now;
37     if (update_mtime)
38         inode->mtime = now;
39 }
40
41 /* Unfortunately a glib hash table is only guaranteed to be able to store
42  * 32-bit keys if we use the key directly.  If we want 64-bit inode numbers,
43  * we'll have to allocate memory to store the 64-bit inumber, and use a pointer
44  * to it.  Rather than allocate the memory for the key, we'll just include a
45  * pointer to the 64-bit inum stored in the inode itself, so that we don't need
46  * to do any more memory management.  */
47 static guint bluesky_fs_key_hash_func(gconstpointer key)
48 {
49     uint64_t inum = *(const uint64_t *)key;
50     return (guint)inum;
51 }
52
53 static gboolean bluesky_fs_key_equal_func(gconstpointer a, gconstpointer b)
54 {
55     uint64_t i1 = *(const uint64_t *)a;
56     uint64_t i2 = *(const uint64_t *)b;
57     return i1 == i2;
58 }
59
60 /* Filesystem-level operations.  A filesystem is like a directory tree that we
61  * are willing to export. */
62 BlueSkyFS *bluesky_new_fs(gchar *name)
63 {
64     BlueSkyFS *fs = g_new0(BlueSkyFS, 1);
65     fs->lock = g_mutex_new();
66     fs->name = g_strdup(name);
67     fs->inodes = g_hash_table_new(bluesky_fs_key_hash_func,
68                                   bluesky_fs_key_equal_func);
69     fs->next_inum = BLUESKY_ROOT_INUM + 1;
70     fs->store = bluesky_store_new("file");
71
72     return fs;
73 }
74
75 /* Inode reference counting. */
76 void bluesky_inode_ref(BlueSkyInode *inode)
77 {
78     g_atomic_int_inc(&inode->refcount);
79 }
80
81 void bluesky_inode_unref(BlueSkyInode *inode)
82 {
83     if (g_atomic_int_dec_and_test(&inode->refcount)) {
84         g_error("Reference count for inode %lld dropped to zero!\n",
85                 inode->inum);
86     }
87 }
88
89 /* Allocate a fresh inode number which has not been used before within a
90  * filesystem.  fs must already be locked. */
91 uint64_t bluesky_fs_alloc_inode(BlueSkyFS *fs)
92 {
93     uint64_t inum;
94
95     inum = fs->next_inum;
96     fs->next_inum++;
97
98     return inum;
99 }
100
101 BlueSkyInode *bluesky_new_inode(uint64_t inum, BlueSkyFS *fs,
102                                 BlueSkyFileType type)
103 {
104     BlueSkyInode *i = g_new0(BlueSkyInode, 1);
105
106     i->lock = g_mutex_new();
107     i->refcount = 1;
108     i->type = type;
109     i->fs = fs;
110     i->inum = inum;
111
112     switch (type) {
113     case BLUESKY_REGULAR:
114         i->blocks = g_array_new(FALSE, TRUE, sizeof(BlueSkyBlock));
115         break;
116     case BLUESKY_DIRECTORY:
117         i->dirents = g_sequence_new(bluesky_dirent_destroy);
118         i->dirhash = g_hash_table_new(g_str_hash, g_str_equal);
119         break;
120     case BLUESKY_BLOCK:
121     case BLUESKY_CHARACTER:
122     case BLUESKY_SYMLINK:
123     case BLUESKY_SOCKET:
124     case BLUESKY_FIFO:
125         break;
126     }
127
128     return i;
129 }
130
131 /* Retrieve an inode from the filesystem.  Eventually this will be a cache and
132  * so we might need to go fetch the inode from elsewhere; for now all
133  * filesystem state is stored here.  inode is returned locked with a reference
134  * held. */
135 BlueSkyInode *bluesky_get_inode(BlueSkyFS *fs, uint64_t inum)
136 {
137     BlueSkyInode *inode = NULL;
138
139     g_mutex_lock(fs->lock);
140     inode = (BlueSkyInode *)g_hash_table_lookup(fs->inodes, &inum);
141
142     if (inode == NULL) {
143         bluesky_inode_fetch(fs, inum);
144         inode = (BlueSkyInode *)g_hash_table_lookup(fs->inodes, &inum);
145     }
146
147     if (inode != NULL) {
148         bluesky_inode_ref(inode);
149     }
150
151     g_mutex_unlock(fs->lock);
152
153     return inode;
154 }
155
156 /* Insert an inode into the filesystem inode cache.  fs should be locked. */
157 void bluesky_insert_inode(BlueSkyFS *fs, BlueSkyInode *inode)
158 {
159     g_hash_table_insert(fs->inodes, &inode->inum, inode);
160 }
161
162 /* Synchronize an inode to stable storage. */
163 void bluesky_inode_flush(BlueSkyFS *fs, BlueSkyInode *inode)
164 {
165     GString *buf = g_string_new("");
166     bluesky_serialize_inode(buf, inode);
167
168     gsize len = buf->len;
169     BlueSkyRCStr *data = bluesky_string_new(g_string_free(buf, FALSE), len);
170
171     char key[64];
172     sprintf(key, "inode-%016llx", inode->inum);
173
174     bluesky_store_put(fs->store, key, data);
175 }
176
177 /* Fetch an inode from stable storage. */
178 void bluesky_inode_fetch(BlueSkyFS *fs, uint64_t inum)
179 {
180     char key[64];
181     sprintf(key, "inode-%016llx", inum);
182     BlueSkyRCStr *data = bluesky_store_get(fs->store, key);
183     if (data == NULL)
184         return;
185
186     BlueSkyInode *inode = bluesky_deserialize_inode(fs, data->data);
187     if (inode != NULL) {
188         bluesky_insert_inode(fs, inode);
189         g_print("Loaded inode %lld\n", (long long)inum);
190     }
191 }