| /branches/dd/uspace/srv/fs/tmpfs/tmpfs.h |
|---|
| 40,8 → 40,16 |
| #include <bool.h> |
| #include <libadt/hash_table.h> |
| #ifndef dprintf |
| #define dprintf(...) printf(__VA_ARGS__) |
| #endif |
| typedef enum { |
| TMPFS_NONE, |
| TMPFS_FILE, |
| TMPFS_DIRECTORY |
| } tmpfs_dentry_type_t; |
| typedef struct tmpfs_dentry { |
| fs_index_t index; /**< TMPFS node index. */ |
| link_t dh_link; /**< Dentries hash table link. */ |
| 48,11 → 56,7 |
| struct tmpfs_dentry *sibling; |
| struct tmpfs_dentry *child; |
| hash_table_t names; /**< All names linking to this TMPFS node. */ |
| enum { |
| TMPFS_NONE, |
| TMPFS_FILE, |
| TMPFS_DIRECTORY |
| } type; |
| tmpfs_dentry_type_t type; |
| unsigned lnkcnt; /**< Link count. */ |
| size_t size; /**< File size if type is TMPFS_FILE. */ |
| void *data; /**< File content's if type is TMPFS_FILE. */ |
| 60,6 → 64,9 |
| extern fs_reg_t tmpfs_reg; |
| extern libfs_ops_t tmpfs_libfs_ops; |
| extern void tmpfs_mounted(ipc_callid_t, ipc_call_t *); |
| extern void tmpfs_mount(ipc_callid_t, ipc_call_t *); |
| extern void tmpfs_lookup(ipc_callid_t, ipc_call_t *); |
| extern void tmpfs_read(ipc_callid_t, ipc_call_t *); |
| 67,6 → 74,8 |
| extern void tmpfs_truncate(ipc_callid_t, ipc_call_t *); |
| extern void tmpfs_destroy(ipc_callid_t, ipc_call_t *); |
| extern bool tmpfs_restore(dev_handle_t); |
| #endif |
| /** |
| /branches/dd/uspace/srv/fs/tmpfs/tmpfs_dump.c |
|---|
| 0,0 → 1,197 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * Copyright (c) 2008 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup fs |
| * @{ |
| */ |
| /** |
| * @file tmpfs_dump.c |
| * @brief Support for loading TMPFS file system dump. |
| */ |
| #include "tmpfs.h" |
| #include "../../vfs/vfs.h" |
| #include <errno.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <as.h> |
| #include <libblock.h> |
| #include <byteorder.h> |
| #define TMPFS_BLOCK_SIZE 1024 |
| struct rdentry { |
| uint8_t type; |
| uint32_t len; |
| } __attribute__((packed)); |
| static bool |
| tmpfs_restore_recursion(int dev, off_t *bufpos, size_t *buflen, off_t *pos, |
| tmpfs_dentry_t *parent) |
| { |
| struct rdentry entry; |
| libfs_ops_t *ops = &tmpfs_libfs_ops; |
| int rc; |
| do { |
| char *fname; |
| tmpfs_dentry_t *node; |
| uint32_t size; |
| if (block_read(dev, bufpos, buflen, pos, &entry, sizeof(entry), |
| TMPFS_BLOCK_SIZE) != EOK) |
| return false; |
| entry.len = uint32_t_le2host(entry.len); |
| switch (entry.type) { |
| case TMPFS_NONE: |
| break; |
| case TMPFS_FILE: |
| fname = malloc(entry.len + 1); |
| if (fname == NULL) |
| return false; |
| node = (tmpfs_dentry_t *) ops->create(dev, L_FILE); |
| if (node == NULL) { |
| free(fname); |
| return false; |
| } |
| if (block_read(dev, bufpos, buflen, pos, fname, |
| entry.len, TMPFS_BLOCK_SIZE) != EOK) { |
| ops->destroy((void *) node); |
| free(fname); |
| return false; |
| } |
| fname[entry.len] = 0; |
| rc = ops->link((void *) parent, (void *) node, fname); |
| if (rc != EOK) { |
| ops->destroy((void *) node); |
| free(fname); |
| return false; |
| } |
| free(fname); |
| if (block_read(dev, bufpos, buflen, pos, &size, |
| sizeof(size), TMPFS_BLOCK_SIZE) != EOK) |
| return false; |
| size = uint32_t_le2host(size); |
| node->data = malloc(size); |
| if (node->data == NULL) |
| return false; |
| node->size = size; |
| if (block_read(dev, bufpos, buflen, pos, node->data, |
| size, TMPFS_BLOCK_SIZE) != EOK) |
| return false; |
| break; |
| case TMPFS_DIRECTORY: |
| fname = malloc(entry.len + 1); |
| if (fname == NULL) |
| return false; |
| node = (tmpfs_dentry_t *) ops->create(dev, L_DIRECTORY); |
| if (node == NULL) { |
| free(fname); |
| return false; |
| } |
| if (block_read(dev, bufpos, buflen, pos, fname, |
| entry.len, TMPFS_BLOCK_SIZE) != EOK) { |
| ops->destroy((void *) node); |
| free(fname); |
| return false; |
| } |
| fname[entry.len] = 0; |
| rc = ops->link((void *) parent, (void *) node, fname); |
| if (rc != EOK) { |
| ops->destroy((void *) node); |
| free(fname); |
| return false; |
| } |
| free(fname); |
| if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos, |
| node)) |
| return false; |
| break; |
| default: |
| return false; |
| } |
| } while (entry.type != TMPFS_NONE); |
| return true; |
| } |
| bool tmpfs_restore(dev_handle_t dev) |
| { |
| libfs_ops_t *ops = &tmpfs_libfs_ops; |
| int rc; |
| rc = block_init(dev, TMPFS_BLOCK_SIZE); |
| if (rc != EOK) |
| return false; |
| off_t bufpos = 0; |
| size_t buflen = 0; |
| off_t pos = 0; |
| char tag[6]; |
| if (block_read(dev, &bufpos, &buflen, &pos, tag, 5, |
| TMPFS_BLOCK_SIZE) != EOK) |
| goto error; |
| tag[5] = 0; |
| if (strcmp(tag, "TMPFS") != 0) |
| goto error; |
| if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos, |
| ops->root_get(dev))) |
| goto error; |
| block_fini(dev); |
| return true; |
| error: |
| block_fini(dev); |
| return false; |
| } |
| /** |
| * @} |
| */ |
| /branches/dd/uspace/srv/fs/tmpfs/tmpfs.c |
|---|
| 50,18 → 50,11 |
| #include <libfs.h> |
| #include "../../vfs/vfs.h" |
| #define NAME "tmpfs" |
| vfs_info_t tmpfs_vfs_info = { |
| .name = "tmpfs", |
| .ops = { |
| [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED, |
| [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED, |
| [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_DEFINED, |
| [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_DEFINED, |
| [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_DEFINED, |
| [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL, |
| [IPC_METHOD_TO_VFS_OP(VFS_DESTROY)] = VFS_OP_DEFINED, |
| } |
| }; |
| fs_reg_t tmpfs_reg; |
| 103,6 → 96,9 |
| callid = async_get_call(&call); |
| switch (IPC_GET_METHOD(call)) { |
| case VFS_MOUNTED: |
| tmpfs_mounted(callid, &call); |
| break; |
| case VFS_MOUNT: |
| tmpfs_mount(callid, &call); |
| break; |
| 130,27 → 126,22 |
| int main(int argc, char **argv) |
| { |
| int vfs_phone; |
| printf("TMPFS: HelenOS TMPFS file system server.\n"); |
| vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0); |
| while (vfs_phone < EOK) { |
| usleep(10000); |
| vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0); |
| printf(NAME ": HelenOS TMPFS file system server\n"); |
| int vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0); |
| if (vfs_phone < EOK) { |
| printf(NAME ": Unable to connect to VFS\n"); |
| return -1; |
| } |
| int rc; |
| rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info, |
| int rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info, |
| tmpfs_connection); |
| if (rc != EOK) { |
| printf("Failed to register the TMPFS file system (%d)\n", rc); |
| printf(NAME ": Failed to register file system (%d)\n", rc); |
| return rc; |
| } |
| dprintf("TMPFS filesystem registered, fs_handle=%d.\n", |
| tmpfs_reg.fs_handle); |
| printf(NAME ": Accepting connections\n"); |
| async_manager(); |
| /* not reached */ |
| return 0; |
| /branches/dd/uspace/srv/fs/tmpfs/tmpfs_ops.c |
|---|
| 64,6 → 64,8 |
| */ |
| static tmpfs_dentry_t *root; |
| #define TMPFS_DEV 0 /**< Dummy device handle for TMPFS */ |
| /* |
| * Implementation of the libfs interface. |
| */ |
| 72,8 → 74,8 |
| static void *tmpfs_match(void *, const char *); |
| static void *tmpfs_node_get(dev_handle_t, fs_index_t); |
| static void tmpfs_node_put(void *); |
| static void *tmpfs_create_node(int); |
| static bool tmpfs_link_node(void *, void *, const char *); |
| static void *tmpfs_create_node(dev_handle_t, int); |
| static int tmpfs_link_node(void *, void *, const char *); |
| static int tmpfs_unlink_node(void *, void *); |
| static int tmpfs_destroy_node(void *); |
| 228,12 → 230,12 |
| { |
| if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops)) |
| return false; |
| root = (tmpfs_dentry_t *) tmpfs_create_node(L_DIRECTORY); |
| root = (tmpfs_dentry_t *) tmpfs_create_node(TMPFS_DEV, L_DIRECTORY); |
| if (!root) { |
| hash_table_destroy(&dentries); |
| return false; |
| } |
| root->lnkcnt = 1; |
| root->lnkcnt = 0; /* FS root is not linked */ |
| return true; |
| } |
| 282,7 → 284,7 |
| /* nothing to do */ |
| } |
| void *tmpfs_create_node(int lflag) |
| void *tmpfs_create_node(dev_handle_t dev_handle, int lflag) |
| { |
| assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); |
| 306,7 → 308,7 |
| return (void *) node; |
| } |
| bool tmpfs_link_node(void *prnt, void *chld, const char *nm) |
| int tmpfs_link_node(void *prnt, void *chld, const char *nm) |
| { |
| tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt; |
| tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld; |
| 315,13 → 317,13 |
| tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t)); |
| if (!namep) |
| return false; |
| return ENOMEM; |
| tmpfs_name_initialize(namep); |
| size_t len = strlen(nm); |
| namep->name = malloc(len + 1); |
| if (!namep->name) { |
| free(namep); |
| return false; |
| return ENOMEM; |
| } |
| strcpy(namep->name, nm); |
| namep->parent = parentp; |
| 341,7 → 343,7 |
| parentp->child = childp; |
| } |
| return true; |
| return EOK; |
| } |
| int tmpfs_unlink_node(void *prnt, void *chld) |
| 393,28 → 395,39 |
| return EOK; |
| } |
| void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request) |
| void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request) |
| { |
| dev_handle_t mr_dev_handle = (dev_handle_t)IPC_GET_ARG1(*request); |
| fs_index_t mr_index = (fs_index_t)IPC_GET_ARG2(*request); |
| fs_handle_t mp_fs_handle = (fs_handle_t)IPC_GET_ARG3(*request); |
| dev_handle_t mp_dev_handle = (dev_handle_t)IPC_GET_ARG4(*request); |
| fs_index_t mp_index = (fs_index_t)IPC_GET_ARG5(*request); |
| if ((mr_index == root->index) && |
| (mp_fs_handle == tmpfs_reg.fs_handle) && |
| (mp_index == mr_index)) |
| ipc_answer_0(rid, EOK); |
| else |
| ipc_answer_0(rid, ENOTSUP); |
| } |
| dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); |
| void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request) |
| { |
| /* Initialize TMPFS. */ |
| if (!root && !tmpfs_init()) { |
| ipc_answer_0(rid, ENOMEM); |
| return; |
| } |
| if (dev_handle >= 0) { |
| if (tmpfs_restore(dev_handle)) |
| ipc_answer_3(rid, EOK, root->index, root->size, |
| root->lnkcnt); |
| else |
| ipc_answer_0(rid, ELIMIT); |
| } else { |
| ipc_answer_3(rid, EOK, root->index, root->size, root->lnkcnt); |
| } |
| } |
| void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request) |
| { |
| dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); |
| fs_index_t mp_index = (fs_index_t) IPC_GET_ARG2(*request); |
| fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request); |
| dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request); |
| ipc_answer_0(rid, ENOTSUP); |
| } |
| void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request) |
| { |
| libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request); |
| } |
| /branches/dd/uspace/srv/fs/tmpfs/Makefile |
|---|
| 31,12 → 31,17 |
| LIBC_PREFIX = ../../../lib/libc |
| LIBFS_PREFIX = ../../../lib/libfs |
| LIBBLOCK_PREFIX = ../../../lib/libblock |
| SOFTINT_PREFIX = ../../../lib/softint |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| CFLAGS += -I $(LIBFS_PREFIX) |
| CFLAGS += -I $(LIBFS_PREFIX) -I $(LIBBLOCK_PREFIX) |
| LIBS = $(LIBC_PREFIX)/libc.a $(LIBFS_PREFIX)/libfs.a |
| LIBS = \ |
| $(LIBFS_PREFIX)/libfs.a \ |
| $(LIBBLOCK_PREFIX)/libblock.a \ |
| $(LIBC_PREFIX)/libc.a |
| ## Sources |
| # |
| 44,28 → 49,31 |
| OUTPUT = tmpfs |
| SOURCES = \ |
| tmpfs.c \ |
| tmpfs_ops.c |
| tmpfs_ops.c \ |
| tmpfs_dump.c |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| .PHONY: all clean depend disasm |
| all: $(OUTPUT) disasm |
| all: $(OUTPUT) $(OUTPUT).disasm |
| -include Makefile.depend |
| clean: |
| -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend |
| -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS) |
| depend: |
| $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend |
| $(OUTPUT): $(OBJECTS) $(LIBS) |
| $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map |
| $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map |
| disasm: |
| $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm |
| disasm: $(OUTPUT).disasm |
| $(OUTPUT).disasm: $(OUTPUT) |
| $(OBJDUMP) -d $< >$@ |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |