Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
2645 jermar 1
/*
2685 jermar 2
 * Copyright (c) 2008 Jakub Jermar
2645 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>
2705 jermar 48
#include <dirent.h>
2699 jermar 49
#include <assert.h>
2658 jermar 50
#include <sys/types.h>
51
#include <libadt/hash_table.h>
52
#include <as.h>
2645 jermar 53
 
2658 jermar 54
#define min(a, b)       ((a) < (b) ? (a) : (b))
55
#define max(a, b)       ((a) > (b) ? (a) : (b))
56
 
2645 jermar 57
#define PLB_GET_CHAR(i)     (tmpfs_reg.plb_ro[(i) % PLB_SIZE])
58
 
2658 jermar 59
#define DENTRIES_BUCKETS    256
60
 
2730 jermar 61
#define TMPFS_GET_INDEX(x)  (((tmpfs_dentry_t *)(x))->index)
62
#define TMPFS_GET_LNKCNT(x) 1
63
 
2658 jermar 64
/*
65
 * Hash table of all directory entries.
66
 */
67
hash_table_t dentries;
68
 
69
static hash_index_t dentries_hash(unsigned long *key)
70
{
71
    return *key % DENTRIES_BUCKETS;
72
}
73
 
74
static int dentries_compare(unsigned long *key, hash_count_t keys,
75
    link_t *item)
76
{
77
    tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
78
        dh_link);
79
    return dentry->index == *key;
80
}
81
 
82
static void dentries_remove_callback(link_t *item)
83
{
84
}
85
 
86
/** TMPFS dentries hash table operations. */
87
hash_table_operations_t dentries_ops = {
88
    .hash = dentries_hash,
89
    .compare = dentries_compare,
90
    .remove_callback = dentries_remove_callback
91
};
92
 
2655 jermar 93
unsigned tmpfs_next_index = 1;
94
 
95
static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
96
{
97
    dentry->index = 0;
98
    dentry->parent = NULL;
99
    dentry->sibling = NULL;
100
    dentry->child = NULL;
101
    dentry->name = NULL;
102
    dentry->type = TMPFS_NONE;
103
    dentry->size = 0;
104
    dentry->data = NULL;
2658 jermar 105
    link_initialize(&dentry->dh_link);
2655 jermar 106
}
107
 
108
/*
109
 * For now, we don't distinguish between different dev_handles/instances. All
110
 * requests resolve to the only instance, rooted in the following variable.
111
 */
112
static tmpfs_dentry_t *root;
113
 
114
static bool tmpfs_init(void)
115
{
2658 jermar 116
    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
117
        return false;
118
 
2655 jermar 119
    root = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
2658 jermar 120
    if (!root)
2655 jermar 121
        return false;
122
    tmpfs_dentry_initialize(root);
123
    root->index = tmpfs_next_index++;
124
    root->name = "";
125
    root->type = TMPFS_DIRECTORY;
2658 jermar 126
    hash_table_insert(&dentries, &root->index, &root->dh_link);
2655 jermar 127
 
128
    return true;
129
}
130
 
2645 jermar 131
/** Compare one component of path to a directory entry.
132
 *
2730 jermar 133
 * @param nodep     Node to compare the path component with.
2705 jermar 134
 * @param component Array of characters holding component name.
2645 jermar 135
 *
2705 jermar 136
 * @return      True on match, false otherwise.
2645 jermar 137
 */
2730 jermar 138
static bool match_component(void *nodep, const char *component)
2645 jermar 139
{
2730 jermar 140
    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep;
141
 
2705 jermar 142
    return !strcmp(dentry->name, component);
143
}
2655 jermar 144
 
2730 jermar 145
static void *create_node(void *nodep,
2705 jermar 146
    const char *component, int lflag)
147
{
2730 jermar 148
    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep;
149
 
2707 jermar 150
    assert(dentry->type == TMPFS_DIRECTORY);
151
    assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
152
 
153
    tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
154
    if (!node)
2730 jermar 155
        return NULL;
2707 jermar 156
    size_t len = strlen(component);
157
    char *name = malloc(len + 1);
158
    if (!name) {
159
        free(node);
2730 jermar 160
        return NULL;
2707 jermar 161
    }
162
    strcpy(name, component);
163
 
164
    tmpfs_dentry_initialize(node);
165
    node->index = tmpfs_next_index++;
166
    node->name = name;
167
    node->parent = dentry;
168
    if (lflag & L_DIRECTORY)
169
        node->type = TMPFS_DIRECTORY;
170
    else
171
        node->type = TMPFS_FILE;
172
 
173
    /* Insert the new node into the namespace. */
174
    if (dentry->child) {
175
        tmpfs_dentry_t *tmp = dentry->child;
176
        while (tmp->sibling)
177
            tmp = tmp->sibling;
178
        tmp->sibling = node;
179
    } else {
180
        dentry->child = node;
181
    }
182
 
183
    /* Insert the new node into the dentry hash table. */
184
    hash_table_insert(&dentries, &node->index, &node->dh_link);
2730 jermar 185
    return (void *) node;
2705 jermar 186
}
2655 jermar 187
 
2730 jermar 188
static int destroy_component(void *nodeptr)
2705 jermar 189
{
190
    return EPERM;
2645 jermar 191
}
192
 
193
void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
194
{
2655 jermar 195
    unsigned next = IPC_GET_ARG1(*request);
196
    unsigned last = IPC_GET_ARG2(*request);
2645 jermar 197
    int dev_handle = IPC_GET_ARG3(*request);
2700 jermar 198
    int lflag = IPC_GET_ARG4(*request);
2645 jermar 199
 
2655 jermar 200
    if (last < next)
201
        last += PLB_SIZE;
202
 
2705 jermar 203
    /*
204
     * Initialize TMPFS.
205
     */
2655 jermar 206
    if (!root && !tmpfs_init()) {
207
        ipc_answer_0(rid, ENOMEM);
208
        return;
209
    }
210
 
211
    tmpfs_dentry_t *dtmp = root->child;
212
    tmpfs_dentry_t *dcur = root;
213
 
214
    if (PLB_GET_CHAR(next) == '/')
215
        next++;     /* eat slash */
216
 
2705 jermar 217
    char component[NAME_MAX + 1];
218
    int len = 0;
2706 jermar 219
    while (dtmp && next <= last) {
2705 jermar 220
 
221
        /* collect the component */
222
        if (PLB_GET_CHAR(next) != '/') {
223
            if (len + 1 == NAME_MAX) {
224
                /* comopnent length overflow */
225
                ipc_answer_0(rid, ENAMETOOLONG);
226
                return;
227
            }
228
            component[len++] = PLB_GET_CHAR(next);
229
            next++; /* process next character */
2707 jermar 230
            if (next <= last)
2705 jermar 231
                continue;
232
        }
233
 
234
        assert(len);
235
        component[len] = '\0';
236
        next++;     /* eat slash */
237
        len = 0;
238
 
239
        /* match the component */
240
        while (dtmp && !match_component(dtmp, component))
241
            dtmp = dtmp->sibling;
242
 
243
        /* handle miss: match amongst siblings */
244
        if (!dtmp) {
245
            if ((next > last) && (lflag & L_CREATE)) {
246
                /* no components left and L_CREATE specified */
247
                if (dcur->type != TMPFS_DIRECTORY) {
248
                    ipc_answer_0(rid, ENOTDIR);
249
                    return;
250
                }
2730 jermar 251
                void *nodep = create_node(dcur,
2705 jermar 252
                    component, lflag);
2730 jermar 253
                if (nodep) {
254
                    ipc_answer_5(rid, EOK,
2705 jermar 255
                        tmpfs_reg.fs_handle, dev_handle,
2730 jermar 256
                        TMPFS_GET_INDEX(nodep), 0,
257
                        TMPFS_GET_LNKCNT(nodep));
2705 jermar 258
                } else {
259
                    ipc_answer_0(rid, ENOSPC);
260
                }
261
                return;
262
            }
263
            ipc_answer_0(rid, ENOENT);
2655 jermar 264
            return;
265
        }
2705 jermar 266
 
2728 jermar 267
        /* descend one level */
2705 jermar 268
        dcur = dtmp;
269
        dtmp = dtmp->child;
2706 jermar 270
    }
2705 jermar 271
 
2706 jermar 272
    /* handle miss: excessive components */
273
    if (!dtmp && next <= last) {
274
        if (lflag & L_CREATE) {
275
            if (dcur->type != TMPFS_DIRECTORY) {
276
                ipc_answer_0(rid, ENOTDIR);
277
                return;
278
            }
279
 
280
            /* collect next component */
281
            while (next <= last) {
282
                if (PLB_GET_CHAR(next) == '/') {
283
                    /* more than one component */
284
                    ipc_answer_0(rid, ENOENT);
2705 jermar 285
                    return;
286
                }
2706 jermar 287
                if (len + 1 == NAME_MAX) {
288
                    /* component length overflow */
289
                    ipc_answer_0(rid, ENAMETOOLONG);
290
                    return;
2705 jermar 291
                }
2706 jermar 292
                component[len++] = PLB_GET_CHAR(next);
293
                next++; /* process next character */
294
            }
295
            assert(len);
296
            component[len] = '\0';
297
            len = 0;
2705 jermar 298
 
2730 jermar 299
            void *nodep = create_node(dcur, component, lflag);
300
            if (nodep) {
301
                ipc_answer_5(rid, EOK, tmpfs_reg.fs_handle,
302
                    dev_handle, TMPFS_GET_INDEX(nodep), 0,
303
                    TMPFS_GET_LNKCNT(nodep));
2706 jermar 304
            } else {
305
                ipc_answer_0(rid, ENOSPC);
2705 jermar 306
            }
307
            return;
308
        }
2706 jermar 309
        ipc_answer_0(rid, ENOENT);
310
        return;
2655 jermar 311
    }
312
 
2705 jermar 313
    /* handle hit */
314
    if (lflag & L_DESTROY) {
315
        int res = destroy_component(dcur);
316
        ipc_answer_0(rid, res);
317
        return;
318
    }
319
    if ((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) {
320
        ipc_answer_0(rid, EEXIST);
321
        return;
322
    }
323
    if ((lflag & L_FILE) && (dcur->type != TMPFS_FILE)) {
324
        ipc_answer_0(rid, EISDIR);
325
        return;
326
    }
327
    if ((lflag & L_DIRECTORY) && (dcur->type != TMPFS_DIRECTORY)) {
328
        ipc_answer_0(rid, ENOTDIR);
329
        return;
330
    }
331
 
2730 jermar 332
    ipc_answer_5(rid, EOK, tmpfs_reg.fs_handle, dev_handle, dcur->index,
333
        dcur->size, TMPFS_GET_LNKCNT(dcur));
2645 jermar 334
}
335
 
2658 jermar 336
void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
337
{
338
    int dev_handle = IPC_GET_ARG1(*request);
339
    unsigned long index = IPC_GET_ARG2(*request);
340
    off_t pos = IPC_GET_ARG3(*request);
341
 
342
    /*
343
     * Lookup the respective dentry.
344
     */
345
    link_t *hlp;
346
    hlp = hash_table_find(&dentries, &index);
347
    if (!hlp) {
348
        ipc_answer_0(rid, ENOENT);
349
        return;
350
    }
351
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
352
        dh_link);
353
 
354
    /*
2663 jermar 355
     * Receive the read request.
2658 jermar 356
     */
357
    ipc_callid_t callid;
2673 jermar 358
    size_t len;
359
    if (!ipc_data_read_receive(&callid, &len)) {
2658 jermar 360
        ipc_answer_0(callid, EINVAL);  
361
        ipc_answer_0(rid, EINVAL);
362
        return;
363
    }
364
 
2699 jermar 365
    size_t bytes;
366
    if (dentry->type == TMPFS_FILE) {
367
        bytes = max(0, min(dentry->size - pos, len));
368
        (void) ipc_data_read_finalize(callid, dentry->data + pos,
369
            bytes);
370
    } else {
371
        int i;
372
        tmpfs_dentry_t *cur = dentry->child;
373
 
374
        assert(dentry->type == TMPFS_DIRECTORY);
375
 
376
        /*
377
         * Yes, we really use O(n) algorithm here.
378
         * If it bothers someone, it could be fixed by introducing a
379
         * hash table.
380
         */
381
        for (i = 0, cur = dentry->child; i < pos && cur; i++,
382
            cur = cur->sibling)
383
            ;
2664 jermar 384
 
2699 jermar 385
        if (!cur) {
386
            ipc_answer_0(callid, ENOENT);
387
            ipc_answer_1(rid, ENOENT, 0);
388
            return;
389
        }
390
 
391
        (void) ipc_data_read_finalize(callid, cur->name,
392
            strlen(cur->name) + 1);
393
        bytes = 1;
394
    }
395
 
2664 jermar 396
    /*
397
     * Answer the VFS_READ call.
398
     */
399
    ipc_answer_1(rid, EOK, bytes);
2658 jermar 400
}
401
 
2666 jermar 402
void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
403
{
404
    int dev_handle = IPC_GET_ARG1(*request);
405
    unsigned long index = IPC_GET_ARG2(*request);
406
    off_t pos = IPC_GET_ARG3(*request);
407
 
408
    /*
409
     * Lookup the respective dentry.
410
     */
411
    link_t *hlp;
412
    hlp = hash_table_find(&dentries, &index);
413
    if (!hlp) {
414
        ipc_answer_0(rid, ENOENT);
415
        return;
416
    }
417
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
418
        dh_link);
419
 
420
    /*
421
     * Receive the write request.
422
     */
423
    ipc_callid_t callid;
2673 jermar 424
    size_t len;
2676 jermar 425
    if (!ipc_data_write_receive(&callid, &len)) {
2666 jermar 426
        ipc_answer_0(callid, EINVAL);  
427
        ipc_answer_0(rid, EINVAL);
428
        return;
429
    }
430
 
431
    /*
2667 jermar 432
     * Check whether the file needs to grow.
433
     */
2673 jermar 434
    if (pos + len <= dentry->size) {
2667 jermar 435
        /* The file size is not changing. */
2678 jermar 436
        (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
2710 jermar 437
        ipc_answer_2(rid, EOK, len, dentry->size);
2667 jermar 438
        return;
439
    }
2673 jermar 440
    size_t delta = (pos + len) - dentry->size;
2667 jermar 441
    /*
2666 jermar 442
     * At this point, we are deliberately extremely straightforward and
2667 jermar 443
     * simply realloc the contents of the file on every write that grows the
444
     * file. In the end, the situation might not be as bad as it may look:
445
     * our heap allocator can save us and just grow the block whenever
446
     * possible.
2666 jermar 447
     */
2667 jermar 448
    void *newdata = realloc(dentry->data, dentry->size + delta);
2666 jermar 449
    if (!newdata) {
450
        ipc_answer_0(callid, ENOMEM);
2710 jermar 451
        ipc_answer_2(rid, EOK, 0, dentry->size);
2666 jermar 452
        return;
453
    }
2693 jermar 454
    /* Clear any newly allocated memory in order to emulate gaps. */
2686 jermar 455
    memset(newdata + dentry->size, 0, delta);
2667 jermar 456
    dentry->size += delta;
2666 jermar 457
    dentry->data = newdata;
2678 jermar 458
    (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
2687 jermar 459
    ipc_answer_2(rid, EOK, len, dentry->size);
2666 jermar 460
}
461
 
2693 jermar 462
void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
463
{
464
    int dev_handle = IPC_GET_ARG1(*request);
465
    unsigned long index = IPC_GET_ARG2(*request);
466
    size_t size = IPC_GET_ARG3(*request);
467
 
468
    /*
469
     * Lookup the respective dentry.
470
     */
471
    link_t *hlp;
472
    hlp = hash_table_find(&dentries, &index);
473
    if (!hlp) {
474
        ipc_answer_0(rid, ENOENT);
475
        return;
476
    }
477
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
478
        dh_link);
479
 
480
    if (size == dentry->size) {
481
        ipc_answer_0(rid, EOK);
482
        return;
483
    }
484
 
485
    void *newdata = realloc(dentry->data, size);
486
    if (!newdata) {
487
        ipc_answer_0(rid, ENOMEM);
488
        return;
489
    }
490
    if (size > dentry->size) {
491
        size_t delta = size - dentry->size;
492
        memset(newdata + dentry->size, 0, delta);
493
    }
494
    dentry->size = size;
495
    dentry->data = newdata;
496
    ipc_answer_0(rid, EOK);
497
}
498
 
2731 jermar 499
void tmpfs_free(ipc_callid_t rid, ipc_call_t *request)
500
{
501
    int dev_handle = IPC_GET_ARG1(*request);
502
    unsigned long index = IPC_GET_ARG2(*request);
503
 
504
    link_t *hlp;
505
    hlp = hash_table_find(&dentries, &index);
506
    if (!hlp) {
507
        ipc_answer_0(rid, ENOENT);
508
        return;
509
    }
510
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
511
        dh_link);
512
 
513
    assert(!dentry->parent);
514
    assert(!dentry->child);
515
    assert(!dentry->sibling);
516
 
517
    if (dentry->type == TMPFS_FILE)
518
        free(dentry->data);
519
    free(dentry->name);
520
    free(dentry);
521
 
522
    ipc_answer_0(rid, EOK);
523
}
524
 
2645 jermar 525
/**
526
 * @}
527
 */