Subversion Repositories HelenOS

Rev

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