WebSVN – HelenOS – Diff – /trunk/uspace/srv/fs/tmpfs/tmpfs_ops.c


/*
 * Copyright (c) 2008 Jakub Jermar
 * 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_ops.c
 * @brief   Implementation of VFS operations for the TMPFS file system
 *      server.
 */
 
#include "tmpfs.h"
#include "../../vfs/vfs.h"
#include <ipc/ipc.h>
#include <async.h>
#include <errno.h>
#include <atomic.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <sys/types.h>
#include <libadt/hash_table.h>
#include <as.h>
#include <libfs.h>
 
#define min(a, b)       ((a) < (b) ? (a) : (b))
#define max(a, b)       ((a) > (b) ? (a) : (b))
 
#define DENTRIES_BUCKETS    256
 
#define NAMES_BUCKETS       4
 
/** All root nodes have index 0. */
#define TMPFS_SOME_ROOT     0
/** Global counter for assigning node indices. Shared by all instances. */
fs_index_t tmpfs_next_index = 1;
 
/*
 * Implementation of the libfs interface.
 */
 
/* Forward declarations of static functions. */
static fs_node_t *tmpfs_match(fs_node_t *, const char *);
static fs_node_t *tmpfs_node_get(dev_handle_t, fs_index_t);
static void tmpfs_node_put(fs_node_t *);
static fs_node_t *tmpfs_create_node(dev_handle_t, int);
static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
static int tmpfs_unlink_node(fs_node_t *, fs_node_t *);
static int tmpfs_destroy_node(fs_node_t *);
 
/* Implementation of helper functions. */
static fs_index_t tmpfs_index_get(fs_node_t *fn)
{
    return TMPFS_NODE(fn)->index;
}
 
static size_t tmpfs_size_get(fs_node_t *fn)
{
    return TMPFS_NODE(fn)->size;
}
 
static unsigned tmpfs_lnkcnt_get(fs_node_t *fn)
{
    return TMPFS_NODE(fn)->lnkcnt;
}
 
static bool tmpfs_has_children(fs_node_t *fn)
{
    return TMPFS_NODE(fn)->child != NULL;
}
 
static fs_node_t *tmpfs_root_get(dev_handle_t dev_handle)
{
    return tmpfs_node_get(dev_handle, TMPFS_SOME_ROOT);
}
 
static char tmpfs_plb_get_char(unsigned pos)
{
    return tmpfs_reg.plb_ro[pos % PLB_SIZE];
}
 
static bool tmpfs_is_directory(fs_node_t *fn)
{
    return TMPFS_NODE(fn)->type == TMPFS_DIRECTORY;
}
 
static bool tmpfs_is_file(fs_node_t *fn)
{
    return TMPFS_NODE(fn)->type == TMPFS_FILE;
}
 
/** libfs operations */
libfs_ops_t tmpfs_libfs_ops = {
    .match = tmpfs_match,
    .node_get = tmpfs_node_get,
    .node_put = tmpfs_node_put,
    .create = tmpfs_create_node,
    .destroy = tmpfs_destroy_node,
    .link = tmpfs_link_node,
    .unlink = tmpfs_unlink_node,
    .index_get = tmpfs_index_get,
    .size_get = tmpfs_size_get,
    .lnkcnt_get = tmpfs_lnkcnt_get,
    .has_children = tmpfs_has_children,
    .root_get = tmpfs_root_get,
    .plb_get_char = tmpfs_plb_get_char,
    .is_directory = tmpfs_is_directory,
    .is_file = tmpfs_is_file
};
 
/** Hash table of all directory entries. */
hash_table_t dentries;
 
#define DENTRIES_KEY_INDEX  0
#define DENTRIES_KEY_DEV    1
 
/* Implementation of hash table interface for the dentries hash table. */
static hash_index_t dentries_hash(unsigned long key[])
{
    return key[DENTRIES_KEY_INDEX] % DENTRIES_BUCKETS;
}
 
static int dentries_compare(unsigned long key[], hash_count_t keys,
    link_t *item)
{
    tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
        dh_link);
    return (dentry->index == key[DENTRIES_KEY_INDEX] &&
        dentry->dev_handle == key[DENTRIES_KEY_DEV]);
}
 
static void dentries_remove_callback(link_t *item)
{
}
 
/** TMPFS dentries hash table operations. */
hash_table_operations_t dentries_ops = {
    .hash = dentries_hash,
    .compare = dentries_compare,
    .remove_callback = dentries_remove_callback
};
 
typedef struct {
    char *name;
    tmpfs_dentry_t *parent;
    link_t link;
} tmpfs_name_t;
 
/* Implementation of hash table interface for the names hash table. */
static hash_index_t names_hash(unsigned long *key)
{
    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) *key;
    return dentry->index % NAMES_BUCKETS;
}
 
static int names_compare(unsigned long *key, hash_count_t keys, link_t *item)
{
    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) *key;
    tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
        link);
    return dentry == namep->parent;
}
 
static void names_remove_callback(link_t *item)
{
    tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
        link);
    free(namep->name);
    free(namep);
}
 
/** TMPFS node names hash table operations. */
static hash_table_operations_t names_ops = {
    .hash = names_hash,
    .compare = names_compare,
    .remove_callback = names_remove_callback
};
 
static void tmpfs_name_initialize(tmpfs_name_t *namep)
{
    namep->name = NULL;
    namep->parent = NULL;
    link_initialize(&namep->link);
}
 
static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
{
    dentry->bp = NULL;
    dentry->index = 0;
    dentry->dev_handle = 0;
    dentry->sibling = NULL;
    dentry->child = NULL;
    dentry->type = TMPFS_NONE;
    dentry->lnkcnt = 0;
    dentry->size = 0;
    dentry->data = NULL;
    link_initialize(&dentry->dh_link);
    return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,
        &names_ops);
}
 
bool tmpfs_init(void)
{
    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 2, &dentries_ops))
        return false;
   
    return true;
}
 
static bool tmpfs_instance_init(dev_handle_t dev_handle)
{
    fs_node_t *rfn;
   
    rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
    if (!rfn)
        return false;
    TMPFS_NODE(rfn)->lnkcnt = 0;    /* FS root is not linked */
    return true;
}
 
/** Compare one component of path to a directory entry.
 *
 * @param parentp   Pointer to node from which we descended.
 * @param childp    Pointer to node to compare the path component with.
 * @param component Array of characters holding component name.
 *
 * @return      True on match, false otherwise.
 */
static bool
tmpfs_match_one(tmpfs_dentry_t *parentp, tmpfs_dentry_t *childp,
    const char *component)
{
    unsigned long key = (unsigned long) parentp;
    link_t *hlp = hash_table_find(&childp->names, &key);
    assert(hlp);
    tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);
    return !str_cmp(namep->name, component);
}
 
fs_node_t *tmpfs_match(fs_node_t *pfn, const char *component)
{
    tmpfs_dentry_t *parentp = TMPFS_NODE(pfn);
    tmpfs_dentry_t *childp = parentp->child;
 
    while (childp && !tmpfs_match_one(parentp, childp, component))
        childp = childp->sibling;
 
    return FS_NODE(childp);
}
 
 
fs_node_t *tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
{
    unsigned long key[] = {
        [DENTRIES_KEY_INDEX] = index,
        [DENTRIES_KEY_DEV] = dev_handle
    };
    link_t *lnk = hash_table_find(&dentries, key);
    if (!lnk)
        return NULL;
    return FS_NODE(hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link));
}
 
void tmpfs_node_put(fs_node_t *fn)
{
    /* nothing to do */
}
 
fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
{
    assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
 
    fs_node_t *fn = malloc(sizeof(fs_node_t));
    if (!fn)
        return NULL;
   
    tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
    if (!node) {
        free(fn);
        return NULL;
    }
    if (!tmpfs_dentry_initialize(node)) {
        free(fn);
        free(node);
        return NULL;
    }
    fn->data = node;
    node->bp = fn;  /* establish the back pointer */
    if (!tmpfs_root_get(dev_handle))
        node->index = TMPFS_SOME_ROOT;
    else
        node->index = tmpfs_next_index++;
    node->dev_handle = dev_handle;
    if (lflag & L_DIRECTORY)
        node->type = TMPFS_DIRECTORY;
    else
        node->type = TMPFS_FILE;
 
    /* Insert the new node into the dentry hash table. */
    unsigned long key[] = {
        [DENTRIES_KEY_INDEX] = node->index,
        [DENTRIES_KEY_DEV] = node->dev_handle
    };
    hash_table_insert(&dentries, key, &node->dh_link);
    return fn;
}
 
int tmpfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
{
    tmpfs_dentry_t *parentp = TMPFS_NODE(pfn);
    tmpfs_dentry_t *childp = TMPFS_NODE(cfn);
 
    assert(parentp->type == TMPFS_DIRECTORY);
 
    tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
    if (!namep)
        return ENOMEM;
    tmpfs_name_initialize(namep);
    size_t size = str_size(nm);
    namep->name = malloc(size + 1);
    if (!namep->name) {
        free(namep);
        return ENOMEM;
    }
    str_cpy(namep->name, size + 1, nm);
    namep->parent = parentp;
   
    childp->lnkcnt++;
 
    unsigned long key = (unsigned long) parentp;
    hash_table_insert(&childp->names, &key, &namep->link);
 
    /* Insert the new node into the namespace. */
    if (parentp->child) {
        tmpfs_dentry_t *tmp = parentp->child;
        while (tmp->sibling)
            tmp = tmp->sibling;
        tmp->sibling = childp;
    } else {
        parentp->child = childp;
    }
 
    return EOK;
}
 
int tmpfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn)
{
    tmpfs_dentry_t *parentp = TMPFS_NODE(pfn);
    tmpfs_dentry_t *childp = TMPFS_NODE(cfn);
 
    if (!parentp)
        return EBUSY;
 
    if (childp->child)
        return ENOTEMPTY;
 
    if (parentp->child == childp) {
        parentp->child = childp->sibling;
    } else {
        /* TODO: consider doubly linked list for organizing siblings. */
        tmpfs_dentry_t *tmp = parentp->child;
        while (tmp->sibling != childp)
            tmp = tmp->sibling;
        tmp->sibling = childp->sibling;
    }
    childp->sibling = NULL;
 
    unsigned long key = (unsigned long) parentp;
    hash_table_remove(&childp->names, &key, 1);
 
    childp->lnkcnt--;
 
    return EOK;
}
 
int tmpfs_destroy_node(fs_node_t *fn)
{
    tmpfs_dentry_t *dentry = TMPFS_NODE(fn);
   
    assert(!dentry->lnkcnt);
    assert(!dentry->child);
    assert(!dentry->sibling);
 
    unsigned long key[] = {
        [DENTRIES_KEY_INDEX] = dentry->index,
        [DENTRIES_KEY_DEV] = dentry->dev_handle
    };
    hash_table_remove(&dentries, key, 2);
 
    hash_table_destroy(&dentry->names);
 
    if (dentry->type == TMPFS_FILE)
        free(dentry->data);
    free(dentry->bp);
    free(dentry);
    return EOK;
}
 
void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
 
    /* accept the mount options */
    ipc_callid_t callid;
    size_t size;
    if (!ipc_data_write_receive(&callid, &size)) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
    char *opts = malloc(size + 1);
    if (!opts) {
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
    ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
    if (retval != EOK) {
        ipc_answer_0(rid, retval);
        free(opts);
        return;
    }
    opts[size] = '\0';
 
    /* Initialize TMPFS instance. */
    if (!tmpfs_instance_init(dev_handle)) {
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    tmpfs_dentry_t *root = TMPFS_NODE(tmpfs_root_get(dev_handle));
    if (str_cmp(opts, "restore") == 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);
}
 
void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    off_t pos = (off_t)IPC_GET_ARG3(*request);
 
    /*
     * Lookup the respective dentry.
     */
    link_t *hlp;
    unsigned long key[] = {
        [DENTRIES_KEY_INDEX] = index,
        [DENTRIES_KEY_DEV] = dev_handle,
    };
    hlp = hash_table_find(&dentries, key);
    if (!hlp) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
        dh_link);
 
    /*
     * Receive the read request.
     */
    ipc_callid_t callid;
    size_t size;
    if (!ipc_data_read_receive(&callid, &size)) {
        ipc_answer_0(callid, EINVAL);  
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    size_t bytes;
    if (dentry->type == TMPFS_FILE) {
        bytes = max(0, min(dentry->size - pos, size));
        (void) ipc_data_read_finalize(callid, dentry->data + pos,
            bytes);
    } else {
        int i;
        tmpfs_dentry_t *cur;
       
        assert(dentry->type == TMPFS_DIRECTORY);
       
        /*
         * Yes, we really use O(n) algorithm here.
         * If it bothers someone, it could be fixed by introducing a
         * hash table.
         */
        for (i = 0, cur = dentry->child; i < pos && cur; i++,
            cur = cur->sibling)
            ;
 
        if (!cur) {
            ipc_answer_0(callid, ENOENT);
            ipc_answer_1(rid, ENOENT, 0);
            return;
        }
 
        unsigned long key = (unsigned long) dentry;
        link_t *hlp = hash_table_find(&cur->names, &key);
        assert(hlp);
        tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t,
            link);
 
        (void) ipc_data_read_finalize(callid, namep->name,
            str_size(namep->name) + 1);
        bytes = 1;
    }
 
    /*
     * Answer the VFS_READ call.
     */
    ipc_answer_1(rid, EOK, bytes);
}
 
void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    off_t pos = (off_t)IPC_GET_ARG3(*request);
 
    /*
     * Lookup the respective dentry.
     */
    link_t *hlp;
    unsigned long key[] = {
        [DENTRIES_KEY_INDEX] = index,
        [DENTRIES_KEY_DEV] = dev_handle
    };
    hlp = hash_table_find(&dentries, key);
    if (!hlp) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
        dh_link);
 
    /*
     * Receive the write request.
     */
    ipc_callid_t callid;
    size_t size;
    if (!ipc_data_write_receive(&callid, &size)) {
        ipc_answer_0(callid, EINVAL);  
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Check whether the file needs to grow.
     */
    if (pos + size <= dentry->size) {
        /* The file size is not changing. */
        (void) ipc_data_write_finalize(callid, dentry->data + pos, size);
        ipc_answer_2(rid, EOK, size, dentry->size);
        return;
    }
    size_t delta = (pos + size) - dentry->size;
    /*
     * At this point, we are deliberately extremely straightforward and
     * simply realloc the contents of the file on every write that grows the
     * file. In the end, the situation might not be as bad as it may look:
     * our heap allocator can save us and just grow the block whenever
     * possible.
     */
    void *newdata = realloc(dentry->data, dentry->size + delta);
    if (!newdata) {
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_2(rid, EOK, 0, dentry->size);
        return;
    }
    /* Clear any newly allocated memory in order to emulate gaps. */
    memset(newdata + dentry->size, 0, delta);
    dentry->size += delta;
    dentry->data = newdata;
    (void) ipc_data_write_finalize(callid, dentry->data + pos, size);
    ipc_answer_2(rid, EOK, size, dentry->size);
}
 
void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    size_t size = (off_t)IPC_GET_ARG3(*request);
 
    /*
     * Lookup the respective dentry.
     */
    link_t *hlp;
    unsigned long key[] = {
        [DENTRIES_KEY_INDEX] = index,
        [DENTRIES_KEY_DEV] = dev_handle
    };
    hlp = hash_table_find(&dentries, key);
    if (!hlp) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
        dh_link);
 
    if (size == dentry->size) {
        ipc_answer_0(rid, EOK);
        return;
    }
 
    void *newdata = realloc(dentry->data, size);
    if (!newdata) {
        ipc_answer_0(rid, ENOMEM);
        return;
    }
    if (size > dentry->size) {
        size_t delta = size - dentry->size;
        memset(newdata + dentry->size, 0, delta);
    }
    dentry->size = size;
    dentry->data = newdata;
    ipc_answer_0(rid, EOK);
}
 
void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    int rc;
 
    link_t *hlp;
    unsigned long key[] = {
        [DENTRIES_KEY_INDEX] = index,
        [DENTRIES_KEY_DEV] = dev_handle
    };
    hlp = hash_table_find(&dentries, key);
    if (!hlp) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
        dh_link);
    rc = tmpfs_destroy_node(FS_NODE(dentry));
    ipc_answer_0(rid, rc);
}
 
/**
 * @}
 */
 

Rev 4306	Rev 4357
1	/*	1	/*
2	* Copyright (c) 2008 Jakub Jermar	2	* Copyright (c) 2008 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup fs	29	/** @addtogroup fs
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file tmpfs_ops.c	34	* @file tmpfs_ops.c
35	* @brief Implementation of VFS operations for the TMPFS file system	35	* @brief Implementation of VFS operations for the TMPFS file system
36	* server.	36	* server.
37	*/	37	*/
38		38
39	#include "tmpfs.h"	39	#include "tmpfs.h"
40	#include "../../vfs/vfs.h"	40	#include "../../vfs/vfs.h"
41	#include <ipc/ipc.h>	41	#include <ipc/ipc.h>
42	#include <async.h>	42	#include <async.h>
43	#include <errno.h>	43	#include <errno.h>
44	#include <atomic.h>	44	#include <atomic.h>
45	#include <stdlib.h>	45	#include <stdlib.h>
46	#include <string.h>	46	#include <string.h>
47	#include <stdio.h>	47	#include <stdio.h>
48	#include <assert.h>	48	#include <assert.h>
49	#include <sys/types.h>	49	#include <sys/types.h>
50	#include <libadt/hash_table.h>	50	#include <libadt/hash_table.h>
51	#include <as.h>	51	#include <as.h>
52	#include <libfs.h>	52	#include <libfs.h>
53		53
54	#define min(a, b) ((a) < (b) ? (a) : (b))	54	#define min(a, b) ((a) < (b) ? (a) : (b))
55	#define max(a, b) ((a) > (b) ? (a) : (b))	55	#define max(a, b) ((a) > (b) ? (a) : (b))
56		56
57	#define DENTRIES_BUCKETS 256	57	#define DENTRIES_BUCKETS 256
58		58
59	#define NAMES_BUCKETS 4	59	#define NAMES_BUCKETS 4
60		60
61	/** All root nodes have index 0. */	61	/** All root nodes have index 0. */
62	#define TMPFS_SOME_ROOT 0	62	#define TMPFS_SOME_ROOT 0
63	/** Global counter for assigning node indices. Shared by all instances. */	63	/** Global counter for assigning node indices. Shared by all instances. */
64	fs_index_t tmpfs_next_index = 1;	64	fs_index_t tmpfs_next_index = 1;
65		65
66	/*	66	/*
67	* Implementation of the libfs interface.	67	* Implementation of the libfs interface.
68	*/	68	*/
69		69
70	/* Forward declarations of static functions. */	70	/* Forward declarations of static functions. */
71	static void tmpfs_match(void , const char *);	71	static fs_node_t tmpfs_match(fs_node_t , const char *);
72	static void *tmpfs_node_get(dev_handle_t, fs_index_t);	72	static fs_node_t *tmpfs_node_get(dev_handle_t, fs_index_t);
73	static void tmpfs_node_put(void *);	73	static void tmpfs_node_put(fs_node_t *);
74	static void *tmpfs_create_node(dev_handle_t, int);	74	static fs_node_t *tmpfs_create_node(dev_handle_t, int);
75	static int tmpfs_link_node(void , void , const char *);	75	static int tmpfs_link_node(fs_node_t , fs_node_t , const char *);
76	static int tmpfs_unlink_node(void , void );	76	static int tmpfs_unlink_node(fs_node_t , fs_node_t );
77	static int tmpfs_destroy_node(void *);	77	static int tmpfs_destroy_node(fs_node_t *);
78		78
79	/* Implementation of helper functions. */	79	/* Implementation of helper functions. */
80	static fs_index_t tmpfs_index_get(void *nodep)	80	static fs_index_t tmpfs_index_get(fs_node_t *fn)
81	{	81	{
82	return ((tmpfs_dentry_t *) nodep)->index;	82	return TMPFS_NODE(fn)->index;
83	}	83	}
84		84
85	static size_t tmpfs_size_get(void *nodep)	85	static size_t tmpfs_size_get(fs_node_t *fn)
86	{	86	{
87	return ((tmpfs_dentry_t *) nodep)->size;	87	return TMPFS_NODE(fn)->size;
88	}	88	}
89		89
90	static unsigned tmpfs_lnkcnt_get(void *nodep)	90	static unsigned tmpfs_lnkcnt_get(fs_node_t *fn)
91	{	91	{
92	return ((tmpfs_dentry_t *) nodep)->lnkcnt;	92	return TMPFS_NODE(fn)->lnkcnt;
93	}	93	}
94		94
95	static bool tmpfs_has_children(void *nodep)	95	static bool tmpfs_has_children(fs_node_t *fn)
96	{	96	{
97	return ((tmpfs_dentry_t *) nodep)->child != NULL;	97	return TMPFS_NODE(fn)->child != NULL;
98	}	98	}
99		99
100	static void *tmpfs_root_get(dev_handle_t dev_handle)	100	static fs_node_t *tmpfs_root_get(dev_handle_t dev_handle)
101	{	101	{
102	return tmpfs_node_get(dev_handle, TMPFS_SOME_ROOT);	102	return tmpfs_node_get(dev_handle, TMPFS_SOME_ROOT);
103	}	103	}
104		104
105	static char tmpfs_plb_get_char(unsigned pos)	105	static char tmpfs_plb_get_char(unsigned pos)
106	{	106	{
107	return tmpfs_reg.plb_ro[pos % PLB_SIZE];	107	return tmpfs_reg.plb_ro[pos % PLB_SIZE];
108	}	108	}
109		109
110	static bool tmpfs_is_directory(void *nodep)	110	static bool tmpfs_is_directory(fs_node_t *fn)
111	{	111	{
112	return ((tmpfs_dentry_t *) nodep)->type == TMPFS_DIRECTORY;	112	return TMPFS_NODE(fn)->type == TMPFS_DIRECTORY;
113	}	113	}
114		114
115	static bool tmpfs_is_file(void *nodep)	115	static bool tmpfs_is_file(fs_node_t *fn)
116	{	116	{
117	return ((tmpfs_dentry_t *) nodep)->type == TMPFS_FILE;	117	return TMPFS_NODE(fn)->type == TMPFS_FILE;
118	}	118	}
119		119
120	/** libfs operations */	120	/** libfs operations */
121	libfs_ops_t tmpfs_libfs_ops = {	121	libfs_ops_t tmpfs_libfs_ops = {
122	.match = tmpfs_match,	122	.match = tmpfs_match,
123	.node_get = tmpfs_node_get,	123	.node_get = tmpfs_node_get,
124	.node_put = tmpfs_node_put,	124	.node_put = tmpfs_node_put,
125	.create = tmpfs_create_node,	125	.create = tmpfs_create_node,
126	.destroy = tmpfs_destroy_node,	126	.destroy = tmpfs_destroy_node,
127	.link = tmpfs_link_node,	127	.link = tmpfs_link_node,
128	.unlink = tmpfs_unlink_node,	128	.unlink = tmpfs_unlink_node,
129	.index_get = tmpfs_index_get,	129	.index_get = tmpfs_index_get,
130	.size_get = tmpfs_size_get,	130	.size_get = tmpfs_size_get,
131	.lnkcnt_get = tmpfs_lnkcnt_get,	131	.lnkcnt_get = tmpfs_lnkcnt_get,
132	.has_children = tmpfs_has_children,	132	.has_children = tmpfs_has_children,
133	.root_get = tmpfs_root_get,	133	.root_get = tmpfs_root_get,
134	.plb_get_char = tmpfs_plb_get_char,	134	.plb_get_char = tmpfs_plb_get_char,
135	.is_directory = tmpfs_is_directory,	135	.is_directory = tmpfs_is_directory,
136	.is_file = tmpfs_is_file	136	.is_file = tmpfs_is_file
137	};	137	};
138		138
139	/** Hash table of all directory entries. */	139	/** Hash table of all directory entries. */
140	hash_table_t dentries;	140	hash_table_t dentries;
141		141
142	#define DENTRIES_KEY_INDEX 0	142	#define DENTRIES_KEY_INDEX 0
143	#define DENTRIES_KEY_DEV 1	143	#define DENTRIES_KEY_DEV 1
144		144
145	/* Implementation of hash table interface for the dentries hash table. */	145	/* Implementation of hash table interface for the dentries hash table. */
146	static hash_index_t dentries_hash(unsigned long key[])	146	static hash_index_t dentries_hash(unsigned long key[])
147	{	147	{
148	return key[DENTRIES_KEY_INDEX] % DENTRIES_BUCKETS;	148	return key[DENTRIES_KEY_INDEX] % DENTRIES_BUCKETS;
149	}	149	}
150		150
151	static int dentries_compare(unsigned long key[], hash_count_t keys,	151	static int dentries_compare(unsigned long key[], hash_count_t keys,
152	link_t *item)	152	link_t *item)
153	{	153	{
154	tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,	154	tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
155	dh_link);	155	dh_link);
156	return (dentry->index == key[DENTRIES_KEY_INDEX] &&	156	return (dentry->index == key[DENTRIES_KEY_INDEX] &&
157	dentry->dev_handle == key[DENTRIES_KEY_DEV]);	157	dentry->dev_handle == key[DENTRIES_KEY_DEV]);
158	}	158	}
159		159
160	static void dentries_remove_callback(link_t *item)	160	static void dentries_remove_callback(link_t *item)
161	{	161	{
162	}	162	}
163		163
164	/** TMPFS dentries hash table operations. */	164	/** TMPFS dentries hash table operations. */
165	hash_table_operations_t dentries_ops = {	165	hash_table_operations_t dentries_ops = {
166	.hash = dentries_hash,	166	.hash = dentries_hash,
167	.compare = dentries_compare,	167	.compare = dentries_compare,
168	.remove_callback = dentries_remove_callback	168	.remove_callback = dentries_remove_callback
169	};	169	};
170		170
171	typedef struct {	171	typedef struct {
172	char *name;	172	char *name;
173	tmpfs_dentry_t *parent;	173	tmpfs_dentry_t *parent;
174	link_t link;	174	link_t link;
175	} tmpfs_name_t;	175	} tmpfs_name_t;
176		176
177	/* Implementation of hash table interface for the names hash table. */	177	/* Implementation of hash table interface for the names hash table. */
178	static hash_index_t names_hash(unsigned long *key)	178	static hash_index_t names_hash(unsigned long *key)
179	{	179	{
180	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) *key;	180	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) *key;
181	return dentry->index % NAMES_BUCKETS;	181	return dentry->index % NAMES_BUCKETS;
182	}	182	}
183		183
184	static int names_compare(unsigned long key, hash_count_t keys, link_t item)	184	static int names_compare(unsigned long key, hash_count_t keys, link_t item)
185	{	185	{
186	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) *key;	186	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) *key;
187	tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,	187	tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
188	link);	188	link);
189	return dentry == namep->parent;	189	return dentry == namep->parent;
190	}	190	}
191		191
192	static void names_remove_callback(link_t *item)	192	static void names_remove_callback(link_t *item)
193	{	193	{
194	tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,	194	tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
195	link);	195	link);
196	free(namep->name);	196	free(namep->name);
197	free(namep);	197	free(namep);
198	}	198	}
199		199
200	/** TMPFS node names hash table operations. */	200	/** TMPFS node names hash table operations. */
201	static hash_table_operations_t names_ops = {	201	static hash_table_operations_t names_ops = {
202	.hash = names_hash,	202	.hash = names_hash,
203	.compare = names_compare,	203	.compare = names_compare,
204	.remove_callback = names_remove_callback	204	.remove_callback = names_remove_callback
205	};	205	};
206		206
207	static void tmpfs_name_initialize(tmpfs_name_t *namep)	207	static void tmpfs_name_initialize(tmpfs_name_t *namep)
208	{	208	{
209	namep->name = NULL;	209	namep->name = NULL;
210	namep->parent = NULL;	210	namep->parent = NULL;
211	link_initialize(&namep->link);	211	link_initialize(&namep->link);
212	}	212	}
213		213
214	static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)	214	static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
215	{	215	{
-		216	dentry->bp = NULL;
216	dentry->index = 0;	217	dentry->index = 0;
217	dentry->dev_handle = 0;	218	dentry->dev_handle = 0;
218	dentry->sibling = NULL;	219	dentry->sibling = NULL;
219	dentry->child = NULL;	220	dentry->child = NULL;
220	dentry->type = TMPFS_NONE;	221	dentry->type = TMPFS_NONE;
221	dentry->lnkcnt = 0;	222	dentry->lnkcnt = 0;
222	dentry->size = 0;	223	dentry->size = 0;
223	dentry->data = NULL;	224	dentry->data = NULL;
224	link_initialize(&dentry->dh_link);	225	link_initialize(&dentry->dh_link);
225	return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,	226	return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,
226	&names_ops);	227	&names_ops);
227	}	228	}
228		229
229	bool tmpfs_init(void)	230	bool tmpfs_init(void)
230	{	231	{
231	if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 2, &dentries_ops))	232	if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 2, &dentries_ops))
232	return false;	233	return false;
233		234
234	return true;	235	return true;
235	}	236	}
236		237
237	static bool tmpfs_instance_init(dev_handle_t dev_handle)	238	static bool tmpfs_instance_init(dev_handle_t dev_handle)
238	{	239	{
239	tmpfs_dentry_t *root;	240	fs_node_t *rfn;
240		241
241	root = (tmpfs_dentry_t *) tmpfs_create_node(dev_handle, L_DIRECTORY);	242	rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
242	if (!root)	243	if (!rfn)
243	return false;	244	return false;
244	root->lnkcnt = 0; /* FS root is not linked */	245	TMPFS_NODE(rfn)->lnkcnt = 0; /* FS root is not linked */
245	return true;	246	return true;
246	}	247	}
247		248
248	/** Compare one component of path to a directory entry.	249	/** Compare one component of path to a directory entry.
249	*	250	*
250	* @param parentp Pointer to node from which we descended.	251	* @param parentp Pointer to node from which we descended.
251	* @param childp Pointer to node to compare the path component with.	252	* @param childp Pointer to node to compare the path component with.
252	* @param component Array of characters holding component name.	253	* @param component Array of characters holding component name.
253	*	254	*
254	* @return True on match, false otherwise.	255	* @return True on match, false otherwise.
255	*/	256	*/
256	static bool	257	static bool
257	tmpfs_match_one(tmpfs_dentry_t parentp, tmpfs_dentry_t childp,	258	tmpfs_match_one(tmpfs_dentry_t parentp, tmpfs_dentry_t childp,
258	const char *component)	259	const char *component)
259	{	260	{
260	unsigned long key = (unsigned long) parentp;	261	unsigned long key = (unsigned long) parentp;
261	link_t *hlp = hash_table_find(&childp->names, &key);	262	link_t *hlp = hash_table_find(&childp->names, &key);
262	assert(hlp);	263	assert(hlp);
263	tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);	264	tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);
264	return !str_cmp(namep->name, component);	265	return !str_cmp(namep->name, component);
265	}	266	}
266		267
267	void tmpfs_match(void prnt, const char *component)	268	fs_node_t tmpfs_match(fs_node_t pfn, const char *component)
268	{	269	{
269	tmpfs_dentry_t parentp = (tmpfs_dentry_t ) prnt;	270	tmpfs_dentry_t *parentp = TMPFS_NODE(pfn);
270	tmpfs_dentry_t *childp = parentp->child;	271	tmpfs_dentry_t *childp = parentp->child;
271		272
272	while (childp && !tmpfs_match_one(parentp, childp, component))	273	while (childp && !tmpfs_match_one(parentp, childp, component))
273	childp = childp->sibling;	274	childp = childp->sibling;
274		275
275	return (void *) childp;	276	return FS_NODE(childp);
276	}	277	}
277		278
278	void *	-
279	tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)	279	fs_node_t *tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
280	{	280	{
281	unsigned long key[] = {	281	unsigned long key[] = {
282	[DENTRIES_KEY_INDEX] = index,	282	[DENTRIES_KEY_INDEX] = index,
283	[DENTRIES_KEY_DEV] = dev_handle	283	[DENTRIES_KEY_DEV] = dev_handle
284	};	284	};
285	link_t *lnk = hash_table_find(&dentries, key);	285	link_t *lnk = hash_table_find(&dentries, key);
286	if (!lnk)	286	if (!lnk)
287	return NULL;	287	return NULL;
288	return hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link);	288	return FS_NODE(hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link));
289	}	289	}
290		290
291	void tmpfs_node_put(void *node)	291	void tmpfs_node_put(fs_node_t *fn)
292	{	292	{
293	/* nothing to do */	293	/* nothing to do */
294	}	294	}
295		295
296	void *tmpfs_create_node(dev_handle_t dev_handle, int lflag)	296	fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
297	{	297	{
298	assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));	298	assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
299		299
-		300	fs_node_t *fn = malloc(sizeof(fs_node_t));
-		301	if (!fn)
-		302	return NULL;
-		303
300	tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));	304	tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
301	if (!node)	305	if (!node) {
-		306	free(fn);
302	return NULL;	307	return NULL;
303		308	}
304	if (!tmpfs_dentry_initialize(node)) {	309	if (!tmpfs_dentry_initialize(node)) {
-		310	free(fn);
305	free(node);	311	free(node);
306	return NULL;	312	return NULL;
307	}	313	}
-		314	fn->data = node;
-		315	node->bp = fn; /* establish the back pointer */
308	if (!tmpfs_root_get(dev_handle))	316	if (!tmpfs_root_get(dev_handle))
309	node->index = TMPFS_SOME_ROOT;	317	node->index = TMPFS_SOME_ROOT;
310	else	318	else
311	node->index = tmpfs_next_index++;	319	node->index = tmpfs_next_index++;
312	node->dev_handle = dev_handle;	320	node->dev_handle = dev_handle;
313	if (lflag & L_DIRECTORY)	321	if (lflag & L_DIRECTORY)
314	node->type = TMPFS_DIRECTORY;	322	node->type = TMPFS_DIRECTORY;
315	else	323	else
316	node->type = TMPFS_FILE;	324	node->type = TMPFS_FILE;
317		325
318	/* Insert the new node into the dentry hash table. */	326	/* Insert the new node into the dentry hash table. */
319	unsigned long key[] = {	327	unsigned long key[] = {
320	[DENTRIES_KEY_INDEX] = node->index,	328	[DENTRIES_KEY_INDEX] = node->index,
321	[DENTRIES_KEY_DEV] = node->dev_handle	329	[DENTRIES_KEY_DEV] = node->dev_handle
322	};	330	};
323	hash_table_insert(&dentries, key, &node->dh_link);	331	hash_table_insert(&dentries, key, &node->dh_link);
324	return (void *) node;	332	return fn;
325	}	333	}
326		334
327	int tmpfs_link_node(void prnt, void chld, const char *nm)	335	int tmpfs_link_node(fs_node_t pfn, fs_node_t cfn, const char *nm)
328	{	336	{
329	tmpfs_dentry_t parentp = (tmpfs_dentry_t ) prnt;	337	tmpfs_dentry_t *parentp = TMPFS_NODE(pfn);
330	tmpfs_dentry_t childp = (tmpfs_dentry_t ) chld;	338	tmpfs_dentry_t *childp = TMPFS_NODE(cfn);
331		339
332	assert(parentp->type == TMPFS_DIRECTORY);	340	assert(parentp->type == TMPFS_DIRECTORY);
333		341
334	tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));	342	tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
335	if (!namep)	343	if (!namep)
336	return ENOMEM;	344	return ENOMEM;
337	tmpfs_name_initialize(namep);	345	tmpfs_name_initialize(namep);
338	size_t size = str_size(nm);	346	size_t size = str_size(nm);
339	namep->name = malloc(size + 1);	347	namep->name = malloc(size + 1);
340	if (!namep->name) {	348	if (!namep->name) {
341	free(namep);	349	free(namep);
342	return ENOMEM;	350	return ENOMEM;
343	}	351	}
344	str_cpy(namep->name, size + 1, nm);	352	str_cpy(namep->name, size + 1, nm);
345	namep->parent = parentp;	353	namep->parent = parentp;
346		354
347	childp->lnkcnt++;	355	childp->lnkcnt++;
348		356
349	unsigned long key = (unsigned long) parentp;	357	unsigned long key = (unsigned long) parentp;
350	hash_table_insert(&childp->names, &key, &namep->link);	358	hash_table_insert(&childp->names, &key, &namep->link);
351		359
352	/* Insert the new node into the namespace. */	360	/* Insert the new node into the namespace. */
353	if (parentp->child) {	361	if (parentp->child) {
354	tmpfs_dentry_t *tmp = parentp->child;	362	tmpfs_dentry_t *tmp = parentp->child;
355	while (tmp->sibling)	363	while (tmp->sibling)
356	tmp = tmp->sibling;	364	tmp = tmp->sibling;
357	tmp->sibling = childp;	365	tmp->sibling = childp;
358	} else {	366	} else {
359	parentp->child = childp;	367	parentp->child = childp;
360	}	368	}
361		369
362	return EOK;	370	return EOK;
363	}	371	}
364		372
365	int tmpfs_unlink_node(void prnt, void chld)	373	int tmpfs_unlink_node(fs_node_t pfn, fs_node_t cfn)
366	{	374	{
367	tmpfs_dentry_t parentp = (tmpfs_dentry_t )prnt;	375	tmpfs_dentry_t *parentp = TMPFS_NODE(pfn);
368	tmpfs_dentry_t childp = (tmpfs_dentry_t )chld;	376	tmpfs_dentry_t *childp = TMPFS_NODE(cfn);
369		377
370	if (!parentp)	378	if (!parentp)
371	return EBUSY;	379	return EBUSY;
372		380
373	if (childp->child)	381	if (childp->child)
374	return ENOTEMPTY;	382	return ENOTEMPTY;
375		383
376	if (parentp->child == childp) {	384	if (parentp->child == childp) {
377	parentp->child = childp->sibling;	385	parentp->child = childp->sibling;
378	} else {	386	} else {
379	/* TODO: consider doubly linked list for organizing siblings. */	387	/* TODO: consider doubly linked list for organizing siblings. */
380	tmpfs_dentry_t *tmp = parentp->child;	388	tmpfs_dentry_t *tmp = parentp->child;
381	while (tmp->sibling != childp)	389	while (tmp->sibling != childp)
382	tmp = tmp->sibling;	390	tmp = tmp->sibling;
383	tmp->sibling = childp->sibling;	391	tmp->sibling = childp->sibling;
384	}	392	}
385	childp->sibling = NULL;	393	childp->sibling = NULL;
386		394
387	unsigned long key = (unsigned long) parentp;	395	unsigned long key = (unsigned long) parentp;
388	hash_table_remove(&childp->names, &key, 1);	396	hash_table_remove(&childp->names, &key, 1);
389		397
390	childp->lnkcnt--;	398	childp->lnkcnt--;
391		399
392	return EOK;	400	return EOK;
393	}	401	}
394		402
395	int tmpfs_destroy_node(void *nodep)	403	int tmpfs_destroy_node(fs_node_t *fn)
396	{	404	{
397	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) nodep;	405	tmpfs_dentry_t *dentry = TMPFS_NODE(fn);
398		406
399	assert(!dentry->lnkcnt);	407	assert(!dentry->lnkcnt);
400	assert(!dentry->child);	408	assert(!dentry->child);
401	assert(!dentry->sibling);	409	assert(!dentry->sibling);
402		410
403	unsigned long key[] = {	411	unsigned long key[] = {
404	[DENTRIES_KEY_INDEX] = dentry->index,	412	[DENTRIES_KEY_INDEX] = dentry->index,
405	[DENTRIES_KEY_DEV] = dentry->dev_handle	413	[DENTRIES_KEY_DEV] = dentry->dev_handle
406	};	414	};
407	hash_table_remove(&dentries, key, 2);	415	hash_table_remove(&dentries, key, 2);
408		416
409	hash_table_destroy(&dentry->names);	417	hash_table_destroy(&dentry->names);
410		418
411	if (dentry->type == TMPFS_FILE)	419	if (dentry->type == TMPFS_FILE)
412	free(dentry->data);	420	free(dentry->data);
-		421	free(dentry->bp);
413	free(dentry);	422	free(dentry);
414	return EOK;	423	return EOK;
415	}	424	}
416		425
417	void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)	426	void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
418	{	427	{
419	dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);	428	dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
420		429
421	/* accept the mount options */	430	/* accept the mount options */
422	ipc_callid_t callid;	431	ipc_callid_t callid;
423	size_t size;	432	size_t size;
424	if (!ipc_data_write_receive(&callid, &size)) {	433	if (!ipc_data_write_receive(&callid, &size)) {
425	ipc_answer_0(callid, EINVAL);	434	ipc_answer_0(callid, EINVAL);
426	ipc_answer_0(rid, EINVAL);	435	ipc_answer_0(rid, EINVAL);
427	return;	436	return;
428	}	437	}
429	char *opts = malloc(size + 1);	438	char *opts = malloc(size + 1);
430	if (!opts) {	439	if (!opts) {
431	ipc_answer_0(callid, ENOMEM);	440	ipc_answer_0(callid, ENOMEM);
432	ipc_answer_0(rid, ENOMEM);	441	ipc_answer_0(rid, ENOMEM);
433	return;	442	return;
434	}	443	}
435	ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);	444	ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
436	if (retval != EOK) {	445	if (retval != EOK) {
437	ipc_answer_0(rid, retval);	446	ipc_answer_0(rid, retval);
438	free(opts);	447	free(opts);
439	return;	448	return;
440	}	449	}
441	opts[size] = '\0';	450	opts[size] = '\0';
442		451
443	/* Initialize TMPFS instance. */	452	/* Initialize TMPFS instance. */
444	if (!tmpfs_instance_init(dev_handle)) {	453	if (!tmpfs_instance_init(dev_handle)) {
445	ipc_answer_0(rid, ENOMEM);	454	ipc_answer_0(rid, ENOMEM);
446	return;	455	return;
447	}	456	}
448		457
449	tmpfs_dentry_t *root = tmpfs_root_get(dev_handle);	458	tmpfs_dentry_t *root = TMPFS_NODE(tmpfs_root_get(dev_handle));
450	if (str_cmp(opts, "restore") == 0) {	459	if (str_cmp(opts, "restore") == 0) {
451	if (tmpfs_restore(dev_handle))	460	if (tmpfs_restore(dev_handle))
452	ipc_answer_3(rid, EOK, root->index, root->size,	461	ipc_answer_3(rid, EOK, root->index, root->size,
453	root->lnkcnt);	462	root->lnkcnt);
454	else	463	else
455	ipc_answer_0(rid, ELIMIT);	464	ipc_answer_0(rid, ELIMIT);
456	} else {	465	} else {
457	ipc_answer_3(rid, EOK, root->index, root->size, root->lnkcnt);	466	ipc_answer_3(rid, EOK, root->index, root->size, root->lnkcnt);
458	}	467	}
459	}	468	}
460		469
461	void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request)	470	void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request)
462	{	471	{
463	dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);	472	dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
464	fs_index_t mp_index = (fs_index_t) IPC_GET_ARG2(*request);	473	fs_index_t mp_index = (fs_index_t) IPC_GET_ARG2(*request);
465	fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);	474	fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);
466	dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);	475	dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);
467		476
468	ipc_answer_0(rid, ENOTSUP);	477	ipc_answer_0(rid, ENOTSUP);
469	}	478	}
470		479
471	void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)	480	void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
472	{	481	{
473	libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);	482	libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
474	}	483	}
475		484
476	void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)	485	void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
477	{	486	{
478	dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);	487	dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
479	fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);	488	fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
480	off_t pos = (off_t)IPC_GET_ARG3(*request);	489	off_t pos = (off_t)IPC_GET_ARG3(*request);
481		490
482	/*	491	/*
483	* Lookup the respective dentry.	492	* Lookup the respective dentry.
484	*/	493	*/
485	link_t *hlp;	494	link_t *hlp;
486	unsigned long key[] = {	495	unsigned long key[] = {
487	[DENTRIES_KEY_INDEX] = index,	496	[DENTRIES_KEY_INDEX] = index,
488	[DENTRIES_KEY_DEV] = dev_handle,	497	[DENTRIES_KEY_DEV] = dev_handle,
489	};	498	};
490	hlp = hash_table_find(&dentries, key);	499	hlp = hash_table_find(&dentries, key);

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/fs/tmpfs/tmpfs_ops.c @ 3109 – Rev 4306 → 4357