Subversion Repositories HelenOS

Rev

Rev 3150 | Rev 3588 | 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>
2699 jermar 48
#include <assert.h>
2658 jermar 49
#include <sys/types.h>
50
#include <libadt/hash_table.h>
51
#include <as.h>
2747 jermar 52
#include <libfs.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
 
57
#define DENTRIES_BUCKETS    256
58
 
2760 jermar 59
#define NAMES_BUCKETS       4
60
 
2747 jermar 61
/*
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.
64
 */
65
static tmpfs_dentry_t *root;
2730 jermar 66
 
2747 jermar 67
/*
68
 * Implementation of the libfs interface.
69
 */
70
 
2742 jermar 71
/* Forward declarations of static functions. */
2791 jermar 72
static void *tmpfs_match(void *, const char *);
2863 jermar 73
static void *tmpfs_node_get(dev_handle_t, fs_index_t);
2852 jermar 74
static void tmpfs_node_put(void *);
2747 jermar 75
static void *tmpfs_create_node(int);
76
static bool tmpfs_link_node(void *, void *, const char *);
2758 jermar 77
static int tmpfs_unlink_node(void *, void *);
2858 jermar 78
static int tmpfs_destroy_node(void *);
2742 jermar 79
 
2747 jermar 80
/* Implementation of helper functions. */
2770 jermar 81
static fs_index_t tmpfs_index_get(void *nodep)
2747 jermar 82
{
83
    return ((tmpfs_dentry_t *) nodep)->index;
84
}
85
 
2770 jermar 86
static size_t tmpfs_size_get(void *nodep)
2747 jermar 87
{
88
    return ((tmpfs_dentry_t *) nodep)->size;
89
}
90
 
91
static unsigned tmpfs_lnkcnt_get(void *nodep)
92
{
2756 jermar 93
    return ((tmpfs_dentry_t *) nodep)->lnkcnt;
2747 jermar 94
}
95
 
2791 jermar 96
static bool tmpfs_has_children(void *nodep)
2747 jermar 97
{
2791 jermar 98
    return ((tmpfs_dentry_t *) nodep)->child != NULL;
2747 jermar 99
}
100
 
2844 jermar 101
static void *tmpfs_root_get(dev_handle_t dev_handle)
2747 jermar 102
{
103
    return root;
104
}
105
 
106
static char tmpfs_plb_get_char(unsigned pos)
107
{
108
    return tmpfs_reg.plb_ro[pos % PLB_SIZE];
109
}
110
 
111
static bool tmpfs_is_directory(void *nodep)
112
{
113
    return ((tmpfs_dentry_t *) nodep)->type == TMPFS_DIRECTORY;
114
}
115
 
116
static bool tmpfs_is_file(void *nodep)
117
{
118
    return ((tmpfs_dentry_t *) nodep)->type == TMPFS_FILE;
119
}
120
 
121
/** libfs operations */
122
libfs_ops_t tmpfs_libfs_ops = {
123
    .match = tmpfs_match,
2763 jermar 124
    .node_get = tmpfs_node_get,
2852 jermar 125
    .node_put = tmpfs_node_put,
2747 jermar 126
    .create = tmpfs_create_node,
127
    .destroy = tmpfs_destroy_node,
128
    .link = tmpfs_link_node,
129
    .unlink = tmpfs_unlink_node,
130
    .index_get = tmpfs_index_get,
131
    .size_get = tmpfs_size_get,
132
    .lnkcnt_get = tmpfs_lnkcnt_get,
2791 jermar 133
    .has_children = tmpfs_has_children,
2747 jermar 134
    .root_get = tmpfs_root_get,
135
    .plb_get_char = tmpfs_plb_get_char,
136
    .is_directory = tmpfs_is_directory,
137
    .is_file = tmpfs_is_file
138
};
139
 
2742 jermar 140
/** Hash table of all directory entries. */
2658 jermar 141
hash_table_t dentries;
142
 
2760 jermar 143
/* Implementation of hash table interface for the dentries hash table. */
2658 jermar 144
static hash_index_t dentries_hash(unsigned long *key)
145
{
146
    return *key % DENTRIES_BUCKETS;
147
}
148
 
149
static int dentries_compare(unsigned long *key, hash_count_t keys,
150
    link_t *item)
151
{
152
    tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
153
        dh_link);
154
    return dentry->index == *key;
155
}
156
 
157
static void dentries_remove_callback(link_t *item)
158
{
159
}
160
 
161
/** TMPFS dentries hash table operations. */
162
hash_table_operations_t dentries_ops = {
163
    .hash = dentries_hash,
164
    .compare = dentries_compare,
165
    .remove_callback = dentries_remove_callback
166
};
167
 
2770 jermar 168
fs_index_t tmpfs_next_index = 1;
2655 jermar 169
 
2760 jermar 170
typedef struct {
171
    char *name;
172
    tmpfs_dentry_t *parent;
173
    link_t link;
174
} tmpfs_name_t;
175
 
176
/* Implementation of hash table interface for the names hash table. */
177
static hash_index_t names_hash(unsigned long *key)
2655 jermar 178
{
2760 jermar 179
    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) *key;
180
    return dentry->index % NAMES_BUCKETS;
181
}
182
 
183
static int names_compare(unsigned long *key, hash_count_t keys, link_t *item)
184
{
185
    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) *key;
186
    tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
187
        link);
188
    return dentry == namep->parent;
189
}
190
 
191
static void names_remove_callback(link_t *item)
192
{
193
    tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
194
        link);
195
    free(namep->name);
196
    free(namep);
197
}
198
 
199
/** TMPFS node names hash table operations. */
200
static hash_table_operations_t names_ops = {
201
    .hash = names_hash,
202
    .compare = names_compare,
203
    .remove_callback = names_remove_callback
204
};
205
 
206
static void tmpfs_name_initialize(tmpfs_name_t *namep)
207
{
208
    namep->name = NULL;
209
    namep->parent = NULL;
210
    link_initialize(&namep->link);
211
}
212
 
213
static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
214
{
2655 jermar 215
    dentry->index = 0;
216
    dentry->sibling = NULL;
217
    dentry->child = NULL;
218
    dentry->type = TMPFS_NONE;
2756 jermar 219
    dentry->lnkcnt = 0;
2655 jermar 220
    dentry->size = 0;
221
    dentry->data = NULL;
2658 jermar 222
    link_initialize(&dentry->dh_link);
2760 jermar 223
    return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,
224
        &names_ops);
2655 jermar 225
}
226
 
227
static bool tmpfs_init(void)
228
{
2658 jermar 229
    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
230
        return false;
2747 jermar 231
    root = (tmpfs_dentry_t *) tmpfs_create_node(L_DIRECTORY);
2760 jermar 232
    if (!root) {
233
        hash_table_destroy(&dentries);
234
        return false;
235
    }
2757 jermar 236
    root->lnkcnt = 1;
2760 jermar 237
    return true;
2655 jermar 238
}
239
 
2645 jermar 240
/** Compare one component of path to a directory entry.
241
 *
2791 jermar 242
 * @param parentp   Pointer to node from which we descended.
243
 * @param childp    Pointer to node to compare the path component with.
2705 jermar 244
 * @param component Array of characters holding component name.
2645 jermar 245
 *
2705 jermar 246
 * @return      True on match, false otherwise.
2645 jermar 247
 */
2791 jermar 248
static bool
249
tmpfs_match_one(tmpfs_dentry_t *parentp, tmpfs_dentry_t *childp,
250
    const char *component)
2645 jermar 251
{
2760 jermar 252
    unsigned long key = (unsigned long) parentp;
253
    link_t *hlp = hash_table_find(&childp->names, &key);
254
    assert(hlp);
255
    tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);
256
    return !strcmp(namep->name, component);
2705 jermar 257
}
2655 jermar 258
 
2791 jermar 259
void *tmpfs_match(void *prnt, const char *component)
260
{
261
    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
262
    tmpfs_dentry_t *childp = parentp->child;
263
 
264
    while (childp && !tmpfs_match_one(parentp, childp, component))
265
        childp = childp->sibling;
266
 
267
    return (void *) childp;
268
}
269
 
2770 jermar 270
void *
2863 jermar 271
tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
2763 jermar 272
{
2770 jermar 273
    unsigned long key = index;
274
    link_t *lnk = hash_table_find(&dentries, &key);
2763 jermar 275
    if (!lnk)
276
        return NULL;
277
    return hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link);
278
}
279
 
2852 jermar 280
void tmpfs_node_put(void *node)
281
{
282
    /* nothing to do */
283
}
284
 
2747 jermar 285
void *tmpfs_create_node(int lflag)
2705 jermar 286
{
2707 jermar 287
    assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
288
 
289
    tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
290
    if (!node)
2730 jermar 291
        return NULL;
2707 jermar 292
 
2760 jermar 293
    if (!tmpfs_dentry_initialize(node)) {
294
        free(node);
295
        return NULL;
296
    }
2707 jermar 297
    node->index = tmpfs_next_index++;
298
    if (lflag & L_DIRECTORY)
299
        node->type = TMPFS_DIRECTORY;
300
    else
301
        node->type = TMPFS_FILE;
302
 
2742 jermar 303
    /* Insert the new node into the dentry hash table. */
2770 jermar 304
    unsigned long key = node->index;
305
    hash_table_insert(&dentries, &key, &node->dh_link);
2742 jermar 306
    return (void *) node;
307
}
308
 
2747 jermar 309
bool tmpfs_link_node(void *prnt, void *chld, const char *nm)
2742 jermar 310
{
311
    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
312
    tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld;
313
 
314
    assert(parentp->type == TMPFS_DIRECTORY);
315
 
2760 jermar 316
    tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
317
    if (!namep)
318
        return false;
319
    tmpfs_name_initialize(namep);
2742 jermar 320
    size_t len = strlen(nm);
2760 jermar 321
    namep->name = malloc(len + 1);
322
    if (!namep->name) {
323
        free(namep);
2742 jermar 324
        return false;
2760 jermar 325
    }
326
    strcpy(namep->name, nm);
327
    namep->parent = parentp;
2756 jermar 328
 
329
    childp->lnkcnt++;
2742 jermar 330
 
2760 jermar 331
    unsigned long key = (unsigned long) parentp;
332
    hash_table_insert(&childp->names, &key, &namep->link);
333
 
2707 jermar 334
    /* Insert the new node into the namespace. */
2742 jermar 335
    if (parentp->child) {
336
        tmpfs_dentry_t *tmp = parentp->child;
2707 jermar 337
        while (tmp->sibling)
338
            tmp = tmp->sibling;
2742 jermar 339
        tmp->sibling = childp;
2707 jermar 340
    } else {
2742 jermar 341
        parentp->child = childp;
2707 jermar 342
    }
343
 
2742 jermar 344
    return true;
2705 jermar 345
}
2655 jermar 346
 
2758 jermar 347
int tmpfs_unlink_node(void *prnt, void *chld)
2705 jermar 348
{
2758 jermar 349
    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *)prnt;
350
    tmpfs_dentry_t *childp = (tmpfs_dentry_t *)chld;
2733 jermar 351
 
2758 jermar 352
    if (!parentp)
353
        return EBUSY;
354
 
355
    if (childp->child)
2733 jermar 356
        return ENOTEMPTY;
357
 
2758 jermar 358
    if (parentp->child == childp) {
359
        parentp->child = childp->sibling;
2733 jermar 360
    } else {
361
        /* TODO: consider doubly linked list for organizing siblings. */
2758 jermar 362
        tmpfs_dentry_t *tmp = parentp->child;
363
        while (tmp->sibling != childp)
2733 jermar 364
            tmp = tmp->sibling;
2758 jermar 365
        tmp->sibling = childp->sibling;
2733 jermar 366
    }
2758 jermar 367
    childp->sibling = NULL;
2733 jermar 368
 
2760 jermar 369
    unsigned long key = (unsigned long) parentp;
370
    hash_table_remove(&childp->names, &key, 1);
2742 jermar 371
 
2758 jermar 372
    childp->lnkcnt--;
2756 jermar 373
 
2733 jermar 374
    return EOK;
2645 jermar 375
}
376
 
2858 jermar 377
int tmpfs_destroy_node(void *nodep)
2742 jermar 378
{
379
    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep;
380
 
2756 jermar 381
    assert(!dentry->lnkcnt);
2742 jermar 382
    assert(!dentry->child);
383
    assert(!dentry->sibling);
384
 
2770 jermar 385
    unsigned long key = dentry->index;
386
    hash_table_remove(&dentries, &key, 1);
2742 jermar 387
 
2760 jermar 388
    hash_table_destroy(&dentry->names);
389
 
2742 jermar 390
    if (dentry->type == TMPFS_FILE)
391
        free(dentry->data);
392
    free(dentry);
2858 jermar 393
    return EOK;
2742 jermar 394
}
395
 
3153 svoboda 396
void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
397
{
398
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
399
 
400
    /* Initialize TMPFS. */
401
    if (!root && !tmpfs_init()) {
402
        ipc_answer_0(rid, ENOMEM);
403
        return;
404
    }
405
 
406
    if (dev_handle >= 0) {
407
        if (tmpfs_restore(dev_handle))
408
            ipc_answer_0(rid, EOK);
409
        else
410
            ipc_answer_0(rid, ELIMIT);
411
    } else {
412
            ipc_answer_0(rid, EOK);
413
    }
414
}
415
 
3009 svoboda 416
void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request)
417
{
3153 svoboda 418
    dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
419
    fs_index_t mp_index = (fs_index_t) IPC_GET_ARG2(*request);
420
    fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);
421
    dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);
3150 svoboda 422
 
3153 svoboda 423
    ipc_answer_0(rid, ENOTSUP);
3009 svoboda 424
}
425
 
2645 jermar 426
void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
427
{
2747 jermar 428
    libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
2645 jermar 429
}
430
 
2658 jermar 431
void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
432
{
2770 jermar 433
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
434
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
435
    off_t pos = (off_t)IPC_GET_ARG3(*request);
2658 jermar 436
 
437
    /*
438
     * Lookup the respective dentry.
439
     */
440
    link_t *hlp;
2770 jermar 441
    unsigned long key = index;
442
    hlp = hash_table_find(&dentries, &key);
2658 jermar 443
    if (!hlp) {
444
        ipc_answer_0(rid, ENOENT);
445
        return;
446
    }
447
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
448
        dh_link);
449
 
450
    /*
2663 jermar 451
     * Receive the read request.
2658 jermar 452
     */
453
    ipc_callid_t callid;
2673 jermar 454
    size_t len;
455
    if (!ipc_data_read_receive(&callid, &len)) {
2658 jermar 456
        ipc_answer_0(callid, EINVAL);  
457
        ipc_answer_0(rid, EINVAL);
458
        return;
459
    }
460
 
2699 jermar 461
    size_t bytes;
462
    if (dentry->type == TMPFS_FILE) {
463
        bytes = max(0, min(dentry->size - pos, len));
464
        (void) ipc_data_read_finalize(callid, dentry->data + pos,
465
            bytes);
466
    } else {
467
        int i;
2739 jermar 468
        tmpfs_dentry_t *cur;
2699 jermar 469
 
470
        assert(dentry->type == TMPFS_DIRECTORY);
471
 
472
        /*
473
         * Yes, we really use O(n) algorithm here.
474
         * If it bothers someone, it could be fixed by introducing a
475
         * hash table.
476
         */
477
        for (i = 0, cur = dentry->child; i < pos && cur; i++,
478
            cur = cur->sibling)
479
            ;
2664 jermar 480
 
2699 jermar 481
        if (!cur) {
482
            ipc_answer_0(callid, ENOENT);
483
            ipc_answer_1(rid, ENOENT, 0);
484
            return;
485
        }
486
 
2760 jermar 487
        unsigned long key = (unsigned long) dentry;
488
        link_t *hlp = hash_table_find(&cur->names, &key);
489
        assert(hlp);
490
        tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t,
491
            link);
492
 
493
        (void) ipc_data_read_finalize(callid, namep->name,
494
            strlen(namep->name) + 1);
2699 jermar 495
        bytes = 1;
496
    }
497
 
2664 jermar 498
    /*
499
     * Answer the VFS_READ call.
500
     */
501
    ipc_answer_1(rid, EOK, bytes);
2658 jermar 502
}
503
 
2666 jermar 504
void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
505
{
2770 jermar 506
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
507
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
508
    off_t pos = (off_t)IPC_GET_ARG3(*request);
2666 jermar 509
 
510
    /*
511
     * Lookup the respective dentry.
512
     */
513
    link_t *hlp;
2770 jermar 514
    unsigned long key = index;
515
    hlp = hash_table_find(&dentries, &key);
2666 jermar 516
    if (!hlp) {
517
        ipc_answer_0(rid, ENOENT);
518
        return;
519
    }
520
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
521
        dh_link);
522
 
523
    /*
524
     * Receive the write request.
525
     */
526
    ipc_callid_t callid;
2673 jermar 527
    size_t len;
2676 jermar 528
    if (!ipc_data_write_receive(&callid, &len)) {
2666 jermar 529
        ipc_answer_0(callid, EINVAL);  
530
        ipc_answer_0(rid, EINVAL);
531
        return;
532
    }
533
 
534
    /*
2667 jermar 535
     * Check whether the file needs to grow.
536
     */
2673 jermar 537
    if (pos + len <= dentry->size) {
2667 jermar 538
        /* The file size is not changing. */
2678 jermar 539
        (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
2710 jermar 540
        ipc_answer_2(rid, EOK, len, dentry->size);
2667 jermar 541
        return;
542
    }
2673 jermar 543
    size_t delta = (pos + len) - dentry->size;
2667 jermar 544
    /*
2666 jermar 545
     * At this point, we are deliberately extremely straightforward and
2667 jermar 546
     * simply realloc the contents of the file on every write that grows the
547
     * file. In the end, the situation might not be as bad as it may look:
548
     * our heap allocator can save us and just grow the block whenever
549
     * possible.
2666 jermar 550
     */
2667 jermar 551
    void *newdata = realloc(dentry->data, dentry->size + delta);
2666 jermar 552
    if (!newdata) {
553
        ipc_answer_0(callid, ENOMEM);
2710 jermar 554
        ipc_answer_2(rid, EOK, 0, dentry->size);
2666 jermar 555
        return;
556
    }
2693 jermar 557
    /* Clear any newly allocated memory in order to emulate gaps. */
2686 jermar 558
    memset(newdata + dentry->size, 0, delta);
2667 jermar 559
    dentry->size += delta;
2666 jermar 560
    dentry->data = newdata;
2678 jermar 561
    (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
2687 jermar 562
    ipc_answer_2(rid, EOK, len, dentry->size);
2666 jermar 563
}
564
 
2693 jermar 565
void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
566
{
2770 jermar 567
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
568
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
569
    size_t size = (off_t)IPC_GET_ARG3(*request);
2693 jermar 570
 
571
    /*
572
     * Lookup the respective dentry.
573
     */
574
    link_t *hlp;
2770 jermar 575
    unsigned long key = index;
576
    hlp = hash_table_find(&dentries, &key);
2693 jermar 577
    if (!hlp) {
578
        ipc_answer_0(rid, ENOENT);
579
        return;
580
    }
581
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
582
        dh_link);
583
 
584
    if (size == dentry->size) {
585
        ipc_answer_0(rid, EOK);
586
        return;
587
    }
588
 
589
    void *newdata = realloc(dentry->data, size);
590
    if (!newdata) {
591
        ipc_answer_0(rid, ENOMEM);
592
        return;
593
    }
594
    if (size > dentry->size) {
595
        size_t delta = size - dentry->size;
596
        memset(newdata + dentry->size, 0, delta);
597
    }
598
    dentry->size = size;
599
    dentry->data = newdata;
600
    ipc_answer_0(rid, EOK);
601
}
602
 
2742 jermar 603
void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
2731 jermar 604
{
2770 jermar 605
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
606
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
2858 jermar 607
    int rc;
2731 jermar 608
 
609
    link_t *hlp;
2770 jermar 610
    unsigned long key = index;
611
    hlp = hash_table_find(&dentries, &key);
2731 jermar 612
    if (!hlp) {
613
        ipc_answer_0(rid, ENOENT);
614
        return;
615
    }
616
    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
617
        dh_link);
2858 jermar 618
    rc = tmpfs_destroy_node(dentry);
619
    ipc_answer_0(rid, rc);
2731 jermar 620
}
621
 
2645 jermar 622
/**
623
 * @}
624
 */