Subversion Repositories HelenOS

Rev

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