Subversion Repositories HelenOS

Rev

Rev 2663 | Rev 2666 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2645 jermar 1
/*
2
 * Copyright (c) 2007 Jakub Jermar
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
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
15
 *   derived from this software without specific prior written permission.
16
 *
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
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
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
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
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup fs
30
 * @{
31
 */
32
 
33
/**
34
 * @file    tmpfs_ops.c
35
 * @brief   Implementation of VFS operations for the TMPFS file system
36
 *      server.
37
 */
38
 
39
#include "tmpfs.h"
40
#include "../../vfs/vfs.h"
41
#include <ipc/ipc.h>
42
#include <async.h>
43
#include <errno.h>
2655 jermar 44
#include <atomic.h>
45
#include <stdlib.h>
46
#include <string.h>
47
#include <stdio.h>
2658 jermar 48
#include <sys/types.h>
49
#include <libadt/hash_table.h>
50
#include <as.h>
2645 jermar 51
 
2658 jermar 52
#define min(a, b)       ((a) < (b) ? (a) : (b))
53
#define max(a, b)       ((a) > (b) ? (a) : (b))
54
 
2645 jermar 55
#define PLB_GET_CHAR(i)     (tmpfs_reg.plb_ro[(i) % PLB_SIZE])
56
 
2658 jermar 57
#define DENTRIES_BUCKETS    256
58
 
59
/*
60
 * Hash table of all directory entries.
61
 */
62
hash_table_t dentries;
63
 
64
static hash_index_t dentries_hash(unsigned long *key)
65
{
66
    return *key % DENTRIES_BUCKETS;
67
}
68
 
69
static int dentries_compare(unsigned long *key, hash_count_t keys,
70
    link_t *item)
71
{
72
    tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
73
        dh_link);
74
    return dentry->index == *key;
75
}
76
 
77
static void dentries_remove_callback(link_t *item)
78
{
79
}
80
 
81
/** TMPFS dentries hash table operations. */
82
hash_table_operations_t dentries_ops = {
83
    .hash = dentries_hash,
84
    .compare = dentries_compare,
85
    .remove_callback = dentries_remove_callback
86
};
87
 
2655 jermar 88
unsigned tmpfs_next_index = 1;
89
 
90
static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
91
{
92
    dentry->index = 0;
93
    dentry->parent = NULL;
94
    dentry->sibling = NULL;
95
    dentry->child = NULL;
96
    dentry->name = NULL;
97
    dentry->type = TMPFS_NONE;
98
    dentry->size = 0;
99
    dentry->data = NULL;
2658 jermar 100
    link_initialize(&dentry->dh_link);
2655 jermar 101
}
102
 
103
/*
104
 * 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
 */
107
static tmpfs_dentry_t *root;
108
 
109
static bool tmpfs_init(void)
110
{
2658 jermar 111
    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
112
        return false;
113
 
2655 jermar 114
    root = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
2658 jermar 115
    if (!root)
2655 jermar 116
        return false;
117
    tmpfs_dentry_initialize(root);
118
    root->index = tmpfs_next_index++;
119
    root->name = "";
120
    root->type = TMPFS_DIRECTORY;
2658 jermar 121
    hash_table_insert(&dentries, &root->index, &root->dh_link);
2655 jermar 122
 
123
    /*
124
     * This is only for debugging. Once we can create files and directories
125
     * using VFS, we can get rid of this.
126
     */
127
    tmpfs_dentry_t *d;
128
    d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
129
    if (!d) {
130
        free(root);
131
        root = NULL;
132
        return false;
133
    }
134
    tmpfs_dentry_initialize(d);
135
    d->index = tmpfs_next_index++;
136
    root->child = d;
137
    d->parent = root;
138
    d->type = TMPFS_DIRECTORY;
139
    d->name = "dir1";
2658 jermar 140
    hash_table_insert(&dentries, &d->index, &d->dh_link);
2655 jermar 141
 
142
    d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
143
    if (!d) {
144
        free(root->child);
145
        free(root);
146
        root = NULL;
147
        return false;
148
    }
149
    tmpfs_dentry_initialize(d);
150
    d->index = tmpfs_next_index++;
151
    root->child->sibling = d;
152
    d->parent = root;
153
    d->type = TMPFS_DIRECTORY;
154
    d->name = "dir2";
2658 jermar 155
    hash_table_insert(&dentries, &d->index, &d->dh_link);
2655 jermar 156
 
157
    d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
158
    if (!d) {
159
        free(root->child->sibling);
160
        free(root->child);
161
        free(root);
162
        root = NULL;
163
        return false;
164
    }
165
    tmpfs_dentry_initialize(d);
166
    d->index = tmpfs_next_index++;
167
    root->child->child = d;
168
    d->parent = root->child;
169
    d->type = TMPFS_FILE;
170
    d->name = "file1";
171
    d->data = "This is the contents of /dir1/file1.\n";
172
    d->size = strlen(d->data);
2658 jermar 173
    hash_table_insert(&dentries, &d->index, &d->dh_link);
2655 jermar 174
 
175
    d = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
176
    if (!d) {
177
        free(root->child->sibling);
178
        free(root->child->child);
179
        free(root->child);
180
        free(root);
181
        root = NULL;
182
        return false;
183
    }
184
    tmpfs_dentry_initialize(d);
185
    d->index = tmpfs_next_index++;
186
    root->child->sibling->child = d;
187
    d->parent = root->child->sibling;
188
    d->type = TMPFS_FILE;
189
    d->name = "file2";
190
    d->data = "This is the contents of /dir2/file2.\n";
191
    d->size = strlen(d->data);
2658 jermar 192
    hash_table_insert(&dentries, &d->index, &d->dh_link);
2655 jermar 193
 
194
    return true;
195
}
196
 
2645 jermar 197
/** Compare one component of path to a directory entry.
198
 *
199
 * @param dentry    Directory entry to compare the path component with.
200
 * @param start     Index into PLB where the path component starts.
201
 * @param last      Index of the last character of the path in PLB.
202
 *
203
 * @return      Zero on failure or delta such that (index + delta) %
2655 jermar 204
 *          PLB_SIZE points to the first unprocessed character in
205
 *          PLB which comprises the path.
2645 jermar 206
 */
207
static unsigned match_path_component(tmpfs_dentry_t *dentry, unsigned start,
208
    unsigned last)
209
{
2655 jermar 210
    int i, j;
211
    size_t namelen;
212
 
213
    namelen = strlen(dentry->name);
214
 
215
    if (last < start)
216
        last += PLB_SIZE;
217
 
218
    for (i = 0, j = start; i < namelen && j <= last; i++, j++) {
219
        if (dentry->name[i] != PLB_GET_CHAR(j))
220
            return 0;
221
    }
222
 
223
    if (i != namelen)
224
        return 0;
225
    if (j < last && PLB_GET_CHAR(j) != '/')
226
        return 0;
227
    if (j == last)
228
            return 0;
229
 
230
    return (j - start);
2645 jermar 231
}
232
 
233
void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
234
{
2655 jermar 235
    unsigned next = IPC_GET_ARG1(*request);
236
    unsigned last = IPC_GET_ARG2(*request);
2645 jermar 237
    int dev_handle = IPC_GET_ARG3(*request);
238
 
2655 jermar 239
    if (last < next)
240
        last += PLB_SIZE;
241
 
242
    if (!root && !tmpfs_init()) {
243
        ipc_answer_0(rid, ENOMEM);
244
        return;
245
    }
246
 
247
    tmpfs_dentry_t *dtmp = root->child;
248
    tmpfs_dentry_t *dcur = root;
249
 
250
    bool hit = true;
2645 jermar 251
 
2655 jermar 252
    if (PLB_GET_CHAR(next) == '/')
253
        next++;     /* eat slash */
254
 
255
    while (next <= last) {
256
        unsigned delta;
257
        hit = false;
258
        do {
259
            delta = match_path_component(dtmp, next, last);
260
            if (!delta) {
261
                dtmp = dtmp->sibling;
262
            } else {
263
                hit = true;
264
                next += delta;
265
                next++;     /* eat slash */
266
                dcur = dtmp;
267
                dtmp = dtmp->child;
268
            }  
269
        } while (delta == 0 && dtmp);
270
        if (!hit) {
271
            ipc_answer_3(rid, ENOENT, tmpfs_reg.fs_handle,
272
                dev_handle, dcur->index);
273
            return;
274
        }
275
    }
276
 
277
    ipc_answer_3(rid, EOK, tmpfs_reg.fs_handle, dev_handle, dcur->index);
2645 jermar 278
}
279
 
2658 jermar 280
void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
281
{
282
    int dev_handle = IPC_GET_ARG1(*request);
283
    unsigned long index = IPC_GET_ARG2(*request);
284
    off_t pos = IPC_GET_ARG3(*request);
285
 
286
    /*
287
     * Lookup the respective dentry.
288
     */
289
    link_t *hlp;
290
    hlp = hash_table_find(&dentries, &index);
291
    if (!hlp) {
292
        ipc_answer_0(rid, ENOENT);
293
        return;
294
    }
295
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
296
        dh_link);
297
 
298
    /*
2663 jermar 299
     * Receive the read request.
2658 jermar 300
     */
301
    ipc_callid_t callid;
2663 jermar 302
    size_t size;
2664 jermar 303
    if (!ipc_data_read_receive(&callid, &size)) {
2658 jermar 304
        ipc_answer_0(callid, EINVAL);  
305
        ipc_answer_0(rid, EINVAL);
306
        return;
307
    }
308
 
309
    size_t bytes = max(0, min(dentry->size - pos, size));
2663 jermar 310
    (void) ipc_data_read_deliver(callid, dentry->data + pos, bytes);
2664 jermar 311
 
312
    /*
313
     * Answer the VFS_READ call.
314
     */
315
    ipc_answer_1(rid, EOK, bytes);
2658 jermar 316
}
317
 
2645 jermar 318
/**
319
 * @}
320
 */