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
 
/*
 * For now, we don't distinguish between different dev_handles/instances. All
 * requests resolve to the only instance, rooted in the following variable.
 */
static tmpfs_dentry_t *root;
 
/*
 * Implementation of the libfs interface.
 */
 
/* Forward declarations of static functions. */
static bool tmpfs_match(void *, void *, const char *);
static void *tmpfs_node_get(int, int, unsigned long);
static void *tmpfs_create_node(int);
static bool tmpfs_link_node(void *, void *, const char *);
static int tmpfs_unlink_node(void *, void *);
static void tmpfs_destroy_node(void *);
 
/* Implementation of helper functions. */
static unsigned long tmpfs_index_get(void *nodep)
{
    return ((tmpfs_dentry_t *) nodep)->index;
}
 
static unsigned long tmpfs_size_get(void *nodep)
{
    return ((tmpfs_dentry_t *) nodep)->size;
}
 
static unsigned tmpfs_lnkcnt_get(void *nodep)
{
    return ((tmpfs_dentry_t *) nodep)->lnkcnt;
}
 
static void *tmpfs_child_get(void *nodep)
{
    return ((tmpfs_dentry_t *) nodep)->child;
}
 
static void *tmpfs_sibling_get(void *nodep)
{
    return ((tmpfs_dentry_t *) nodep)->sibling;
}
 
static void *tmpfs_root_get(void)
{
    return root;
}
 
static char tmpfs_plb_get_char(unsigned pos)
{
    return tmpfs_reg.plb_ro[pos % PLB_SIZE];
}
 
static bool tmpfs_is_directory(void *nodep)
{
    return ((tmpfs_dentry_t *) nodep)->type == TMPFS_DIRECTORY;
}
 
static bool tmpfs_is_file(void *nodep)
{
    return ((tmpfs_dentry_t *) nodep)->type == TMPFS_FILE;
}
 
/** libfs operations */
libfs_ops_t tmpfs_libfs_ops = {
    .match = tmpfs_match,
    .node_get = tmpfs_node_get,
    .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,
    .child_get = tmpfs_child_get,
    .sibling_get = tmpfs_sibling_get,
    .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;
 
/* Implementation of hash table interface for the dentries hash table. */
static hash_index_t dentries_hash(unsigned long *key)
{
    return *key % 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;
}
 
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
};
 
unsigned tmpfs_next_index = 1;
 
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->index = 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);
}
 
static bool tmpfs_init(void)
{
    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
        return false;
    root = (tmpfs_dentry_t *) tmpfs_create_node(L_DIRECTORY);
    if (!root) {
        hash_table_destroy(&dentries);
        return false;
    }
    root->lnkcnt = 1;
    return true;
}
 
/** Compare one component of path to a directory entry.
 *
 * @param prnt      Node from which we descended.
 * @param chld      Node to compare the path component with.
 * @param component Array of characters holding component name.
 *
 * @return      True on match, false otherwise.
 */
bool tmpfs_match(void *prnt, void *chld, const char *component)
{
    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
    tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld;
 
    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 !strcmp(namep->name, component);
}
 
void *tmpfs_node_get(int fs_handle, int dev_handle, unsigned long index)
{
    link_t *lnk = hash_table_find(&dentries, &index);
    if (!lnk)
        return NULL;
    return hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link);
}
 
void *tmpfs_create_node(int lflag)
{
    assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
 
    tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
    if (!node)
        return NULL;
 
    if (!tmpfs_dentry_initialize(node)) {
        free(node);
        return NULL;
    }
    node->index = tmpfs_next_index++;
    if (lflag & L_DIRECTORY)
        node->type = TMPFS_DIRECTORY;
    else
        node->type = TMPFS_FILE;
 
    /* Insert the new node into the dentry hash table. */
    hash_table_insert(&dentries, &node->index, &node->dh_link);
    return (void *) node;
}
 
bool 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;
 
    assert(parentp->type == TMPFS_DIRECTORY);
 
    tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
    if (!namep)
        return false;
    tmpfs_name_initialize(namep);
    size_t len = strlen(nm);
    namep->name = malloc(len + 1);
    if (!namep->name) {
        free(namep);
        return false;
    }
    strcpy(namep->name, 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 true;
}
 
int tmpfs_unlink_node(void *prnt, void *chld)
{
    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *)prnt;
    tmpfs_dentry_t *childp = (tmpfs_dentry_t *)chld;
 
    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;
}
 
void tmpfs_destroy_node(void *nodep)
{
    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep;
   
    assert(!dentry->lnkcnt);
    assert(!dentry->child);
    assert(!dentry->sibling);
 
    unsigned long index = dentry->index;
    hash_table_remove(&dentries, &index, 1);
 
    hash_table_destroy(&dentry->names);
 
    if (dentry->type == TMPFS_FILE)
        free(dentry->data);
    free(dentry);
}
 
void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
{
    /* Initialize TMPFS. */
    if (!root && !tmpfs_init()) {
        ipc_answer_0(rid, ENOMEM);
        return;
    }
    libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
}
 
void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
{
    int dev_handle = IPC_GET_ARG1(*request);
    unsigned long index = IPC_GET_ARG2(*request);
    off_t pos = IPC_GET_ARG3(*request);
 
    /*
     * Lookup the respective dentry.
     */
    link_t *hlp;
    hlp = hash_table_find(&dentries, &index);
    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 len;
    if (!ipc_data_read_receive(&callid, &len)) {
        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, len));
        (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,
            strlen(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)
{
    int dev_handle = IPC_GET_ARG1(*request);
    unsigned long index = IPC_GET_ARG2(*request);
    off_t pos = IPC_GET_ARG3(*request);
 
    /*
     * Lookup the respective dentry.
     */
    link_t *hlp;
    hlp = hash_table_find(&dentries, &index);
    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 len;
    if (!ipc_data_write_receive(&callid, &len)) {
        ipc_answer_0(callid, EINVAL);  
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Check whether the file needs to grow.
     */
    if (pos + len <= dentry->size) {
        /* The file size is not changing. */
        (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
        ipc_answer_2(rid, EOK, len, dentry->size);
        return;
    }
    size_t delta = (pos + len) - 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, len);
    ipc_answer_2(rid, EOK, len, dentry->size);
}
 
void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
{
    int dev_handle = IPC_GET_ARG1(*request);
    unsigned long index = IPC_GET_ARG2(*request);
    size_t size = IPC_GET_ARG3(*request);
 
    /*
     * Lookup the respective dentry.
     */
    link_t *hlp;
    hlp = hash_table_find(&dentries, &index);
    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)
{
    int dev_handle = IPC_GET_ARG1(*request);
    unsigned long index = IPC_GET_ARG2(*request);
 
    link_t *hlp;
    hlp = hash_table_find(&dentries, &index);
    if (!hlp) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
        dh_link);
    tmpfs_destroy_node(dentry);
    ipc_answer_0(rid, EOK);
}
 
/**
 * @}
 */
 

Rev 2760	Rev 2763
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	/*	61	/*
62	* For now, we don't distinguish between different dev_handles/instances. All	62	* For now, we don't distinguish between different dev_handles/instances. All
63	* requests resolve to the only instance, rooted in the following variable.	63	* requests resolve to the only instance, rooted in the following variable.
64	*/	64	*/
65	static tmpfs_dentry_t *root;	65	static tmpfs_dentry_t *root;
66		66
67	/*	67	/*
68	* Implementation of the libfs interface.	68	* Implementation of the libfs interface.
69	*/	69	*/
70		70
71	/* Forward declarations of static functions. */	71	/* Forward declarations of static functions. */
72	static bool tmpfs_match(void , void , const char *);	72	static bool tmpfs_match(void , void , const char *);
-		73	static void *tmpfs_node_get(int, int, unsigned long);
73	static void *tmpfs_create_node(int);	74	static void *tmpfs_create_node(int);
74	static bool tmpfs_link_node(void , void , const char *);	75	static bool tmpfs_link_node(void , void , const char *);
75	static int tmpfs_unlink_node(void , void );	76	static int tmpfs_unlink_node(void , void );
76	static void tmpfs_destroy_node(void *);	77	static void tmpfs_destroy_node(void *);
77		78
78	/* Implementation of helper functions. */	79	/* Implementation of helper functions. */
79	static unsigned long tmpfs_index_get(void *nodep)	80	static unsigned long tmpfs_index_get(void *nodep)
80	{	81	{
81	return ((tmpfs_dentry_t *) nodep)->index;	82	return ((tmpfs_dentry_t *) nodep)->index;
82	}	83	}
83		84
84	static unsigned long tmpfs_size_get(void *nodep)	85	static unsigned long tmpfs_size_get(void *nodep)
85	{	86	{
86	return ((tmpfs_dentry_t *) nodep)->size;	87	return ((tmpfs_dentry_t *) nodep)->size;
87	}	88	}
88		89
89	static unsigned tmpfs_lnkcnt_get(void *nodep)	90	static unsigned tmpfs_lnkcnt_get(void *nodep)
90	{	91	{
91	return ((tmpfs_dentry_t *) nodep)->lnkcnt;	92	return ((tmpfs_dentry_t *) nodep)->lnkcnt;
92	}	93	}
93		94
94	static void tmpfs_child_get(void nodep)	95	static void tmpfs_child_get(void nodep)
95	{	96	{
96	return ((tmpfs_dentry_t *) nodep)->child;	97	return ((tmpfs_dentry_t *) nodep)->child;
97	}	98	}
98		99
99	static void tmpfs_sibling_get(void nodep)	100	static void tmpfs_sibling_get(void nodep)
100	{	101	{
101	return ((tmpfs_dentry_t *) nodep)->sibling;	102	return ((tmpfs_dentry_t *) nodep)->sibling;
102	}	103	}
103		104
104	static void *tmpfs_root_get(void)	105	static void *tmpfs_root_get(void)
105	{	106	{
106	return root;	107	return root;
107	}	108	}
108		109
109	static char tmpfs_plb_get_char(unsigned pos)	110	static char tmpfs_plb_get_char(unsigned pos)
110	{	111	{
111	return tmpfs_reg.plb_ro[pos % PLB_SIZE];	112	return tmpfs_reg.plb_ro[pos % PLB_SIZE];
112	}	113	}
113		114
114	static bool tmpfs_is_directory(void *nodep)	115	static bool tmpfs_is_directory(void *nodep)
115	{	116	{
116	return ((tmpfs_dentry_t *) nodep)->type == TMPFS_DIRECTORY;	117	return ((tmpfs_dentry_t *) nodep)->type == TMPFS_DIRECTORY;
117	}	118	}
118		119
119	static bool tmpfs_is_file(void *nodep)	120	static bool tmpfs_is_file(void *nodep)
120	{	121	{
121	return ((tmpfs_dentry_t *) nodep)->type == TMPFS_FILE;	122	return ((tmpfs_dentry_t *) nodep)->type == TMPFS_FILE;
122	}	123	}
123		124
124	/** libfs operations */	125	/** libfs operations */
125	libfs_ops_t tmpfs_libfs_ops = {	126	libfs_ops_t tmpfs_libfs_ops = {
126	.match = tmpfs_match,	127	.match = tmpfs_match,
-		128	.node_get = tmpfs_node_get,
127	.create = tmpfs_create_node,	129	.create = tmpfs_create_node,
128	.destroy = tmpfs_destroy_node,	130	.destroy = tmpfs_destroy_node,
129	.link = tmpfs_link_node,	131	.link = tmpfs_link_node,
130	.unlink = tmpfs_unlink_node,	132	.unlink = tmpfs_unlink_node,
131	.index_get = tmpfs_index_get,	133	.index_get = tmpfs_index_get,
132	.size_get = tmpfs_size_get,	134	.size_get = tmpfs_size_get,
133	.lnkcnt_get = tmpfs_lnkcnt_get,	135	.lnkcnt_get = tmpfs_lnkcnt_get,
134	.child_get = tmpfs_child_get,	136	.child_get = tmpfs_child_get,
135	.sibling_get = tmpfs_sibling_get,	137	.sibling_get = tmpfs_sibling_get,
136	.root_get = tmpfs_root_get,	138	.root_get = tmpfs_root_get,
137	.plb_get_char = tmpfs_plb_get_char,	139	.plb_get_char = tmpfs_plb_get_char,
138	.is_directory = tmpfs_is_directory,	140	.is_directory = tmpfs_is_directory,
139	.is_file = tmpfs_is_file	141	.is_file = tmpfs_is_file
140	};	142	};
141		143
142	/** Hash table of all directory entries. */	144	/** Hash table of all directory entries. */
143	hash_table_t dentries;	145	hash_table_t dentries;
144		146
145	/* Implementation of hash table interface for the dentries hash table. */	147	/* Implementation of hash table interface for the dentries hash table. */
146	static hash_index_t dentries_hash(unsigned long *key)	148	static hash_index_t dentries_hash(unsigned long *key)
147	{	149	{
148	return *key % DENTRIES_BUCKETS;	150	return *key % DENTRIES_BUCKETS;
149	}	151	}
150		152
151	static int dentries_compare(unsigned long *key, hash_count_t keys,	153	static int dentries_compare(unsigned long *key, hash_count_t keys,
152	link_t *item)	154	link_t *item)
153	{	155	{
154	tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,	156	tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
155	dh_link);	157	dh_link);
156	return dentry->index == *key;	158	return dentry->index == *key;
157	}	159	}
158		160
159	static void dentries_remove_callback(link_t *item)	161	static void dentries_remove_callback(link_t *item)
160	{	162	{
161	}	163	}
162		164
163	/** TMPFS dentries hash table operations. */	165	/** TMPFS dentries hash table operations. */
164	hash_table_operations_t dentries_ops = {	166	hash_table_operations_t dentries_ops = {
165	.hash = dentries_hash,	167	.hash = dentries_hash,
166	.compare = dentries_compare,	168	.compare = dentries_compare,
167	.remove_callback = dentries_remove_callback	169	.remove_callback = dentries_remove_callback
168	};	170	};
169		171
170	unsigned tmpfs_next_index = 1;	172	unsigned tmpfs_next_index = 1;
171		173
172	typedef struct {	174	typedef struct {
173	char *name;	175	char *name;
174	tmpfs_dentry_t *parent;	176	tmpfs_dentry_t *parent;
175	link_t link;	177	link_t link;
176	} tmpfs_name_t;	178	} tmpfs_name_t;
177		179
178	/* Implementation of hash table interface for the names hash table. */	180	/* Implementation of hash table interface for the names hash table. */
179	static hash_index_t names_hash(unsigned long *key)	181	static hash_index_t names_hash(unsigned long *key)
180	{	182	{
181	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) *key;	183	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) *key;
182	return dentry->index % NAMES_BUCKETS;	184	return dentry->index % NAMES_BUCKETS;
183	}	185	}
184		186
185	static int names_compare(unsigned long key, hash_count_t keys, link_t item)	187	static int names_compare(unsigned long key, hash_count_t keys, link_t item)
186	{	188	{
187	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) *key;	189	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) *key;
188	tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,	190	tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
189	link);	191	link);
190	return dentry == namep->parent;	192	return dentry == namep->parent;
191	}	193	}
192		194
193	static void names_remove_callback(link_t *item)	195	static void names_remove_callback(link_t *item)
194	{	196	{
195	tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,	197	tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
196	link);	198	link);
197	free(namep->name);	199	free(namep->name);
198	free(namep);	200	free(namep);
199	}	201	}
200		202
201	/** TMPFS node names hash table operations. */	203	/** TMPFS node names hash table operations. */
202	static hash_table_operations_t names_ops = {	204	static hash_table_operations_t names_ops = {
203	.hash = names_hash,	205	.hash = names_hash,
204	.compare = names_compare,	206	.compare = names_compare,
205	.remove_callback = names_remove_callback	207	.remove_callback = names_remove_callback
206	};	208	};
207		209
208	static void tmpfs_name_initialize(tmpfs_name_t *namep)	210	static void tmpfs_name_initialize(tmpfs_name_t *namep)
209	{	211	{
210	namep->name = NULL;	212	namep->name = NULL;
211	namep->parent = NULL;	213	namep->parent = NULL;
212	link_initialize(&namep->link);	214	link_initialize(&namep->link);
213	}	215	}
214		216
215	static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)	217	static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
216	{	218	{
217	dentry->index = 0;	219	dentry->index = 0;
218	dentry->sibling = NULL;	220	dentry->sibling = NULL;
219	dentry->child = NULL;	221	dentry->child = NULL;
220	dentry->type = TMPFS_NONE;	222	dentry->type = TMPFS_NONE;
221	dentry->lnkcnt = 0;	223	dentry->lnkcnt = 0;
222	dentry->size = 0;	224	dentry->size = 0;
223	dentry->data = NULL;	225	dentry->data = NULL;
224	link_initialize(&dentry->dh_link);	226	link_initialize(&dentry->dh_link);
225	return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,	227	return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,
226	&names_ops);	228	&names_ops);
227	}	229	}
228		230
229	static bool tmpfs_init(void)	231	static bool tmpfs_init(void)
230	{	232	{
231	if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))	233	if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
232	return false;	234	return false;
233	root = (tmpfs_dentry_t *) tmpfs_create_node(L_DIRECTORY);	235	root = (tmpfs_dentry_t *) tmpfs_create_node(L_DIRECTORY);
234	if (!root) {	236	if (!root) {
235	hash_table_destroy(&dentries);	237	hash_table_destroy(&dentries);
236	return false;	238	return false;
237	}	239	}
238	root->lnkcnt = 1;	240	root->lnkcnt = 1;
239	return true;	241	return true;
240	}	242	}
241		243
242	/** Compare one component of path to a directory entry.	244	/** Compare one component of path to a directory entry.
243	*	245	*
244	* @param prnt Node from which we descended.	246	* @param prnt Node from which we descended.
245	* @param chld Node to compare the path component with.	247	* @param chld Node to compare the path component with.
246	* @param component Array of characters holding component name.	248	* @param component Array of characters holding component name.
247	*	249	*
248	* @return True on match, false otherwise.	250	* @return True on match, false otherwise.
249	*/	251	*/
250	bool tmpfs_match(void prnt, void chld, const char *component)	252	bool tmpfs_match(void prnt, void chld, const char *component)
251	{	253	{
252	tmpfs_dentry_t parentp = (tmpfs_dentry_t ) prnt;	254	tmpfs_dentry_t parentp = (tmpfs_dentry_t ) prnt;
253	tmpfs_dentry_t childp = (tmpfs_dentry_t ) chld;	255	tmpfs_dentry_t childp = (tmpfs_dentry_t ) chld;
254		256
255	unsigned long key = (unsigned long) parentp;	257	unsigned long key = (unsigned long) parentp;
256	link_t *hlp = hash_table_find(&childp->names, &key);	258	link_t *hlp = hash_table_find(&childp->names, &key);
257	assert(hlp);	259	assert(hlp);
258	tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);	260	tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);
259		261
260	return !strcmp(namep->name, component);	262	return !strcmp(namep->name, component);
261	}	263	}
-		264
-		265	void *tmpfs_node_get(int fs_handle, int dev_handle, unsigned long index)
-		266	{
-		267	link_t *lnk = hash_table_find(&dentries, &index);
-		268	if (!lnk)
-		269	return NULL;
-		270	return hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link);
-		271	}
262		272
263	void *tmpfs_create_node(int lflag)	273	void *tmpfs_create_node(int lflag)
264	{	274	{
265	assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));	275	assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
266		276
267	tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));	277	tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
268	if (!node)	278	if (!node)
269	return NULL;	279	return NULL;
270		280
271	if (!tmpfs_dentry_initialize(node)) {	281	if (!tmpfs_dentry_initialize(node)) {
272	free(node);	282	free(node);
273	return NULL;	283	return NULL;
274	}	284	}
275	node->index = tmpfs_next_index++;	285	node->index = tmpfs_next_index++;
276	if (lflag & L_DIRECTORY)	286	if (lflag & L_DIRECTORY)
277	node->type = TMPFS_DIRECTORY;	287	node->type = TMPFS_DIRECTORY;
278	else	288	else
279	node->type = TMPFS_FILE;	289	node->type = TMPFS_FILE;
280		290
281	/* Insert the new node into the dentry hash table. */	291	/* Insert the new node into the dentry hash table. */
282	hash_table_insert(&dentries, &node->index, &node->dh_link);	292	hash_table_insert(&dentries, &node->index, &node->dh_link);
283	return (void *) node;	293	return (void *) node;
284	}	294	}
285		295
286	bool tmpfs_link_node(void prnt, void chld, const char *nm)	296	bool tmpfs_link_node(void prnt, void chld, const char *nm)
287	{	297	{
288	tmpfs_dentry_t parentp = (tmpfs_dentry_t ) prnt;	298	tmpfs_dentry_t parentp = (tmpfs_dentry_t ) prnt;
289	tmpfs_dentry_t childp = (tmpfs_dentry_t ) chld;	299	tmpfs_dentry_t childp = (tmpfs_dentry_t ) chld;
290		300
291	assert(parentp->type == TMPFS_DIRECTORY);	301	assert(parentp->type == TMPFS_DIRECTORY);
292		302
293	tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));	303	tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
294	if (!namep)	304	if (!namep)
295	return false;	305	return false;
296	tmpfs_name_initialize(namep);	306	tmpfs_name_initialize(namep);
297	size_t len = strlen(nm);	307	size_t len = strlen(nm);
298	namep->name = malloc(len + 1);	308	namep->name = malloc(len + 1);
299	if (!namep->name) {	309	if (!namep->name) {
300	free(namep);	310	free(namep);
301	return false;	311	return false;
302	}	312	}
303	strcpy(namep->name, nm);	313	strcpy(namep->name, nm);
304	namep->parent = parentp;	314	namep->parent = parentp;
305		315
306	childp->lnkcnt++;	316	childp->lnkcnt++;
307		317
308	unsigned long key = (unsigned long) parentp;	318	unsigned long key = (unsigned long) parentp;
309	hash_table_insert(&childp->names, &key, &namep->link);	319	hash_table_insert(&childp->names, &key, &namep->link);
310		320
311	/* Insert the new node into the namespace. */	321	/* Insert the new node into the namespace. */
312	if (parentp->child) {	322	if (parentp->child) {
313	tmpfs_dentry_t *tmp = parentp->child;	323	tmpfs_dentry_t *tmp = parentp->child;
314	while (tmp->sibling)	324	while (tmp->sibling)
315	tmp = tmp->sibling;	325	tmp = tmp->sibling;
316	tmp->sibling = childp;	326	tmp->sibling = childp;
317	} else {	327	} else {
318	parentp->child = childp;	328	parentp->child = childp;
319	}	329	}
320		330
321	return true;	331	return true;
322	}	332	}
323		333
324	int tmpfs_unlink_node(void prnt, void chld)	334	int tmpfs_unlink_node(void prnt, void chld)
325	{	335	{
326	tmpfs_dentry_t parentp = (tmpfs_dentry_t )prnt;	336	tmpfs_dentry_t parentp = (tmpfs_dentry_t )prnt;
327	tmpfs_dentry_t childp = (tmpfs_dentry_t )chld;	337	tmpfs_dentry_t childp = (tmpfs_dentry_t )chld;
328		338
329	if (!parentp)	339	if (!parentp)
330	return EBUSY;	340	return EBUSY;
331		341
332	if (childp->child)	342	if (childp->child)
333	return ENOTEMPTY;	343	return ENOTEMPTY;
334		344
335	if (parentp->child == childp) {	345	if (parentp->child == childp) {
336	parentp->child = childp->sibling;	346	parentp->child = childp->sibling;
337	} else {	347	} else {
338	/* TODO: consider doubly linked list for organizing siblings. */	348	/* TODO: consider doubly linked list for organizing siblings. */
339	tmpfs_dentry_t *tmp = parentp->child;	349	tmpfs_dentry_t *tmp = parentp->child;
340	while (tmp->sibling != childp)	350	while (tmp->sibling != childp)
341	tmp = tmp->sibling;	351	tmp = tmp->sibling;
342	tmp->sibling = childp->sibling;	352	tmp->sibling = childp->sibling;
343	}	353	}
344	childp->sibling = NULL;	354	childp->sibling = NULL;
345		355
346	unsigned long key = (unsigned long) parentp;	356	unsigned long key = (unsigned long) parentp;
347	hash_table_remove(&childp->names, &key, 1);	357	hash_table_remove(&childp->names, &key, 1);
348		358
349	childp->lnkcnt--;	359	childp->lnkcnt--;
350		360
351	return EOK;	361	return EOK;
352	}	362	}
353		363
354	void tmpfs_destroy_node(void *nodep)	364	void tmpfs_destroy_node(void *nodep)
355	{	365	{
356	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) nodep;	366	tmpfs_dentry_t dentry = (tmpfs_dentry_t ) nodep;
357		367
358	assert(!dentry->lnkcnt);	368	assert(!dentry->lnkcnt);
359	assert(!dentry->child);	369	assert(!dentry->child);
360	assert(!dentry->sibling);	370	assert(!dentry->sibling);
361		371
362	unsigned long index = dentry->index;	372	unsigned long index = dentry->index;
363	hash_table_remove(&dentries, &index, 1);	373	hash_table_remove(&dentries, &index, 1);
364		374
365	hash_table_destroy(&dentry->names);	375	hash_table_destroy(&dentry->names);
366		376
367	if (dentry->type == TMPFS_FILE)	377	if (dentry->type == TMPFS_FILE)
368	free(dentry->data);	378	free(dentry->data);
369	free(dentry);	379	free(dentry);
370	}	380	}
371		381
372	void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)	382	void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
373	{	383	{
374	/* Initialize TMPFS. */	384	/* Initialize TMPFS. */
375	if (!root && !tmpfs_init()) {	385	if (!root && !tmpfs_init()) {
376	ipc_answer_0(rid, ENOMEM);	386	ipc_answer_0(rid, ENOMEM);
377	return;	387	return;
378	}	388	}
379	libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);	389	libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
380	}	390	}
381		391
382	void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)	392	void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
383	{	393	{
384	int dev_handle = IPC_GET_ARG1(*request);	394	int dev_handle = IPC_GET_ARG1(*request);
385	unsigned long index = IPC_GET_ARG2(*request);	395	unsigned long index = IPC_GET_ARG2(*request);
386	off_t pos = IPC_GET_ARG3(*request);	396	off_t pos = IPC_GET_ARG3(*request);
387		397
388	/*	398	/*
389	* Lookup the respective dentry.	399	* Lookup the respective dentry.
390	*/	400	*/
391	link_t *hlp;	401	link_t *hlp;
392	hlp = hash_table_find(&dentries, &index);	402	hlp = hash_table_find(&dentries, &index);
393	if (!hlp) {	403	if (!hlp) {
394	ipc_answer_0(rid, ENOENT);	404	ipc_answer_0(rid, ENOENT);
395	return;	405	return;
396	}	406	}
397	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,	407	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
398	dh_link);	408	dh_link);
399		409
400	/*	410	/*
401	* Receive the read request.	411	* Receive the read request.
402	*/	412	*/
403	ipc_callid_t callid;	413	ipc_callid_t callid;
404	size_t len;	414	size_t len;
405	if (!ipc_data_read_receive(&callid, &len)) {	415	if (!ipc_data_read_receive(&callid, &len)) {
406	ipc_answer_0(callid, EINVAL);	416	ipc_answer_0(callid, EINVAL);
407	ipc_answer_0(rid, EINVAL);	417	ipc_answer_0(rid, EINVAL);
408	return;	418	return;
409	}	419	}
410		420
411	size_t bytes;	421	size_t bytes;
412	if (dentry->type == TMPFS_FILE) {	422	if (dentry->type == TMPFS_FILE) {
413	bytes = max(0, min(dentry->size - pos, len));	423	bytes = max(0, min(dentry->size - pos, len));
414	(void) ipc_data_read_finalize(callid, dentry->data + pos,	424	(void) ipc_data_read_finalize(callid, dentry->data + pos,
415	bytes);	425	bytes);
416	} else {	426	} else {
417	int i;	427	int i;
418	tmpfs_dentry_t *cur;	428	tmpfs_dentry_t *cur;
419		429
420	assert(dentry->type == TMPFS_DIRECTORY);	430	assert(dentry->type == TMPFS_DIRECTORY);
421		431
422	/*	432	/*
423	* Yes, we really use O(n) algorithm here.	433	* Yes, we really use O(n) algorithm here.
424	* If it bothers someone, it could be fixed by introducing a	434	* If it bothers someone, it could be fixed by introducing a
425	* hash table.	435	* hash table.
426	*/	436	*/
427	for (i = 0, cur = dentry->child; i < pos && cur; i++,	437	for (i = 0, cur = dentry->child; i < pos && cur; i++,
428	cur = cur->sibling)	438	cur = cur->sibling)
429	;	439	;
430		440
431	if (!cur) {	441	if (!cur) {
432	ipc_answer_0(callid, ENOENT);	442	ipc_answer_0(callid, ENOENT);
433	ipc_answer_1(rid, ENOENT, 0);	443	ipc_answer_1(rid, ENOENT, 0);
434	return;	444	return;
435	}	445	}
436		446
437	unsigned long key = (unsigned long) dentry;	447	unsigned long key = (unsigned long) dentry;
438	link_t *hlp = hash_table_find(&cur->names, &key);	448	link_t *hlp = hash_table_find(&cur->names, &key);
439	assert(hlp);	449	assert(hlp);
440	tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t,	450	tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t,
441	link);	451	link);
442		452
443	(void) ipc_data_read_finalize(callid, namep->name,	453	(void) ipc_data_read_finalize(callid, namep->name,
444	strlen(namep->name) + 1);	454	strlen(namep->name) + 1);
445	bytes = 1;	455	bytes = 1;
446	}	456	}
447		457
448	/*	458	/*
449	* Answer the VFS_READ call.	459	* Answer the VFS_READ call.
450	*/	460	*/
451	ipc_answer_1(rid, EOK, bytes);	461	ipc_answer_1(rid, EOK, bytes);
452	}	462	}
453		463
454	void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)	464	void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
455	{	465	{
456	int dev_handle = IPC_GET_ARG1(*request);	466	int dev_handle = IPC_GET_ARG1(*request);
457	unsigned long index = IPC_GET_ARG2(*request);	467	unsigned long index = IPC_GET_ARG2(*request);
458	off_t pos = IPC_GET_ARG3(*request);	468	off_t pos = IPC_GET_ARG3(*request);
459		469
460	/*	470	/*
461	* Lookup the respective dentry.	471	* Lookup the respective dentry.
462	*/	472	*/
463	link_t *hlp;	473	link_t *hlp;
464	hlp = hash_table_find(&dentries, &index);	474	hlp = hash_table_find(&dentries, &index);
465	if (!hlp) {	475	if (!hlp) {
466	ipc_answer_0(rid, ENOENT);	476	ipc_answer_0(rid, ENOENT);
467	return;	477	return;
468	}	478	}
469	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,	479	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
470	dh_link);	480	dh_link);
471		481
472	/*	482	/*
473	* Receive the write request.	483	* Receive the write request.
474	*/	484	*/
475	ipc_callid_t callid;	485	ipc_callid_t callid;
476	size_t len;	486	size_t len;
477	if (!ipc_data_write_receive(&callid, &len)) {	487	if (!ipc_data_write_receive(&callid, &len)) {
478	ipc_answer_0(callid, EINVAL);	488	ipc_answer_0(callid, EINVAL);
479	ipc_answer_0(rid, EINVAL);	489	ipc_answer_0(rid, EINVAL);
480	return;	490	return;
481	}	491	}
482		492
483	/*	493	/*
484	* Check whether the file needs to grow.	494	* Check whether the file needs to grow.
485	*/	495	*/
486	if (pos + len <= dentry->size) {	496	if (pos + len <= dentry->size) {
487	/* The file size is not changing. */	497	/* The file size is not changing. */
488	(void) ipc_data_write_finalize(callid, dentry->data + pos, len);	498	(void) ipc_data_write_finalize(callid, dentry->data + pos, len);
489	ipc_answer_2(rid, EOK, len, dentry->size);	499	ipc_answer_2(rid, EOK, len, dentry->size);
490	return;	500	return;

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/fs/tmpfs/tmpfs_ops.c – Rev 2760 → 2763