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->dirty = bluesky_string_new(g_malloc0(block_len), block_len);
  35         break;
  36     case BLUESKY_BLOCK_REF:
  37         // FIXME: locking on the cloudlog?
  38         bluesky_block_fetch(inode, block, NULL);
  39         bluesky_string_ref(block->ref->data);
  40         block->dirty = bluesky_string_dup(block->ref->data);
  41         break;
  42     case BLUESKY_BLOCK_DIRTY:
  43         block->dirty = bluesky_string_dup(block->dirty);
  44         break;
  45     }
  46
  47     if (block->type != BLUESKY_BLOCK_DIRTY)
  48         g_atomic_int_add(&inode->fs->cache_dirty, 1);
  49
  50     block->type = BLUESKY_BLOCK_DIRTY;
  51     bluesky_cloudlog_unref(block->ref);
  52     block->ref = NULL;
  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 // FIXME
  58 void bluesky_file_truncate(BlueSkyInode *inode, uint64_t size)
  59 {
  60     g_return_if_fail(size <= BLUESKY_MAX_FILE_SIZE);
  61
  62     if (size == inode->size)
  63         return;
  64
  65     if (bluesky_verbose) {
  66         g_log("bluesky/file", G_LOG_LEVEL_DEBUG,
  67               "Truncating file to %"PRIi64" bytes", size);
  68     }
  69
  70     uint64_t blocks = (size + BLUESKY_BLOCK_SIZE - 1) / BLUESKY_BLOCK_SIZE;
  71
  72     if (blocks > inode->blocks->len) {
  73         /* Need to add new blocks to the end of a file.  New block structures
  74          * are automatically zeroed, which initializes them to be pointers to
  75          * zero blocks so we don't need to do any more work.  If the
  76          * previously-last block in the file is smaller than
  77          * BLUESKY_BLOCK_SIZE, extend it to full size. */
  78         if (inode->blocks->len > 0) {
  79             BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
  80                                              inode->blocks->len - 1);
  81
  82             if (b->type != BLUESKY_BLOCK_ZERO
  83                     && (b->type == BLUESKY_BLOCK_REF
  84                         || b->dirty->len < BLUESKY_BLOCK_SIZE)) {
  85                 bluesky_block_touch(inode, inode->blocks->len - 1);
  86                 gsize old_size = b->dirty->len;
  87                 bluesky_string_resize(b->dirty, BLUESKY_BLOCK_SIZE);
  88                 memset(&b->dirty->data[old_size], 0,
  89                        BLUESKY_BLOCK_SIZE - old_size);
  90             }
  91         }
  92
  93         g_array_set_size(inode->blocks, blocks);
  94     } else if (blocks < inode->blocks->len) {
  95         /* Delete blocks from a file.  Must reclaim memory. */
  96         for (guint i = blocks; i < inode->blocks->len; i++) {
  97             BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
  98             if (b->type == BLUESKY_BLOCK_DIRTY)
  99                 g_atomic_int_add(&inode->fs->cache_dirty, -1);
 100             bluesky_string_unref(b->dirty);
 101             bluesky_cloudlog_unref(b->ref);
 102         }
 103         g_array_set_size(inode->blocks, blocks);
 104     }
 105
 106     /* Ensure the new last block of the file is properly sized.  If the block
 107      * is extended, newly-added bytes must be zeroed. */
 108     if (blocks > 0) {
 109         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
 110                                          blocks - 1);
 111
 112         if (b->type != BLUESKY_BLOCK_ZERO) {
 113             bluesky_block_touch(inode, blocks - 1);
 114             gsize old_size = b->dirty->len;
 115             gsize new_size = size - (blocks - 1) * BLUESKY_BLOCK_SIZE;
 116
 117             bluesky_string_resize(b->dirty, new_size);
 118
 119             if (new_size > old_size) {
 120                 memset(&b->dirty->data[old_size], 0, new_size - old_size);
 121             }
 122         }
 123     }
 124
 125     inode->size = size;
 126     bluesky_inode_update_ctime(inode, 1);
 127 }
 128
 129 void bluesky_file_write(BlueSkyInode *inode, uint64_t offset,
 130                         const char *data, gint len)
 131 {
 132     g_return_if_fail(inode->type == BLUESKY_REGULAR);
 133     g_return_if_fail(offset < inode->size);
 134     g_return_if_fail(len <= inode->size - offset);
 135
 136     if (len == 0)
 137         return;
 138
 139     // TODO: Optimization: If we are entirely overwriting a block we don't need
 140     // to fetch it frm storage first.
 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->dirty->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     BlueSkyProfile *profile = bluesky_profile_get();
 170
 171     bluesky_profile_add_event(profile,
 172                               g_strdup_printf("Start file read prefetch"));
 173     uint64_t start_block, end_block;
 174     start_block = offset / BLUESKY_BLOCK_SIZE;
 175     end_block = (offset + len - 1) / BLUESKY_BLOCK_SIZE;
 176     for (uint64_t i = start_block; i <= end_block; i++) {
 177         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
 178                                          i);
 179         if (b->type == BLUESKY_BLOCK_REF)
 180             bluesky_cloudlog_prefetch(b->ref);
 181     }
 182
 183     bluesky_profile_add_event(profile,
 184                               g_strdup_printf("End file read prefetch"));
 185
 186     while (len > 0) {
 187         uint64_t block_num = offset / BLUESKY_BLOCK_SIZE;
 188         gint block_offset = offset % BLUESKY_BLOCK_SIZE;
 189         gint bytes = MIN(BLUESKY_BLOCK_SIZE - block_offset, len);
 190
 191         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock,
 192                                          block_num);
 193         if (b->type == BLUESKY_BLOCK_ZERO) {
 194             memset(buf, 0, bytes);
 195         } else {
 196             BlueSkyRCStr *data = NULL;
 197             if (b->type == BLUESKY_BLOCK_REF) {
 198                 bluesky_block_fetch(inode, b, NULL);
 199                 data = b->ref->data;
 200             } else if (b->type == BLUESKY_BLOCK_DIRTY) {
 201                 data = b->dirty;
 202             }
 203             memcpy(buf, &data->data[block_offset], bytes);
 204         }
 205
 206         offset += bytes;
 207         buf += bytes;
 208         len -= bytes;
 209     }
 210
 211     bluesky_profile_add_event(profile,
 212                               g_strdup_printf("BlueSky read complete"));
 213 }
 214
 215 void bluesky_block_fetch(BlueSkyInode *inode, BlueSkyBlock *block,
 216                          BlueSkyStoreAsync *barrier)
 217 {
 218     if (block->type != BLUESKY_BLOCK_REF)
 219         return;
 220
 221     g_mutex_lock(block->ref->lock);
 222     bluesky_cloudlog_fetch(block->ref);
 223     g_mutex_unlock(block->ref->lock);
 224     block->type = BLUESKY_BLOCK_REF;
 225 }
 226
 227 /* Write the given block to cloud-backed storage and mark it clean. */
 228 void bluesky_block_flush(BlueSkyInode *inode, BlueSkyBlock *block,
 229                          GList **log_items)
 230 {
 231     BlueSkyFS *fs = inode->fs;
 232
 233     if (block->type != BLUESKY_BLOCK_DIRTY)
 234         return;
 235
 236     g_assert(block->ref == NULL);
 237
 238     BlueSkyCloudLog *cloudlog = bluesky_cloudlog_new(fs, NULL);
 239     cloudlog->type = LOGTYPE_DATA;
 240     cloudlog->inum = inode->inum;
 241     cloudlog->data = block->dirty;      // String ownership is transferred
 242     bluesky_cloudlog_stats_update(cloudlog, 1);
 243     bluesky_cloudlog_sync(cloudlog);
 244     bluesky_cloudlog_ref(cloudlog);     // Reference for log_items list
 245     *log_items = g_list_prepend(*log_items, cloudlog);
 246     bluesky_cloudlog_insert(cloudlog);
 247
 248     block->ref = cloudlog;              // Uses initial reference from _new()
 249
 250     block->type = BLUESKY_BLOCK_REF;
 251     block->dirty = NULL;
 252     g_atomic_int_add(&fs->cache_dirty, -1);
 253 }
 254
 255 /* Flush all blocks in a file to stable storage. */
 256 void bluesky_file_flush(BlueSkyInode *inode, GList **log_items)
 257 {
 258     g_return_if_fail(inode->type == BLUESKY_REGULAR);
 259
 260     for (int i = 0; i < inode->blocks->len; i++) {
 261         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
 262         bluesky_block_flush(inode, b, log_items);
 263     }
 264 }
 265
 266 /* Drop clean data blocks for a file from cache. */
 267 void bluesky_file_drop_cached(BlueSkyInode *inode)
 268 {
 269     g_return_if_fail(inode->type == BLUESKY_REGULAR);
 270
 271     for (int i = 0; i < inode->blocks->len; i++) {
 272         BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i);
 273         if (b->type == BLUESKY_BLOCK_REF) {
 274             g_mutex_lock(b->ref->lock);
 275             if (b->ref->data != NULL
 276                 && g_atomic_int_get(&b->ref->data_lock_count) == 0
 277                 && (b->ref->location_flags != 0))
 278             {
 279                 bluesky_cloudlog_stats_update(b->ref, -1);
 280                 bluesky_string_unref(b->ref->data);
 281                 b->ref->data = NULL;
 282                 bluesky_cloudlog_stats_update(b->ref, 1);
 283             }
 284             g_mutex_unlock(b->ref->lock);
 285         }
 286     }
 287 }