X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;ds=sidebyside;f=inode.c;h=aa822b76736ddb58bddbdc09302504dad47ac232;hb=19f316a185dc3d2a67fc3d3546f3989e45559d7c;hp=5f31326da95b8963becb2e6eab9d18a1c652abd6;hpb=2246171d841d34e6368e340a6b76b7ee9d9a1084;p=bluesky.git diff --git a/inode.c b/inode.c index 5f31326..aa822b7 100644 --- a/inode.c +++ b/inode.c @@ -9,33 +9,64 @@ #include #include -#include "inode.h" +#include "bluesky.h" /* Core filesystem. Different proxies, such as the NFSv3 one, interface to * this, but the core actually tracks the data which is stored. So far we just * implement an in-memory filesystem, but eventually this will be state which * is persisted to the cloud. */ +/* Return the current time, in microseconds since the epoch. */ +int64_t bluesky_get_current_time() +{ + GTimeVal t; + g_get_current_time(&t); + return (int64_t)t.tv_sec * 1000000 + t.tv_usec; +} -/* Hash a filename for a directory lookup. The string is hashed to a 64-bit - * value. */ -uint64_t bluesky_directory_hash(gchar *name) +/* Update an inode to indicate that a modification was made. This increases + * the change counter, updates the ctime to the current time, and optionally + * updates the mtime. */ +void bluesky_inode_update_ctime(BlueSkyInode *inode, gboolean update_mtime) { - GChecksum *csum = g_checksum_new(G_CHECKSUM_MD5); - g_checksum_update(csum, (guchar *)name, -1); + int64_t now = bluesky_get_current_time(); + inode->change_count++; + inode->ctime = now; + if (update_mtime) + inode->mtime = now; +} - guint64 hashbytes[2]; - gsize hashsize = sizeof(hashbytes); - g_checksum_get_digest(csum, (guint8 *)hashbytes, &hashsize); - return GUINT64_FROM_LE(hashbytes[0]); +/* Unfortunately a glib hash table is only guaranteed to be able to store + * 32-bit keys if we use the key directly. If we want 64-bit inode numbers, + * we'll have to allocate memory to store the 64-bit inumber, and use a pointer + * to it. Rather than allocate the memory for the key, we'll just include a + * pointer to the 64-bit inum stored in the inode itself, so that we don't need + * to do any more memory management. */ +static guint bluesky_fs_key_hash_func(gconstpointer key) +{ + uint64_t inum = *(const uint64_t *)key; + return (guint)inum; } -/* Return the current time, in microseconds since the epoch. */ -int64_t bluesky_get_current_time() +static gboolean bluesky_fs_key_equal_func(gconstpointer a, gconstpointer b) { - GTimeVal t; - g_get_current_time(&t); - return t.tv_sec * 1000000 + t.tv_usec; + uint64_t i1 = *(const uint64_t *)a; + uint64_t i2 = *(const uint64_t *)b; + return i1 == i2; +} + +/* Filesystem-level operations. A filesystem is like a directory tree that we + * are willing to export. */ +BlueSkyFS *bluesky_new_fs(gchar *name) +{ + BlueSkyFS *fs = g_new0(BlueSkyFS, 1); + fs->lock = g_mutex_new(); + fs->name = g_strdup(name); + fs->inodes = g_hash_table_new(bluesky_fs_key_hash_func, + bluesky_fs_key_equal_func); + fs->next_inum = BLUESKY_ROOT_INUM + 1; + + return fs; } /* Allocate a fresh inode number which has not been used before within a @@ -52,61 +83,83 @@ uint64_t bluesky_fs_alloc_inode(BlueSkyFS *fs) return inum; } -BlueSkyInode *bluesky_new_inode(uint64_t inum) +BlueSkyInode *bluesky_new_inode(uint64_t inum, BlueSkyFileType type) { BlueSkyInode *i = g_new0(BlueSkyInode, 1); i->lock = g_mutex_new(); + i->type = type; i->inum = inum; + switch (type) { + case BLUESKY_REGULAR: + i->blocks = g_array_new(FALSE, TRUE, sizeof(BlueSkyBlock)); + break; + case BLUESKY_DIRECTORY: + i->dirents = g_sequence_new(bluesky_dirent_destroy); + i->dirhash = g_hash_table_new(g_str_hash, g_str_equal); + break; + case BLUESKY_BLOCK: + case BLUESKY_CHARACTER: + case BLUESKY_SYMLINK: + case BLUESKY_SOCKET: + case BLUESKY_FIFO: + break; + } + return i; } -void bluesky_dirent_destroy(BlueSkyDirent *dirent) +/* Retrieve an inode from the filesystem. Eventually this will be a cache and + * so we might need to go fetch the inode from elsewhere; for now all + * filesystem state is stored here. */ +BlueSkyInode *bluesky_get_inode(BlueSkyFS *fs, uint64_t inum) { - g_free(dirent->name); - g_free(dirent); + BlueSkyInode *inode = NULL; + + g_mutex_lock(fs->lock); + inode = (BlueSkyInode *)g_hash_table_lookup(fs->inodes, &inum); + g_mutex_unlock(fs->lock); + + return inode; } -gint bluesky_dirent_compare(gconstpointer a, gconstpointer b, - gpointer unused) +/* Insert an inode into the filesystem inode cache. */ +void bluesky_insert_inode(BlueSkyFS *fs, BlueSkyInode *inode) { - /* We can't simply subtract the hash values, since they are 64-bit and the - * result could overflow when converted to a gint. */ - uint64_t hash1 = ((const BlueSkyDirent *)a)->hash; - uint64_t hash2 = ((const BlueSkyDirent *)b)->hash; - - if (hash1 < hash2) - return -1; - else if (hash1 > hash2) - return 1; - else - return 0; + g_mutex_lock(fs->lock); + g_hash_table_insert(fs->inodes, &inode->inum, inode); + g_mutex_unlock(fs->lock); } -/* Perform a lookup for a file name within a directory. Returns the inode - * number if found, or 0 if not (0 is never a valid inode number). Should be - * called with the inode lock already held. */ -uint64_t bluesky_directory_lookup(BlueSkyInode *inode, gchar *name) +/* Set the size of a file. This will truncate or extend the file as needed. + * Newly-allocated bytes are zeroed. */ +void bluesky_file_truncate(BlueSkyInode *inode, uint64_t size) { - g_return_val_if_fail(inode->type != BLUESKY_DIRECTORY, 0); - g_return_val_if_fail(inode->dirents != NULL, 0); - - /* First, construct a hash of the file name. Search the directory for a - * match, then check to see if it does really match. */ - uint64_t hash = bluesky_directory_hash(name); - - BlueSkyDirent d = {name, hash, 0}; - GSequenceIter *i = g_sequence_search(inode->dirents, &d, - bluesky_dirent_compare, NULL); - - if (g_sequence_iter_is_end(i)) - return 0; - BlueSkyDirent *dirent = g_sequence_get(i); - if (dirent->hash != hash) - return 0; - if (g_strcmp0(name, dirent->name) != 0) - return 0; - - return dirent->inum; + g_return_if_fail(size <= BLUESKY_MAX_FILE_SIZE); + + if (size == inode->size) + return; + + uint64_t blocks = (size + BLUESKY_BLOCK_SIZE - 1) / BLUESKY_MAX_FILE_SIZE; + + if (blocks > inode->blocks->len) { + /* Need to add new blocks to the end of a file. New block structures + * are automatically zeroed, which initializes them to be pointers to + * zero blocks so we don't need to do any more work. */ + g_array_set_size(inode->blocks, blocks); + } else if (blocks < inode->blocks->len) { + /* Delete blocks from a file. Must reclaim memory. */ + for (guint i = inode->blocks->len; i < blocks; i++) { + BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i); + g_free(b->ref); + g_free(b->data); + } + g_array_set_size(inode->blocks, blocks); + } + + /* TODO: Zero out partial blocks if needed? */ + + inode->size = size; + inode->change_count++; }