Fix filesystem locking when creating a new inode.
[bluesky.git] / bluesky / file.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 <glib.h>
11 #include <string.h>
12 #include <inttypes.h>
13
14 #include "bluesky-private.h"
15
16 /* Core filesystem: handling of regular files and caching of file data. */
17
18 /* Mark a given block dirty and make sure that data is faulted in so that it
19  * can be written to. */
20 void bluesky_block_touch(BlueSkyInode *inode, uint64_t i)
21 {
22     g_return_if_fail(i < inode->blocks->len);
23     BlueSkyBlock *block = &g_array_index(inode->blocks, BlueSkyBlock, i);
24
25     gsize block_len;
26     if (i < inode->blocks->len - 1) {
27         block_len = BLUESKY_BLOCK_SIZE;
28     } else {
29         block_len = inode->size - i * BLUESKY_BLOCK_SIZE;
30     }
31
32     switch (block->type) {
33     case BLUESKY_BLOCK_ZERO:
34         block->data = bluesky_string_new(g_malloc0(block_len), block_len);
35         break;
36     case BLUESKY_BLOCK_REF:
37         bluesky_block_fetch(inode->fs, block, NULL);
38         g_assert(block->type == BLUESKY_BLOCK_CACHED);
39         /* Fall through */
40     case BLUESKY_BLOCK_CACHED:
41     case BLUESKY_BLOCK_DIRTY:
42         block->data = bluesky_string_dup(block->data);
43         break;
44     }
45
46     if (block->type != BLUESKY_BLOCK_CACHED
47             && block->type != BLUESKY_BLOCK_DIRTY)
48         g_atomic_int_add(&inode->fs->cache_total, 1);
49     if (block->type != BLUESKY_BLOCK_DIRTY)
50         g_atomic_int_add(&inode->fs->cache_dirty, 1);
51
52     block->type = BLUESKY_BLOCK_DIRTY;
53 }
54
55 /* Set the size of a file.  This will truncate or extend the file as needed.
56  * Newly-allocated bytes are zeroed. */
57 void bluesky_file_truncate(BlueSkyInode *inode, uint64_t size)
58 {
59     g_return_if_fail(size <= BLUESKY_MAX_FILE_SIZE);
60
61     if (size == inode->size)
62         return;
63
64     if (bluesky_verbose) {
65         g_log("bluesky/file", G_LOG_LEVEL_DEBUG,
66               "Truncating file to %"PRIi64" bytes", size);
67     }
68
69     uint64_t blocks = (size + BLUESKY_BLOCK_SIZE - 1) / BLUESKY_BLOCK_SIZE;
70
71     if (blocks > inode->blocks->len) {
72         /* Need to add new blocks to the end of a file.  New block structures
73          * are automatically zeroed, which initializes them to be pointers to
74          * zero blocks so we don't need to do any more work.  If the
75          * previously-last block in the file is smaller than
76          * BLUESKY_BLOCK_SIZE, extend it to full size. */
77         if (inode->blocks->len > 0) {
78             BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
79                                              inode->blocks->len - 1);
80
81             if (b->type != BLUESKY_BLOCK_ZERO
82                     && (b->type == BLUESKY_BLOCK_REF
83                         || b->data->len < BLUESKY_BLOCK_SIZE)) {
84                 bluesky_block_touch(inode, inode->blocks->len - 1);
85                 gsize old_size = b->data->len;
86                 bluesky_string_resize(b->data, BLUESKY_BLOCK_SIZE);
87                 memset(&b->data->data[old_size], 0,
88                        BLUESKY_BLOCK_SIZE - old_size);
89             }
90         }
91
92         g_array_set_size(inode->blocks, blocks);
93     } else if (blocks < inode->blocks->len) {
94         /* Delete blocks from a file.  Must reclaim memory. */
95         for (guint i = inode->blocks->len; i < blocks; i++) {
96             BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
97             g_free(b->ref);
98             if (b->type == BLUESKY_BLOCK_CACHED
99                     || b->type == BLUESKY_BLOCK_DIRTY)
100                 g_atomic_int_add(&inode->fs->cache_total, -1);
101             if (b->type == BLUESKY_BLOCK_DIRTY)
102                 g_atomic_int_add(&inode->fs->cache_dirty, -1);
103             bluesky_string_unref(b->data);
104         }
105         g_array_set_size(inode->blocks, blocks);
106     }
107
108     /* Ensure the new last block of the file is properly sized.  If the block
109      * is extended, newly-added bytes must be zeroed. */
110     if (blocks > 0) {
111         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
112                                          blocks - 1);
113
114         if (b->type != BLUESKY_BLOCK_ZERO) {
115             bluesky_block_touch(inode, blocks - 1);
116             gsize old_size = b->data->len;
117             gsize new_size = size - (blocks - 1) * BLUESKY_BLOCK_SIZE;
118
119             bluesky_string_resize(b->data, new_size);
120
121             if (new_size > old_size) {
122                 memset(&b->data->data[old_size], 0, new_size - old_size);
123             }
124         }
125     }
126
127     inode->size = size;
128     bluesky_inode_update_ctime(inode, 1);
129 }
130
131 void bluesky_file_write(BlueSkyInode *inode, uint64_t offset,
132                         const char *data, gint len)
133 {
134     g_return_if_fail(inode->type == BLUESKY_REGULAR);
135     g_return_if_fail(offset < inode->size);
136     g_return_if_fail(len <= inode->size - offset);
137
138     if (len == 0)
139         return;
140
141     while (len > 0) {
142         uint64_t block_num = offset / BLUESKY_BLOCK_SIZE;
143         gint block_offset = offset % BLUESKY_BLOCK_SIZE;
144         gint bytes = MIN(BLUESKY_BLOCK_SIZE - block_offset, len);
145
146         bluesky_block_touch(inode, block_num);
147         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
148                                          block_num);
149         memcpy(&b->data->data[block_offset], data, bytes);
150
151         offset += bytes;
152         data += bytes;
153         len -= bytes;
154     }
155
156     bluesky_inode_update_ctime(inode, 1);
157 }
158
159 void bluesky_file_read(BlueSkyInode *inode, uint64_t offset,
160                        char *buf, gint len)
161 {
162     if (len == 0 && offset <= inode->size)
163         return;
164
165     g_return_if_fail(inode->type == BLUESKY_REGULAR);
166     g_return_if_fail(offset < inode->size);
167     g_return_if_fail(len <= inode->size - offset);
168
169     /* Start fetches on any data blocks that we will need for this read. */
170     BlueSkyStoreAsync *barrier = bluesky_store_async_new(inode->fs->store);
171     barrier->op = STORE_OP_BARRIER;
172     uint64_t start_block, end_block;
173     start_block = offset / BLUESKY_BLOCK_SIZE;
174     end_block = (offset + len - 1) / BLUESKY_BLOCK_SIZE;
175     if (bluesky_verbose) {
176         g_log("bluesky/file", G_LOG_LEVEL_DEBUG,
177               "Start prefetch on blocks %"PRIi64" .. %"PRIi64,
178               start_block, end_block);
179     }
180     for (uint64_t i = start_block; i <= end_block; i++) {
181         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
182                                          i);
183         if (b->type == BLUESKY_BLOCK_REF)
184             bluesky_block_fetch(inode->fs, b, barrier);
185     }
186     bluesky_store_async_submit(barrier);
187     bluesky_store_async_wait(barrier);
188     bluesky_store_async_unref(barrier);
189     if (bluesky_verbose) {
190         g_log("bluesky/file", G_LOG_LEVEL_DEBUG, "Prefetch complete.");
191     }
192
193     while (len > 0) {
194         uint64_t block_num = offset / BLUESKY_BLOCK_SIZE;
195         gint block_offset = offset % BLUESKY_BLOCK_SIZE;
196         gint bytes = MIN(BLUESKY_BLOCK_SIZE - block_offset, len);
197
198         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
199                                          block_num);
200         switch (b->type) {
201         case BLUESKY_BLOCK_ZERO:
202             memset(buf, 0, bytes);
203             break;
204         case BLUESKY_BLOCK_REF:
205             bluesky_block_fetch(inode->fs, b, NULL);
206             /* Fall through */
207         case BLUESKY_BLOCK_CACHED:
208         case BLUESKY_BLOCK_DIRTY:
209             memcpy(buf, &b->data->data[block_offset], bytes);
210             break;
211         }
212
213         offset += bytes;
214         buf += bytes;
215         len -= bytes;
216     }
217 }
218
219 /* Read the given block from cloud-backed storage if the data is not already
220  * cached. */
221 static void block_fetch_completion(BlueSkyStoreAsync *async, gpointer data)
222 {
223     BlueSkyBlock *block = (BlueSkyBlock *)data;
224
225     bluesky_string_unref(block->data);
226     block->data = async->data;
227     bluesky_string_ref(block->data);
228
229     if (block->data == NULL) {
230         g_warning("Failed to fetch data block from store!\n");
231         block->data = bluesky_string_new(g_malloc0(BLUESKY_BLOCK_SIZE),
232                                          BLUESKY_BLOCK_SIZE);
233     }
234
235     block->type = BLUESKY_BLOCK_CACHED;
236 }
237
238 void bluesky_block_fetch(BlueSkyFS *fs, BlueSkyBlock *block,
239                          BlueSkyStoreAsync *barrier)
240 {
241     if (block->type != BLUESKY_BLOCK_REF)
242         return;
243
244     BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
245     async->op = STORE_OP_GET;
246     async->key = g_strdup(block->ref);
247     bluesky_store_async_add_notifier(async, (GFunc)block_fetch_completion, block);
248     bluesky_store_async_submit(async);
249
250     if (barrier != NULL)
251         bluesky_store_add_barrier(barrier, async);
252     else
253         bluesky_store_async_wait(async);
254
255     bluesky_store_async_unref(async);
256     g_atomic_int_add(&fs->cache_total, 1);
257 }
258
259 /* Write the given block to cloud-backed storage and mark it clean. */
260 void bluesky_block_flush(BlueSkyFS *fs, BlueSkyBlock *block,
261                          BlueSkyStoreAsync *barrier)
262 {
263     if (block->type != BLUESKY_BLOCK_DIRTY)
264         return;
265
266     BlueSkyRCStr *data = block->data;
267
268     GChecksum *csum = g_checksum_new(G_CHECKSUM_SHA256);
269     g_checksum_update(csum, (const guchar *)data->data, data->len);
270     gchar *name = g_strdup(g_checksum_get_string(csum));
271
272     /* Store the file data asynchronously, and don't bother waiting for a
273      * response. */
274     BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
275     async->op = STORE_OP_PUT;
276     async->key = g_strdup(name);
277     bluesky_string_ref(data);
278     async->data = data;
279     bluesky_store_async_submit(async);
280     if (barrier != NULL)
281         bluesky_store_add_barrier(barrier, async);
282     bluesky_store_async_unref(async);
283
284     g_free(block->ref);
285     block->ref = name;
286
287     block->type = BLUESKY_BLOCK_CACHED;
288     g_atomic_int_add(&fs->cache_dirty, -1);
289
290     g_checksum_free(csum);
291 }
292
293 /* Flush all blocks in a file to stable storage. */
294 void bluesky_file_flush(BlueSkyInode *inode, BlueSkyStoreAsync *barrier)
295 {
296     g_return_if_fail(inode->type == BLUESKY_REGULAR);
297
298     for (int i = 0; i < inode->blocks->len; i++) {
299         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
300         bluesky_block_flush(inode->fs, b, barrier);
301     }
302 }
303
304 /* Drop clean data blocks for a file from cache. */
305 void bluesky_file_drop_cached(BlueSkyInode *inode)
306 {
307     g_return_if_fail(inode->type == BLUESKY_REGULAR);
308
309     for (int i = 0; i < inode->blocks->len; i++) {
310         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
311         if (b->type == BLUESKY_BLOCK_CACHED) {
312             if (bluesky_verbose) {
313                 g_log("bluesky/cache", G_LOG_LEVEL_DEBUG,
314                       "Dropping block %d of inode %"PRIu64" from cache",
315                       i, inode->inum);
316                 g_log("bluesky/cache", G_LOG_LEVEL_DEBUG,
317                       "  (reference count was %d)", b->data->refcount);
318             }
319
320             bluesky_string_unref(b->data);
321             b->data = NULL;
322             b->type = BLUESKY_BLOCK_REF;
323             g_atomic_int_add(&inode->fs->cache_total, -1);
324         }
325     }
326 }