Subversion Repositories HelenOS

Rev

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