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>
 
#define min(a, b)       ((a) < (b) ? (a) : (b))
#define max(a, b)       ((a) > (b) ? (a) : (b))
 
#define PLB_GET_CHAR(i)     (tmpfs_reg.plb_ro[(i) % PLB_SIZE])
 
#define DENTRIES_BUCKETS    256
 
/*
 * Hash table of all directory entries.
 */
hash_table_t dentries;
 
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;
 
static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
{
    dentry->index = 0;
    dentry->parent = NULL;
    dentry->sibling = NULL;
    dentry->child = NULL;
    dentry->name = NULL;
    dentry->type = TMPFS_NONE;
    dentry->size = 0;
    dentry->data = NULL;
    link_initialize(&dentry->dh_link);
}
 
/*
 * 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;
 
static bool tmpfs_init(void)
{
    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
        return false;
 
    root = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
    if (!root)
        return false;
    tmpfs_dentry_initialize(root);
    root->index = tmpfs_next_index++;
    root->name = "";
    root->type = TMPFS_DIRECTORY;
    hash_table_insert(&dentries, &root->index, &root->dh_link);
 
    /*
     * This is only for debugging. Once we can create files and directories
     * using VFS, we can get rid of this.
     */
    tmpfs_dentry_t *d;
    d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
    if (!d) {
        free(root);
        root = NULL;
        return false;
    }
    tmpfs_dentry_initialize(d);
    d->index = tmpfs_next_index++;
    root->child = d;
    d->parent = root;
    d->type = TMPFS_DIRECTORY;
    d->name = "dir1";
    hash_table_insert(&dentries, &d->index, &d->dh_link);
 
    d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
    if (!d) {
        free(root->child);
        free(root);
        root = NULL;
        return false;
    }
    tmpfs_dentry_initialize(d);
    d->index = tmpfs_next_index++;
    root->child->sibling = d;
    d->parent = root;
    d->type = TMPFS_DIRECTORY;
    d->name = "dir2";
    hash_table_insert(&dentries, &d->index, &d->dh_link);
   
    d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
    if (!d) {
        free(root->child->sibling);
        free(root->child);
        free(root);
        root = NULL;
        return false;
    }
    tmpfs_dentry_initialize(d);
    d->index = tmpfs_next_index++;
    root->child->child = d;
    d->parent = root->child;
    d->type = TMPFS_FILE;
    d->name = "file1";
    d->data = "This is the contents of /dir1/file1.\n";
    d->size = strlen(d->data);
    hash_table_insert(&dentries, &d->index, &d->dh_link);
 
    d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
    if (!d) {
        free(root->child->sibling);
        free(root->child->child);
        free(root->child);
        free(root);
        root = NULL;
        return false;
    }
    tmpfs_dentry_initialize(d);
    d->index = tmpfs_next_index++;
    root->child->sibling->child = d;
    d->parent = root->child->sibling;
    d->type = TMPFS_FILE;
    d->name = "file2";
    d->data = "This is the contents of /dir2/file2.\n";
    d->size = strlen(d->data);
    hash_table_insert(&dentries, &d->index, &d->dh_link);
 
    return true;
}
 
/** Compare one component of path to a directory entry.
 *
 * @param dentry    Directory entry to compare the path component with.
 * @param start     Index into PLB where the path component starts.
 * @param last      Index of the last character of the path in PLB.
 *
 * @return      Zero on failure or delta such that (index + delta) %
 *          PLB_SIZE points to the first unprocessed character in
 *          PLB which comprises the path.
 */
static unsigned match_path_component(tmpfs_dentry_t *dentry, unsigned start,
    unsigned last)
{
    int i, j;
    size_t namelen;
 
    namelen = strlen(dentry->name);
 
    if (last < start)
        last += PLB_SIZE;
 
    for (i = 0, j = start; i < namelen && j <= last; i++, j++) {
        if (dentry->name[i] != PLB_GET_CHAR(j))
            return 0;
    }
   
    if (i != namelen)
        return 0;
    if (j < last && PLB_GET_CHAR(j) != '/')
        return 0;
    if (j == last)
            return 0;
   
    return (j - start);
}
 
void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
{
    unsigned next = IPC_GET_ARG1(*request);
    unsigned last = IPC_GET_ARG2(*request);
    int dev_handle = IPC_GET_ARG3(*request);
 
    if (last < next)
        last += PLB_SIZE;
 
    if (!root && !tmpfs_init()) {
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    tmpfs_dentry_t *dtmp = root->child;
    tmpfs_dentry_t *dcur = root;
 
    bool hit = true;
   
    if (PLB_GET_CHAR(next) == '/')
        next++;     /* eat slash */
   
    while (next <= last) {
        unsigned delta;
        hit = false;
        do {
            delta = match_path_component(dtmp, next, last);
            if (!delta) {
                dtmp = dtmp->sibling;
            } else {
                hit = true;
                next += delta;
                next++;     /* eat slash */
                dcur = dtmp;
                dtmp = dtmp->child;
            }  
        } while (delta == 0 && dtmp);
        if (!hit) {
            ipc_answer_3(rid, ENOENT, tmpfs_reg.fs_handle,
                dev_handle, dcur->index);
            return;
        }
    }
 
    ipc_answer_4(rid, EOK, tmpfs_reg.fs_handle, dev_handle, dcur->index,
        dcur->size);
}
 
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 = dentry->child;
       
        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;
        }
 
        (void) ipc_data_read_finalize(callid, cur->name,
            strlen(cur->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_1(rid, EOK, len);
        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_1(rid, EOK, 0);
        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);
}
 
/**
 * @}
 */
 

Rev 2693	Rev 2699
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 <sys/types.h>	49	#include <sys/types.h>
49	#include <libadt/hash_table.h>	50	#include <libadt/hash_table.h>
50	#include <as.h>	51	#include <as.h>
51		52
52	#define min(a, b) ((a) < (b) ? (a) : (b))	53	#define min(a, b) ((a) < (b) ? (a) : (b))
53	#define max(a, b) ((a) > (b) ? (a) : (b))	54	#define max(a, b) ((a) > (b) ? (a) : (b))
54		55
55	#define PLB_GET_CHAR(i) (tmpfs_reg.plb_ro[(i) % PLB_SIZE])	56	#define PLB_GET_CHAR(i) (tmpfs_reg.plb_ro[(i) % PLB_SIZE])
56		57
57	#define DENTRIES_BUCKETS 256	58	#define DENTRIES_BUCKETS 256
58		59
59	/*	60	/*
60	* Hash table of all directory entries.	61	* Hash table of all directory entries.
61	*/	62	*/
62	hash_table_t dentries;	63	hash_table_t dentries;
63		64
64	static hash_index_t dentries_hash(unsigned long *key)	65	static hash_index_t dentries_hash(unsigned long *key)
65	{	66	{
66	return *key % DENTRIES_BUCKETS;	67	return *key % DENTRIES_BUCKETS;
67	}	68	}
68		69
69	static int dentries_compare(unsigned long *key, hash_count_t keys,	70	static int dentries_compare(unsigned long *key, hash_count_t keys,
70	link_t *item)	71	link_t *item)
71	{	72	{
72	tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,	73	tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
73	dh_link);	74	dh_link);
74	return dentry->index == *key;	75	return dentry->index == *key;
75	}	76	}
76		77
77	static void dentries_remove_callback(link_t *item)	78	static void dentries_remove_callback(link_t *item)
78	{	79	{
79	}	80	}
80		81
81	/** TMPFS dentries hash table operations. */	82	/** TMPFS dentries hash table operations. */
82	hash_table_operations_t dentries_ops = {	83	hash_table_operations_t dentries_ops = {
83	.hash = dentries_hash,	84	.hash = dentries_hash,
84	.compare = dentries_compare,	85	.compare = dentries_compare,
85	.remove_callback = dentries_remove_callback	86	.remove_callback = dentries_remove_callback
86	};	87	};
87		88
88	unsigned tmpfs_next_index = 1;	89	unsigned tmpfs_next_index = 1;
89		90
90	static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)	91	static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
91	{	92	{
92	dentry->index = 0;	93	dentry->index = 0;
93	dentry->parent = NULL;	94	dentry->parent = NULL;
94	dentry->sibling = NULL;	95	dentry->sibling = NULL;
95	dentry->child = NULL;	96	dentry->child = NULL;
96	dentry->name = NULL;	97	dentry->name = NULL;
97	dentry->type = TMPFS_NONE;	98	dentry->type = TMPFS_NONE;
98	dentry->size = 0;	99	dentry->size = 0;
99	dentry->data = NULL;	100	dentry->data = NULL;
100	link_initialize(&dentry->dh_link);	101	link_initialize(&dentry->dh_link);
101	}	102	}
102		103
103	/*	104	/*
104	* For now, we don't distinguish between different dev_handles/instances. All	105	* For now, we don't distinguish between different dev_handles/instances. All
105	* requests resolve to the only instance, rooted in the following variable.	106	* requests resolve to the only instance, rooted in the following variable.
106	*/	107	*/
107	static tmpfs_dentry_t *root;	108	static tmpfs_dentry_t *root;
108		109
109	static bool tmpfs_init(void)	110	static bool tmpfs_init(void)
110	{	111	{
111	if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))	112	if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
112	return false;	113	return false;
113		114
114	root = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));	115	root = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
115	if (!root)	116	if (!root)
116	return false;	117	return false;
117	tmpfs_dentry_initialize(root);	118	tmpfs_dentry_initialize(root);
118	root->index = tmpfs_next_index++;	119	root->index = tmpfs_next_index++;
119	root->name = "";	120	root->name = "";
120	root->type = TMPFS_DIRECTORY;	121	root->type = TMPFS_DIRECTORY;
121	hash_table_insert(&dentries, &root->index, &root->dh_link);	122	hash_table_insert(&dentries, &root->index, &root->dh_link);
122		123
123	/*	124	/*
124	* This is only for debugging. Once we can create files and directories	125	* This is only for debugging. Once we can create files and directories
125	* using VFS, we can get rid of this.	126	* using VFS, we can get rid of this.
126	*/	127	*/
127	tmpfs_dentry_t *d;	128	tmpfs_dentry_t *d;
128	d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));	129	d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
129	if (!d) {	130	if (!d) {
130	free(root);	131	free(root);
131	root = NULL;	132	root = NULL;
132	return false;	133	return false;
133	}	134	}
134	tmpfs_dentry_initialize(d);	135	tmpfs_dentry_initialize(d);
135	d->index = tmpfs_next_index++;	136	d->index = tmpfs_next_index++;
136	root->child = d;	137	root->child = d;
137	d->parent = root;	138	d->parent = root;
138	d->type = TMPFS_DIRECTORY;	139	d->type = TMPFS_DIRECTORY;
139	d->name = "dir1";	140	d->name = "dir1";
140	hash_table_insert(&dentries, &d->index, &d->dh_link);	141	hash_table_insert(&dentries, &d->index, &d->dh_link);
141		142
142	d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));	143	d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
143	if (!d) {	144	if (!d) {
144	free(root->child);	145	free(root->child);
145	free(root);	146	free(root);
146	root = NULL;	147	root = NULL;
147	return false;	148	return false;
148	}	149	}
149	tmpfs_dentry_initialize(d);	150	tmpfs_dentry_initialize(d);
150	d->index = tmpfs_next_index++;	151	d->index = tmpfs_next_index++;
151	root->child->sibling = d;	152	root->child->sibling = d;
152	d->parent = root;	153	d->parent = root;
153	d->type = TMPFS_DIRECTORY;	154	d->type = TMPFS_DIRECTORY;
154	d->name = "dir2";	155	d->name = "dir2";
155	hash_table_insert(&dentries, &d->index, &d->dh_link);	156	hash_table_insert(&dentries, &d->index, &d->dh_link);
156		157
157	d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));	158	d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
158	if (!d) {	159	if (!d) {
159	free(root->child->sibling);	160	free(root->child->sibling);
160	free(root->child);	161	free(root->child);
161	free(root);	162	free(root);
162	root = NULL;	163	root = NULL;
163	return false;	164	return false;
164	}	165	}
165	tmpfs_dentry_initialize(d);	166	tmpfs_dentry_initialize(d);
166	d->index = tmpfs_next_index++;	167	d->index = tmpfs_next_index++;
167	root->child->child = d;	168	root->child->child = d;
168	d->parent = root->child;	169	d->parent = root->child;
169	d->type = TMPFS_FILE;	170	d->type = TMPFS_FILE;
170	d->name = "file1";	171	d->name = "file1";
171	d->data = "This is the contents of /dir1/file1.\n";	172	d->data = "This is the contents of /dir1/file1.\n";
172	d->size = strlen(d->data);	173	d->size = strlen(d->data);
173	hash_table_insert(&dentries, &d->index, &d->dh_link);	174	hash_table_insert(&dentries, &d->index, &d->dh_link);
174		175
175	d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));	176	d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
176	if (!d) {	177	if (!d) {
177	free(root->child->sibling);	178	free(root->child->sibling);
178	free(root->child->child);	179	free(root->child->child);
179	free(root->child);	180	free(root->child);
180	free(root);	181	free(root);
181	root = NULL;	182	root = NULL;
182	return false;	183	return false;
183	}	184	}
184	tmpfs_dentry_initialize(d);	185	tmpfs_dentry_initialize(d);
185	d->index = tmpfs_next_index++;	186	d->index = tmpfs_next_index++;
186	root->child->sibling->child = d;	187	root->child->sibling->child = d;
187	d->parent = root->child->sibling;	188	d->parent = root->child->sibling;
188	d->type = TMPFS_FILE;	189	d->type = TMPFS_FILE;
189	d->name = "file2";	190	d->name = "file2";
190	d->data = "This is the contents of /dir2/file2.\n";	191	d->data = "This is the contents of /dir2/file2.\n";
191	d->size = strlen(d->data);	192	d->size = strlen(d->data);
192	hash_table_insert(&dentries, &d->index, &d->dh_link);	193	hash_table_insert(&dentries, &d->index, &d->dh_link);
193		194
194	return true;	195	return true;
195	}	196	}
196		197
197	/** Compare one component of path to a directory entry.	198	/** Compare one component of path to a directory entry.
198	*	199	*
199	* @param dentry Directory entry to compare the path component with.	200	* @param dentry Directory entry to compare the path component with.
200	* @param start Index into PLB where the path component starts.	201	* @param start Index into PLB where the path component starts.
201	* @param last Index of the last character of the path in PLB.	202	* @param last Index of the last character of the path in PLB.
202	*	203	*
203	* @return Zero on failure or delta such that (index + delta) %	204	* @return Zero on failure or delta such that (index + delta) %
204	* PLB_SIZE points to the first unprocessed character in	205	* PLB_SIZE points to the first unprocessed character in
205	* PLB which comprises the path.	206	* PLB which comprises the path.
206	*/	207	*/
207	static unsigned match_path_component(tmpfs_dentry_t *dentry, unsigned start,	208	static unsigned match_path_component(tmpfs_dentry_t *dentry, unsigned start,
208	unsigned last)	209	unsigned last)
209	{	210	{
210	int i, j;	211	int i, j;
211	size_t namelen;	212	size_t namelen;
212		213
213	namelen = strlen(dentry->name);	214	namelen = strlen(dentry->name);
214		215
215	if (last < start)	216	if (last < start)
216	last += PLB_SIZE;	217	last += PLB_SIZE;
217		218
218	for (i = 0, j = start; i < namelen && j <= last; i++, j++) {	219	for (i = 0, j = start; i < namelen && j <= last; i++, j++) {
219	if (dentry->name[i] != PLB_GET_CHAR(j))	220	if (dentry->name[i] != PLB_GET_CHAR(j))
220	return 0;	221	return 0;
221	}	222	}
222		223
223	if (i != namelen)	224	if (i != namelen)
224	return 0;	225	return 0;
225	if (j < last && PLB_GET_CHAR(j) != '/')	226	if (j < last && PLB_GET_CHAR(j) != '/')
226	return 0;	227	return 0;
227	if (j == last)	228	if (j == last)
228	return 0;	229	return 0;
229		230
230	return (j - start);	231	return (j - start);
231	}	232	}
232		233
233	void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)	234	void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
234	{	235	{
235	unsigned next = IPC_GET_ARG1(*request);	236	unsigned next = IPC_GET_ARG1(*request);
236	unsigned last = IPC_GET_ARG2(*request);	237	unsigned last = IPC_GET_ARG2(*request);
237	int dev_handle = IPC_GET_ARG3(*request);	238	int dev_handle = IPC_GET_ARG3(*request);
238		239
239	if (last < next)	240	if (last < next)
240	last += PLB_SIZE;	241	last += PLB_SIZE;
241		242
242	if (!root && !tmpfs_init()) {	243	if (!root && !tmpfs_init()) {
243	ipc_answer_0(rid, ENOMEM);	244	ipc_answer_0(rid, ENOMEM);
244	return;	245	return;
245	}	246	}
246		247
247	tmpfs_dentry_t *dtmp = root->child;	248	tmpfs_dentry_t *dtmp = root->child;
248	tmpfs_dentry_t *dcur = root;	249	tmpfs_dentry_t *dcur = root;
249		250
250	bool hit = true;	251	bool hit = true;
251		252
252	if (PLB_GET_CHAR(next) == '/')	253	if (PLB_GET_CHAR(next) == '/')
253	next++; /* eat slash */	254	next++; /* eat slash */
254		255
255	while (next <= last) {	256	while (next <= last) {
256	unsigned delta;	257	unsigned delta;
257	hit = false;	258	hit = false;
258	do {	259	do {
259	delta = match_path_component(dtmp, next, last);	260	delta = match_path_component(dtmp, next, last);
260	if (!delta) {	261	if (!delta) {
261	dtmp = dtmp->sibling;	262	dtmp = dtmp->sibling;
262	} else {	263	} else {
263	hit = true;	264	hit = true;
264	next += delta;	265	next += delta;
265	next++; /* eat slash */	266	next++; /* eat slash */
266	dcur = dtmp;	267	dcur = dtmp;
267	dtmp = dtmp->child;	268	dtmp = dtmp->child;
268	}	269	}
269	} while (delta == 0 && dtmp);	270	} while (delta == 0 && dtmp);
270	if (!hit) {	271	if (!hit) {
271	ipc_answer_3(rid, ENOENT, tmpfs_reg.fs_handle,	272	ipc_answer_3(rid, ENOENT, tmpfs_reg.fs_handle,
272	dev_handle, dcur->index);	273	dev_handle, dcur->index);
273	return;	274	return;
274	}	275	}
275	}	276	}
276		277
277	ipc_answer_4(rid, EOK, tmpfs_reg.fs_handle, dev_handle, dcur->index,	278	ipc_answer_4(rid, EOK, tmpfs_reg.fs_handle, dev_handle, dcur->index,
278	dcur->size);	279	dcur->size);
279	}	280	}
280		281
281	void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)	282	void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
282	{	283	{
283	int dev_handle = IPC_GET_ARG1(*request);	284	int dev_handle = IPC_GET_ARG1(*request);
284	unsigned long index = IPC_GET_ARG2(*request);	285	unsigned long index = IPC_GET_ARG2(*request);
285	off_t pos = IPC_GET_ARG3(*request);	286	off_t pos = IPC_GET_ARG3(*request);
286		287
287	/*	288	/*
288	* Lookup the respective dentry.	289	* Lookup the respective dentry.
289	*/	290	*/
290	link_t *hlp;	291	link_t *hlp;
291	hlp = hash_table_find(&dentries, &index);	292	hlp = hash_table_find(&dentries, &index);
292	if (!hlp) {	293	if (!hlp) {
293	ipc_answer_0(rid, ENOENT);	294	ipc_answer_0(rid, ENOENT);
294	return;	295	return;
295	}	296	}
296	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,	297	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
297	dh_link);	298	dh_link);
298		299
299	/*	300	/*
300	* Receive the read request.	301	* Receive the read request.
301	*/	302	*/
302	ipc_callid_t callid;	303	ipc_callid_t callid;
303	size_t len;	304	size_t len;
304	if (!ipc_data_read_receive(&callid, &len)) {	305	if (!ipc_data_read_receive(&callid, &len)) {
305	ipc_answer_0(callid, EINVAL);	306	ipc_answer_0(callid, EINVAL);
306	ipc_answer_0(rid, EINVAL);	307	ipc_answer_0(rid, EINVAL);
307	return;	308	return;
308	}	309	}
309		310
-		311	size_t bytes;
-		312	if (dentry->type == TMPFS_FILE) {
310	size_t bytes = max(0, min(dentry->size - pos, len));	313	bytes = max(0, min(dentry->size - pos, len));
311	(void) ipc_data_read_finalize(callid, dentry->data + pos, bytes);	314	(void) ipc_data_read_finalize(callid, dentry->data + pos,
-		315	bytes);
-		316	} else {
-		317	int i;
-		318	tmpfs_dentry_t *cur = dentry->child;
-		319
-		320	assert(dentry->type == TMPFS_DIRECTORY);
-		321
-		322	/*
-		323	* Yes, we really use O(n) algorithm here.
-		324	* If it bothers someone, it could be fixed by introducing a
-		325	* hash table.
-		326	*/
-		327	for (i = 0, cur = dentry->child; i < pos && cur; i++,
-		328	cur = cur->sibling)
-		329	;
-		330
-		331	if (!cur) {
-		332	ipc_answer_0(callid, ENOENT);
-		333	ipc_answer_1(rid, ENOENT, 0);
-		334	return;
-		335	}
-		336
-		337	(void) ipc_data_read_finalize(callid, cur->name,
-		338	strlen(cur->name) + 1);
-		339	bytes = 1;
-		340	}
312		341
313	/*	342	/*
314	* Answer the VFS_READ call.	343	* Answer the VFS_READ call.
315	*/	344	*/
316	ipc_answer_1(rid, EOK, bytes);	345	ipc_answer_1(rid, EOK, bytes);
317	}	346	}
318		347
319	void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)	348	void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
320	{	349	{
321	int dev_handle = IPC_GET_ARG1(*request);	350	int dev_handle = IPC_GET_ARG1(*request);
322	unsigned long index = IPC_GET_ARG2(*request);	351	unsigned long index = IPC_GET_ARG2(*request);
323	off_t pos = IPC_GET_ARG3(*request);	352	off_t pos = IPC_GET_ARG3(*request);
324		353
325	/*	354	/*
326	* Lookup the respective dentry.	355	* Lookup the respective dentry.
327	*/	356	*/
328	link_t *hlp;	357	link_t *hlp;
329	hlp = hash_table_find(&dentries, &index);	358	hlp = hash_table_find(&dentries, &index);
330	if (!hlp) {	359	if (!hlp) {
331	ipc_answer_0(rid, ENOENT);	360	ipc_answer_0(rid, ENOENT);
332	return;	361	return;
333	}	362	}
334	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,	363	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
335	dh_link);	364	dh_link);
336		365
337	/*	366	/*
338	* Receive the write request.	367	* Receive the write request.
339	*/	368	*/
340	ipc_callid_t callid;	369	ipc_callid_t callid;
341	size_t len;	370	size_t len;
342	if (!ipc_data_write_receive(&callid, &len)) {	371	if (!ipc_data_write_receive(&callid, &len)) {
343	ipc_answer_0(callid, EINVAL);	372	ipc_answer_0(callid, EINVAL);
344	ipc_answer_0(rid, EINVAL);	373	ipc_answer_0(rid, EINVAL);
345	return;	374	return;
346	}	375	}
347		376
348	/*	377	/*
349	* Check whether the file needs to grow.	378	* Check whether the file needs to grow.
350	*/	379	*/
351	if (pos + len <= dentry->size) {	380	if (pos + len <= dentry->size) {
352	/* The file size is not changing. */	381	/* The file size is not changing. */
353	(void) ipc_data_write_finalize(callid, dentry->data + pos, len);	382	(void) ipc_data_write_finalize(callid, dentry->data + pos, len);
354	ipc_answer_1(rid, EOK, len);	383	ipc_answer_1(rid, EOK, len);
355	return;	384	return;
356	}	385	}
357	size_t delta = (pos + len) - dentry->size;	386	size_t delta = (pos + len) - dentry->size;
358	/*	387	/*
359	* At this point, we are deliberately extremely straightforward and	388	* At this point, we are deliberately extremely straightforward and
360	* simply realloc the contents of the file on every write that grows the	389	* simply realloc the contents of the file on every write that grows the
361	* file. In the end, the situation might not be as bad as it may look:	390	* file. In the end, the situation might not be as bad as it may look:
362	* our heap allocator can save us and just grow the block whenever	391	* our heap allocator can save us and just grow the block whenever
363	* possible.	392	* possible.
364	*/	393	*/
365	void *newdata = realloc(dentry->data, dentry->size + delta);	394	void *newdata = realloc(dentry->data, dentry->size + delta);
366	if (!newdata) {	395	if (!newdata) {
367	ipc_answer_0(callid, ENOMEM);	396	ipc_answer_0(callid, ENOMEM);
368	ipc_answer_1(rid, EOK, 0);	397	ipc_answer_1(rid, EOK, 0);
369	return;	398	return;
370	}	399	}
371	/* Clear any newly allocated memory in order to emulate gaps. */	400	/* Clear any newly allocated memory in order to emulate gaps. */
372	memset(newdata + dentry->size, 0, delta);	401	memset(newdata + dentry->size, 0, delta);
373	dentry->size += delta;	402	dentry->size += delta;
374	dentry->data = newdata;	403	dentry->data = newdata;
375	(void) ipc_data_write_finalize(callid, dentry->data + pos, len);	404	(void) ipc_data_write_finalize(callid, dentry->data + pos, len);
376	ipc_answer_2(rid, EOK, len, dentry->size);	405	ipc_answer_2(rid, EOK, len, dentry->size);
377	}	406	}
378		407
379	void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)	408	void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
380	{	409	{
381	int dev_handle = IPC_GET_ARG1(*request);	410	int dev_handle = IPC_GET_ARG1(*request);
382	unsigned long index = IPC_GET_ARG2(*request);	411	unsigned long index = IPC_GET_ARG2(*request);
383	size_t size = IPC_GET_ARG3(*request);	412	size_t size = IPC_GET_ARG3(*request);
384		413
385	/*	414	/*
386	* Lookup the respective dentry.	415	* Lookup the respective dentry.
387	*/	416	*/
388	link_t *hlp;	417	link_t *hlp;
389	hlp = hash_table_find(&dentries, &index);	418	hlp = hash_table_find(&dentries, &index);
390	if (!hlp) {	419	if (!hlp) {
391	ipc_answer_0(rid, ENOENT);	420	ipc_answer_0(rid, ENOENT);
392	return;	421	return;
393	}	422	}
394	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,	423	tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
395	dh_link);	424	dh_link);
396		425
397	if (size == dentry->size) {	426	if (size == dentry->size) {
398	ipc_answer_0(rid, EOK);	427	ipc_answer_0(rid, EOK);
399	return;	428	return;
400	}	429	}
401		430
402	void *newdata = realloc(dentry->data, size);	431	void *newdata = realloc(dentry->data, size);
403	if (!newdata) {	432	if (!newdata) {
404	ipc_answer_0(rid, ENOMEM);	433	ipc_answer_0(rid, ENOMEM);
405	return;	434	return;
406	}	435	}
407	if (size > dentry->size) {	436	if (size > dentry->size) {
408	size_t delta = size - dentry->size;	437	size_t delta = size - dentry->size;
409	memset(newdata + dentry->size, 0, delta);	438	memset(newdata + dentry->size, 0, delta);
410	}	439	}
411	dentry->size = size;	440	dentry->size = size;
412	dentry->data = newdata;	441	dentry->data = newdata;
413	ipc_answer_0(rid, EOK);	442	ipc_answer_0(rid, EOK);
414	}	443	}
415		444
416	/**	445	/**
417	* @}	446	* @}
418	*/	447	*/
419		448

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/fs/tmpfs/tmpfs_ops.c – Rev 2693 → 2699