Fix filesystem locking when creating a new inode.
[bluesky.git] / bluesky / serialize.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 <stdint.h>
10 #include <inttypes.h>
11 #include <glib.h>
12 #include <string.h>
13
14 #include "bluesky-private.h"
15
16 /* Serialization of in-memory filesystem data structures to bytestrings which
17  * can be written to persistent storage.  All data is stored in little-endian
18  * format. */
19
20 /* Magic signature and structure of serialized superblocks. */
21
22 #define SUPERBLOCK_MAGIC 0x65ca91e91b124234ULL
23
24 struct serialized_superblock {
25     uint64_t signature;         /* SUPERBLOCK_MAGIC */
26     uint64_t next_inum;
27 } __attribute__((packed));
28
29 /* Magic signature for serialized inodes. */
30
31 #define INODE_MAGIC 0xa6832100943d71e6ULL
32
33 struct serialized_inode {
34     uint64_t signature;         /* INODE_MAGIC */
35     int32_t type;
36     uint32_t mode;
37     uint32_t uid, gid;
38     uint32_t nlink;
39     uint64_t inum;
40     uint64_t change_count;
41     int64_t atime;
42     int64_t ctime;
43     int64_t mtime;
44     int64_t ntime;
45 } __attribute__((packed));
46
47 void bluesky_serialize_superblock(GString *out, BlueSkyFS *fs)
48 {
49     struct serialized_superblock buf;
50
51     buf.signature = GUINT64_TO_LE(SUPERBLOCK_MAGIC);
52     buf.next_inum = GUINT64_TO_LE(fs->next_inum);
53
54     g_string_append_len(out, (gchar *)&buf, sizeof(buf));
55 }
56
57 BlueSkyFS *bluesky_deserialize_superblock(const gchar *buf)
58 {
59     struct serialized_superblock *raw = (struct serialized_superblock *)buf;
60
61     if (GUINT64_FROM_LE(raw->signature) != SUPERBLOCK_MAGIC)
62         return NULL;
63
64     BlueSkyFS *fs = bluesky_new_fs("deserialized");
65     fs->next_inum = GUINT64_FROM_LE(raw->next_inum);
66
67     return fs;
68 }
69
70 void bluesky_serialize_inode(GString *out, BlueSkyInode *inode)
71 {
72     struct serialized_inode buf;
73
74     buf.signature = GUINT64_TO_LE(INODE_MAGIC);
75     buf.type = GUINT32_TO_LE(inode->type);
76     buf.mode = GUINT32_TO_LE(inode->mode);
77     buf.uid = GUINT32_TO_LE(inode->uid);
78     buf.gid = GUINT32_TO_LE(inode->gid);
79     buf.nlink = GUINT32_TO_LE(inode->nlink);
80     buf.inum = GUINT64_TO_LE(inode->inum);
81     buf.change_count = GUINT64_TO_LE(inode->change_count);
82     buf.atime = GINT64_TO_LE(inode->atime);
83     buf.ctime = GINT64_TO_LE(inode->ctime);
84     buf.mtime = GINT64_TO_LE(inode->mtime);
85     buf.ntime = GINT64_TO_LE(inode->ntime);
86
87     g_string_append_len(out, (gchar *)&buf, sizeof(buf));
88
89     switch (inode->type) {
90     case BLUESKY_REGULAR:
91     {
92         uint64_t size = GUINT64_TO_LE(inode->size);
93         g_string_append_len(out, (gchar *)&size, sizeof(uint64_t));
94         for (int i = 0; i < inode->blocks->len; i++) {
95             BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
96             if (b->ref != NULL)
97                 g_string_append(out, b->ref);
98             g_string_append_c(out, '\0');
99         }
100         break;
101     }
102
103     case BLUESKY_DIRECTORY:
104     {
105         uint32_t seq;
106         uint64_t inum;
107         GSequenceIter *i = g_sequence_get_begin_iter(inode->dirents);
108
109         while (!g_sequence_iter_is_end(i)) {
110             BlueSkyDirent *d = g_sequence_get(i);
111
112             seq = GUINT32_TO_LE(d->cookie);
113             inum = GUINT64_TO_LE(d->inum);
114             g_string_append_len(out, (gchar *)&seq, sizeof(uint32_t));
115             g_string_append_len(out, (gchar *)&inum, sizeof(uint64_t));
116             g_string_append(out, d->name);
117             g_string_append_c(out, '\0');
118
119             i = g_sequence_iter_next(i);
120         }
121
122         seq = GUINT32_TO_LE(0);
123         g_string_append_len(out, (gchar *)&seq, sizeof(uint32_t));
124
125         break;
126     }
127
128     case BLUESKY_SYMLINK:
129     {
130         g_string_append(out, inode->symlink_contents);
131         g_string_append_c(out, '\0');
132         break;
133     }
134
135     default:
136         g_warning("Serialization for inode type %d not implemented!\n",
137                   inode->type);
138     }
139 }
140
141 /* Deserialize an inode into an in-memory representation.  Returns a boolean
142  * indicating whether the deserialization was successful. */
143 gboolean bluesky_deserialize_inode(BlueSkyInode *inode, const gchar *buf)
144 {
145     if (bluesky_verbose) {
146         g_log("bluesky/serialize", G_LOG_LEVEL_DEBUG,
147               "Deserializing inode %lld...", (long long)inode->inum);
148     }
149
150     struct serialized_inode *raw = (struct serialized_inode *)buf;
151
152     if (GUINT64_FROM_LE(raw->signature) != INODE_MAGIC)
153         return FALSE;
154
155     if (inode->inum != GUINT64_FROM_LE(raw->inum))
156         return FALSE;
157
158     bluesky_init_inode(inode, GUINT32_FROM_LE(raw->type));
159
160     inode->mode = GUINT32_FROM_LE(raw->mode);
161     inode->uid = GUINT32_FROM_LE(raw->uid);
162     inode->gid = GUINT32_FROM_LE(raw->gid);
163     inode->nlink = GUINT32_FROM_LE(raw->nlink);
164     inode->change_count = GUINT64_FROM_LE(raw->change_count);
165     inode->change_commit = inode->change_count;
166     inode->atime = GINT64_FROM_LE(raw->atime);
167     inode->ctime = GINT64_FROM_LE(raw->ctime);
168     inode->mtime = GINT64_FROM_LE(raw->mtime);
169     inode->ntime = GINT64_FROM_LE(raw->ntime);
170
171     buf += sizeof(struct serialized_inode);
172
173     /* TODO: Bounds checking */
174     switch (inode->type) {
175     case BLUESKY_REGULAR:
176         inode->size = GINT64_FROM_LE(*(uint64_t *)buf);
177         buf += sizeof(uint64_t);
178         g_array_set_size(inode->blocks,
179                          (inode->size + BLUESKY_BLOCK_SIZE - 1)
180                           / BLUESKY_BLOCK_SIZE);
181         for (int i = 0; i < inode->blocks->len; i++) {
182             BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
183             b->type = BLUESKY_BLOCK_REF;
184             b->ref = g_strdup(buf);
185             buf += strlen(b->ref) + 1;
186         }
187         break;
188
189     case BLUESKY_DIRECTORY:
190     {
191         struct serialized_dirent {
192             uint32_t seq;
193             uint64_t inum;
194             gchar name[0];
195         } __attribute__((packed));
196
197         struct serialized_dirent *d = (struct serialized_dirent *)buf;
198         while (GUINT32_FROM_LE(d->seq) != 0) {
199             BlueSkyDirent *dirent = g_new(BlueSkyDirent, 1);
200             dirent->cookie = GUINT64_FROM_LE(d->seq);
201             dirent->inum = GUINT64_FROM_LE(d->inum);
202             dirent->name = g_strdup(d->name);
203             dirent->name_folded = bluesky_lowercase(d->name);
204
205             g_sequence_insert_sorted(inode->dirents, dirent,
206                                      bluesky_dirent_compare, NULL);
207             g_hash_table_insert(inode->dirhash, dirent->name, dirent);
208             g_hash_table_insert(inode->dirhash_folded, dirent->name_folded,
209                                 dirent);
210
211             buf = strchr(d->name, '\0') + 1;
212             d = (struct serialized_dirent *)buf;
213         }
214         break;
215     }
216
217     case BLUESKY_SYMLINK:
218     {
219         inode->symlink_contents = g_strdup(buf);
220         break;
221     }
222
223     default:
224         g_warning("Deserialization for inode type %d not implemented!\n",
225                   inode->type);
226     }
227
228     return TRUE;
229 }