e0c62555639708a27caf652712235515ddbf740c
[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  *
21  * If preserve is set to false, this is a hint that the block is about to be
22  * entirely overwritten.  In this case, a dirty block is made available but any
23  * prior contents might be lost.  A value of preserve = TRUE is always safe. */
24 void bluesky_block_touch(BlueSkyInode *inode, uint64_t i, gboolean preserve)
25 {
26     g_return_if_fail(i < inode->blocks->len);
27     BlueSkyBlock *block = &g_array_index(inode->blocks, BlueSkyBlock, i);
28
29     gsize block_len;
30     if (i < inode->blocks->len - 1) {
31         block_len = BLUESKY_BLOCK_SIZE;
32     } else {
33         block_len = inode->size - i * BLUESKY_BLOCK_SIZE;
34     }
35
36     switch (block->type) {
37     case BLUESKY_BLOCK_ZERO:
38         block->dirty = bluesky_string_new(g_malloc0(block_len), block_len);
39         break;
40     case BLUESKY_BLOCK_REF:
41         if (preserve) {
42             // FIXME: locking on the cloudlog?
43             bluesky_block_fetch(inode, block, NULL);
44             bluesky_string_ref(block->ref->data);
45             block->dirty = bluesky_string_dup(block->ref->data);
46         } else {
47             block->dirty = bluesky_string_new(g_malloc0(block_len), block_len);
48         }
49         break;
50     case BLUESKY_BLOCK_DIRTY:
51         block->dirty = bluesky_string_dup(block->dirty);
52         break;
53     }
54
55     if (block->type != BLUESKY_BLOCK_DIRTY)
56         g_atomic_int_add(&inode->fs->cache_dirty, 1);
57
58     block->type = BLUESKY_BLOCK_DIRTY;
59     bluesky_cloudlog_unref(block->ref);
60     block->ref = NULL;
61 }
62
63 /* Set the size of a file.  This will truncate or extend the file as needed.
64  * Newly-allocated bytes are zeroed. */
65 // FIXME
66 void bluesky_file_truncate(BlueSkyInode *inode, uint64_t size)
67 {
68     g_return_if_fail(size <= BLUESKY_MAX_FILE_SIZE);
69
70     if (size == inode->size)
71         return;
72
73     if (bluesky_verbose) {
74         g_log("bluesky/file", G_LOG_LEVEL_DEBUG,
75               "Truncating file to %"PRIi64" bytes", size);
76     }
77
78     uint64_t blocks = (size + BLUESKY_BLOCK_SIZE - 1) / BLUESKY_BLOCK_SIZE;
79
80     /* Calculate number of bytes in the last block of the file */
81     int lastblock_old, lastblock_new;
82     lastblock_old = inode->size % BLUESKY_BLOCK_SIZE;
83     if (lastblock_old == 0 && inode->size > 0)
84         lastblock_old = BLUESKY_BLOCK_SIZE;
85     lastblock_new = size % BLUESKY_BLOCK_SIZE;
86     if (lastblock_new == 0 && size > 0)
87         lastblock_new = BLUESKY_BLOCK_SIZE;
88
89     if (blocks > inode->blocks->len) {
90         /* Need to add new blocks to the end of a file.  New block structures
91          * are automatically zeroed, which initializes them to be pointers to
92          * zero blocks so we don't need to do any more work.  If the
93          * previously-last block in the file is smaller than
94          * BLUESKY_BLOCK_SIZE, extend it to full size. */
95         if (inode->blocks->len > 0) {
96             BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
97                                              inode->blocks->len - 1);
98
99             if (b->type != BLUESKY_BLOCK_ZERO
100                     && lastblock_old < BLUESKY_BLOCK_SIZE) {
101                 bluesky_block_touch(inode, inode->blocks->len - 1, TRUE);
102                 gsize old_size = b->dirty->len;
103                 g_warn_if_fail(lastblock_old != old_size);
104                 bluesky_string_resize(b->dirty, BLUESKY_BLOCK_SIZE);
105                 memset(&b->dirty->data[old_size], 0,
106                        BLUESKY_BLOCK_SIZE - old_size);
107             }
108         }
109
110         g_array_set_size(inode->blocks, blocks);
111     } else if (blocks < inode->blocks->len) {
112         /* Delete blocks from a file.  Must reclaim memory. */
113         for (guint i = blocks; i < inode->blocks->len; i++) {
114             BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
115             if (b->type == BLUESKY_BLOCK_DIRTY)
116                 g_atomic_int_add(&inode->fs->cache_dirty, -1);
117             bluesky_string_unref(b->dirty);
118             bluesky_cloudlog_unref(b->ref);
119         }
120         g_array_set_size(inode->blocks, blocks);
121     }
122
123     /* Ensure the new last block of the file is properly sized.  If the block
124      * is extended, newly-added bytes must be zeroed. */
125     if (blocks > 0) {
126         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
127                                          blocks - 1);
128
129         gboolean need_resize = TRUE;
130         if (b->type == BLUESKY_BLOCK_ZERO)
131             need_resize = FALSE;
132         else if (size < inode->size && lastblock_new == BLUESKY_BLOCK_SIZE)
133             need_resize = FALSE;
134
135         if (need_resize) {
136             bluesky_block_touch(inode, blocks - 1, TRUE);
137             gsize old_size = b->dirty->len;
138             gsize new_size = size - (blocks - 1) * BLUESKY_BLOCK_SIZE;
139
140             bluesky_string_resize(b->dirty, new_size);
141
142             if (new_size > old_size) {
143                 memset(&b->dirty->data[old_size], 0, new_size - old_size);
144             }
145         }
146     }
147
148     inode->size = size;
149     bluesky_inode_update_ctime(inode, 1);
150 }
151
152 void bluesky_file_write(BlueSkyInode *inode, uint64_t offset,
153                         const char *data, gint len)
154 {
155     g_return_if_fail(inode->type == BLUESKY_REGULAR);
156     g_return_if_fail(offset < inode->size);
157     g_return_if_fail(len <= inode->size - offset);
158
159     if (len == 0)
160         return;
161
162     // TODO: Optimization: If we are entirely overwriting a block we don't need
163     // to fetch it frm storage first.  We don't yet handle the case where the
164     // partial last block of a file is entirely overwritten.
165     while (len > 0) {
166         uint64_t block_num = offset / BLUESKY_BLOCK_SIZE;
167         gint block_offset = offset % BLUESKY_BLOCK_SIZE;
168         gint bytes = MIN(BLUESKY_BLOCK_SIZE - block_offset, len);
169
170         gboolean preserve = TRUE;
171         if (block_offset == 0 && bytes == BLUESKY_BLOCK_SIZE) {
172             preserve = FALSE;
173         }
174         bluesky_block_touch(inode, block_num, preserve);
175         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
176                                          block_num);
177         memcpy(&b->dirty->data[block_offset], data, bytes);
178
179         offset += bytes;
180         data += bytes;
181         len -= bytes;
182     }
183
184     bluesky_inode_update_ctime(inode, 1);
185 }
186
187 void bluesky_file_read(BlueSkyInode *inode, uint64_t offset,
188                        char *buf, gint len)
189 {
190     if (len == 0 && offset <= inode->size)
191         return;
192
193     g_return_if_fail(inode->type == BLUESKY_REGULAR);
194     g_return_if_fail(offset < inode->size);
195     g_return_if_fail(len <= inode->size - offset);
196
197     BlueSkyProfile *profile = bluesky_profile_get();
198
199     bluesky_profile_add_event(profile,
200                               g_strdup_printf("Start file read prefetch"));
201     uint64_t start_block, end_block;
202     start_block = offset / BLUESKY_BLOCK_SIZE;
203     end_block = (offset + len - 1) / BLUESKY_BLOCK_SIZE;
204     for (uint64_t i = start_block; i <= end_block; i++) {
205         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
206                                          i);
207         if (b->type == BLUESKY_BLOCK_REF)
208             bluesky_cloudlog_prefetch(b->ref);
209     }
210
211     bluesky_profile_add_event(profile,
212                               g_strdup_printf("End file read prefetch"));
213
214     while (len > 0) {
215         uint64_t block_num = offset / BLUESKY_BLOCK_SIZE;
216         gint block_offset = offset % BLUESKY_BLOCK_SIZE;
217         gint bytes = MIN(BLUESKY_BLOCK_SIZE - block_offset, len);
218
219         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
220                                          block_num);
221         if (b->type == BLUESKY_BLOCK_ZERO) {
222             memset(buf, 0, bytes);
223         } else {
224             BlueSkyRCStr *data = NULL;
225             if (b->type == BLUESKY_BLOCK_REF) {
226                 bluesky_block_fetch(inode, b, NULL);
227                 data = b->ref->data;
228             } else if (b->type == BLUESKY_BLOCK_DIRTY) {
229                 data = b->dirty;
230             }
231             memcpy(buf, &data->data[block_offset], bytes);
232         }
233
234         offset += bytes;
235         buf += bytes;
236         len -= bytes;
237     }
238
239     bluesky_profile_add_event(profile,
240                               g_strdup_printf("BlueSky read complete"));
241 }
242
243 void bluesky_block_fetch(BlueSkyInode *inode, BlueSkyBlock *block,
244                          BlueSkyStoreAsync *barrier)
245 {
246     if (block->type != BLUESKY_BLOCK_REF)
247         return;
248
249     g_mutex_lock(block->ref->lock);
250     bluesky_cloudlog_fetch(block->ref);
251     g_mutex_unlock(block->ref->lock);
252     block->type = BLUESKY_BLOCK_REF;
253 }
254
255 /* Write the given block to cloud-backed storage and mark it clean. */
256 void bluesky_block_flush(BlueSkyInode *inode, BlueSkyBlock *block,
257                          GList **log_items)
258 {
259     BlueSkyFS *fs = inode->fs;
260
261     if (block->type != BLUESKY_BLOCK_DIRTY)
262         return;
263
264     g_assert(block->ref == NULL);
265
266     BlueSkyCloudLog *cloudlog = bluesky_cloudlog_new(fs, NULL);
267     cloudlog->type = LOGTYPE_DATA;
268     cloudlog->inum = inode->inum;
269     cloudlog->data = block->dirty;      // String ownership is transferred
270     bluesky_cloudlog_stats_update(cloudlog, 1);
271     bluesky_cloudlog_sync(cloudlog);
272     bluesky_cloudlog_ref(cloudlog);     // Reference for log_items list
273     *log_items = g_list_prepend(*log_items, cloudlog);
274     bluesky_cloudlog_insert(cloudlog);
275
276     block->ref = cloudlog;              // Uses initial reference from _new()
277
278     block->type = BLUESKY_BLOCK_REF;
279     block->dirty = NULL;
280     g_atomic_int_add(&fs->cache_dirty, -1);
281 }
282
283 /* Flush all blocks in a file to stable storage. */
284 void bluesky_file_flush(BlueSkyInode *inode, GList **log_items)
285 {
286     g_return_if_fail(inode->type == BLUESKY_REGULAR);
287
288     for (int i = 0; i < inode->blocks->len; i++) {
289         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
290         bluesky_block_flush(inode, b, log_items);
291     }
292 }
293
294 /* Drop clean data blocks for a file from cache. */
295 void bluesky_file_drop_cached(BlueSkyInode *inode)
296 {
297     g_return_if_fail(inode->type == BLUESKY_REGULAR);
298
299     for (int i = 0; i < inode->blocks->len; i++) {
300         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
301         if (b->type == BLUESKY_BLOCK_REF) {
302             g_mutex_lock(b->ref->lock);
303             if (b->ref->data != NULL
304                 && g_atomic_int_get(&b->ref->data_lock_count) == 0
305                 && (b->ref->location_flags != 0))
306             {
307                 bluesky_cloudlog_stats_update(b->ref, -1);
308                 bluesky_string_unref(b->ref->data);
309                 b->ref->data = NULL;
310                 bluesky_cloudlog_stats_update(b->ref, 1);
311             }
312             g_mutex_unlock(b->ref->lock);
313         }
314     }
315 }