Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
2689 jermar 1
/*
2
 * Copyright (c) 2008 Jakub 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
 * @{
4153 mejdrech 31
 */
2689 jermar 32
 
33
/**
4153 mejdrech 34
 * @file vfs_ops.c
35
 * @brief Operations that VFS offers to its clients.
2689 jermar 36
 */
37
 
2763 jermar 38
#include "vfs.h"
2689 jermar 39
#include <ipc/ipc.h>
40
#include <async.h>
41
#include <errno.h>
42
#include <stdio.h>
43
#include <stdlib.h>
44
#include <string.h>
45
#include <bool.h>
46
#include <futex.h>
47
#include <rwlock.h>
48
#include <libadt/list.h>
49
#include <unistd.h>
50
#include <ctype.h>
2708 jermar 51
#include <fcntl.h>
2689 jermar 52
#include <assert.h>
2763 jermar 53
#include <vfs/canonify.h>
2689 jermar 54
 
2748 jermar 55
/* Forward declarations of static functions. */
2770 jermar 56
static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, size_t);
2748 jermar 57
 
4153 mejdrech 58
/** Pending mount structure. */
59
typedef struct {
60
    link_t link;
61
    char *fs_name;            /**< File system name */
62
    char *mp;                 /**< Mount point */
4327 mejdrech 63
    char *opts;       /**< Mount options. */
4153 mejdrech 64
    ipc_callid_t callid;      /**< Call ID waiting for the mount */
65
    ipc_callid_t rid;         /**< Request ID */
66
    dev_handle_t dev_handle;  /**< Device handle */
67
} pending_req_t;
68
 
69
LIST_INITIALIZE(pending_req);
70
 
2689 jermar 71
/**
72
 * This rwlock prevents the race between a triplet-to-VFS-node resolution and a
73
 * concurrent VFS operation which modifies the file system namespace.
74
 */
75
RWLOCK_INITIALIZE(namespace_rwlock);
76
 
2766 jermar 77
futex_t rootfs_futex = FUTEX_INITIALIZER;
3109 jermar 78
vfs_pair_t rootfs = {
2689 jermar 79
    .fs_handle = 0,
3109 jermar 80
    .dev_handle = 0
2689 jermar 81
};
82
 
4153 mejdrech 83
static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
4327 mejdrech 84
    fs_handle_t fs_handle, char *mp, char *opts)
2689 jermar 85
{
4153 mejdrech 86
    vfs_lookup_res_t mp_res;
2689 jermar 87
    vfs_node_t *mp_node = NULL;
4327 mejdrech 88
    ipcarg_t rc;
2958 jermar 89
    int phone;
4327 mejdrech 90
    aid_t msg;
91
    ipc_call_t answer;
92
 
93
    /* Resolve the path to the mountpoint. */
2689 jermar 94
    futex_down(&rootfs_futex);
95
    if (rootfs.fs_handle) {
2707 jermar 96
        /* We already have the root FS. */
2689 jermar 97
        rwlock_write_lock(&namespace_rwlock);
4327 mejdrech 98
        if (str_cmp(mp, "/") == 0) {
2788 jermar 99
            /* Trying to mount root FS over root FS */
100
            rwlock_write_unlock(&namespace_rwlock);
101
            futex_up(&rootfs_futex);
102
            ipc_answer_0(rid, EBUSY);
103
            return;
104
        }
4153 mejdrech 105
 
106
        rc = vfs_lookup_internal(mp, L_DIRECTORY, &mp_res, NULL);
2689 jermar 107
        if (rc != EOK) {
2707 jermar 108
            /* The lookup failed for some reason. */
2689 jermar 109
            rwlock_write_unlock(&namespace_rwlock);
110
            futex_up(&rootfs_futex);
111
            ipc_answer_0(rid, rc);
112
            return;
113
        }
4153 mejdrech 114
 
2691 jermar 115
        mp_node = vfs_node_get(&mp_res);
2689 jermar 116
        if (!mp_node) {
117
            rwlock_write_unlock(&namespace_rwlock);
118
            futex_up(&rootfs_futex);
119
            ipc_answer_0(rid, ENOMEM);
120
            return;
121
        }
4153 mejdrech 122
 
2689 jermar 123
        /*
124
         * Now we hold a reference to mp_node.
125
         * It will be dropped upon the corresponding VFS_UNMOUNT.
126
         * This prevents the mount point from being deleted.
127
         */
128
        rwlock_write_unlock(&namespace_rwlock);
129
    } else {
2707 jermar 130
        /* We still don't have the root file system mounted. */
4327 mejdrech 131
        if (str_cmp(mp, "/") == 0) {
3352 jermar 132
            vfs_lookup_res_t mr_res;
133
            vfs_node_t *mr_node;
4327 mejdrech 134
            fs_index_t rindex;
135
            size_t rsize;
136
            unsigned rlnkcnt;
4153 mejdrech 137
 
2958 jermar 138
            /*
139
             * For this simple, but important case,
140
             * we are almost done.
141
             */
142
 
3109 jermar 143
            /* Tell the mountee that it is being mounted. */
144
            phone = vfs_grab_phone(fs_handle);
4327 mejdrech 145
            msg = async_send_1(phone, VFS_MOUNTED,
146
                (ipcarg_t) dev_handle, &answer);
147
            /* send the mount options */
148
            rc = ipc_data_write_start(phone, (void *)opts,
149
                str_size(opts));
150
            if (rc != EOK) {
151
                async_wait_for(msg, NULL);
152
                vfs_release_phone(phone);
153
                futex_up(&rootfs_futex);
154
                ipc_answer_0(rid, rc);
155
                return;
156
            }
157
            async_wait_for(msg, &rc);
2958 jermar 158
            vfs_release_phone(phone);
3352 jermar 159
 
160
            if (rc != EOK) {
161
                futex_up(&rootfs_futex);
162
                ipc_answer_0(rid, rc);
163
                return;
3109 jermar 164
            }
4327 mejdrech 165
 
166
            rindex = (fs_index_t) IPC_GET_ARG1(answer);
167
            rsize = (size_t) IPC_GET_ARG2(answer);
168
            rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
4153 mejdrech 169
 
3352 jermar 170
            mr_res.triplet.fs_handle = fs_handle;
171
            mr_res.triplet.dev_handle = dev_handle;
4327 mejdrech 172
            mr_res.triplet.index = rindex;
173
            mr_res.size = rsize;
174
            mr_res.lnkcnt = rlnkcnt;
4153 mejdrech 175
            mr_res.type = VFS_NODE_DIRECTORY;
176
 
3352 jermar 177
            rootfs.fs_handle = fs_handle;
178
            rootfs.dev_handle = dev_handle;
2689 jermar 179
            futex_up(&rootfs_futex);
4153 mejdrech 180
 
3352 jermar 181
            /* Add reference to the mounted root. */
182
            mr_node = vfs_node_get(&mr_res);
183
            assert(mr_node);
4153 mejdrech 184
 
2958 jermar 185
            ipc_answer_0(rid, rc);
2689 jermar 186
            return;
187
        } else {
188
            /*
189
             * We can't resolve this without the root filesystem
190
             * being mounted first.
191
             */
192
            futex_up(&rootfs_futex);
193
            ipc_answer_0(rid, ENOENT);
194
            return;
195
        }
196
    }
197
    futex_up(&rootfs_futex);
198
 
199
    /*
200
     * At this point, we have all necessary pieces: file system and device
3109 jermar 201
     * handles, and we know the mount point VFS node.
2689 jermar 202
     */
4153 mejdrech 203
 
2958 jermar 204
    phone = vfs_grab_phone(mp_res.triplet.fs_handle);
4327 mejdrech 205
    msg = async_send_4(phone, VFS_MOUNT,
2691 jermar 206
        (ipcarg_t) mp_res.triplet.dev_handle,
2957 jermar 207
        (ipcarg_t) mp_res.triplet.index,
3109 jermar 208
        (ipcarg_t) fs_handle,
4327 mejdrech 209
        (ipcarg_t) dev_handle, &answer);
210
    /* send the mount options */
211
    rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
212
    if (rc != EOK) {
213
        async_wait_for(msg, NULL);
214
        vfs_release_phone(phone);
215
        /* Mount failed, drop reference to mp_node. */
216
        if (mp_node)
217
            vfs_node_put(mp_node);
218
        ipc_answer_0(rid, rc);
219
        return;
220
    }
221
    async_wait_for(msg, &rc);
2689 jermar 222
    vfs_release_phone(phone);
4153 mejdrech 223
 
2957 jermar 224
    if (rc != EOK) {
3109 jermar 225
        /* Mount failed, drop reference to mp_node. */
2689 jermar 226
        if (mp_node)
227
            vfs_node_put(mp_node);
228
    }
229
 
2957 jermar 230
    ipc_answer_0(rid, rc);
2689 jermar 231
}
232
 
4153 mejdrech 233
/** Process pending mount requests */
234
void vfs_process_pending_mount()
235
{
236
    link_t *cur;
237
 
238
loop:
239
    for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
240
        pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
241
 
242
        fs_handle_t fs_handle = fs_name_to_handle(pr->fs_name, true);
243
        if (!fs_handle)
244
            continue;
245
 
246
        /* Acknowledge that we know fs_name. */
247
        ipc_answer_0(pr->callid, EOK);
248
 
249
        /* Do the mount */
4327 mejdrech 250
        vfs_mount_internal(pr->rid, pr->dev_handle, fs_handle, pr->mp,
251
            pr->opts);
4153 mejdrech 252
 
253
        free(pr->fs_name);
254
        free(pr->mp);
4327 mejdrech 255
        free(pr->opts);
4153 mejdrech 256
        list_remove(cur);
257
        free(pr);
258
        goto loop;
259
    }
260
}
261
 
262
void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
263
{
264
    /*
265
     * We expect the library to do the device-name to device-handle
266
     * translation for us, thus the device handle will arrive as ARG1
267
     * in the request.
268
     */
269
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
270
 
271
    /*
272
     * Mount flags are passed as ARG2.
273
     */
274
    unsigned int flags = (unsigned int) IPC_GET_ARG2(*request);
275
 
276
    /*
277
     * For now, don't make use of ARG3, but it can be used to
278
     * carry mount options in the future.
279
     */
280
 
281
    /* We want the client to send us the mount point. */
282
    ipc_callid_t callid;
283
    size_t size;
284
    if (!ipc_data_write_receive(&callid, &size)) {
285
        ipc_answer_0(callid, EINVAL);
286
        ipc_answer_0(rid, EINVAL);
287
        return;
288
    }
289
 
290
    /* Check whether size is reasonable wrt. the mount point. */
291
    if ((size < 1) || (size > MAX_PATH_LEN)) {
292
        ipc_answer_0(callid, EINVAL);
293
        ipc_answer_0(rid, EINVAL);
294
        return;
295
    }
296
 
297
    /* Allocate buffer for the mount point data being received. */
298
    char *mp = malloc(size + 1);
299
    if (!mp) {
300
        ipc_answer_0(callid, ENOMEM);
301
        ipc_answer_0(rid, ENOMEM);
302
        return;
303
    }
304
 
305
    /* Deliver the mount point. */
306
    ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
307
    if (retval != EOK) {
4327 mejdrech 308
        ipc_answer_0(rid, retval);
4153 mejdrech 309
        free(mp);
310
        return;
311
    }
312
    mp[size] = '\0';
313
 
4327 mejdrech 314
    /* Now we expect to receive the mount options. */
315
    if (!ipc_data_write_receive(&callid, &size)) {
316
        ipc_answer_0(callid, EINVAL);
317
        ipc_answer_0(rid, EINVAL);
318
        free(mp);
319
        return;
320
    }
321
 
322
    /* Check the offered options size. */
323
    if (size < 0 || size > MAX_MNTOPTS_LEN) {
324
        ipc_answer_0(callid, EINVAL);
325
        ipc_answer_0(rid, EINVAL);
326
        free(mp);
327
        return;
328
    }
329
 
330
    /* Allocate buffer for the mount options. */
331
    char *opts = (char *) malloc(size + 1);
332
    if (!opts) {
333
        ipc_answer_0(callid, ENOMEM);
334
        ipc_answer_0(rid, ENOMEM);
335
        free(mp);
336
        return;
337
    }
338
 
339
    /* Deliver the mount options. */
340
    retval = ipc_data_write_finalize(callid, opts, size);
341
    if (retval != EOK) {
342
        ipc_answer_0(rid, retval);
343
        free(mp);
344
        free(opts);
345
        return;
346
    }
347
    opts[size] = '\0';
348
 
4153 mejdrech 349
    /*
350
     * Now, we expect the client to send us data with the name of the file
351
     * system.
352
     */
353
    if (!ipc_data_write_receive(&callid, &size)) {
354
        ipc_answer_0(callid, EINVAL);
355
        ipc_answer_0(rid, EINVAL);
356
        free(mp);
4327 mejdrech 357
        free(opts);
4153 mejdrech 358
        return;
359
    }
360
 
361
    /*
362
     * Don't receive more than is necessary for storing a full file system
363
     * name.
364
     */
365
    if ((size < 1) || (size > FS_NAME_MAXLEN)) {
366
        ipc_answer_0(callid, EINVAL);
367
        ipc_answer_0(rid, EINVAL);
368
        free(mp);
4327 mejdrech 369
        free(opts);
4153 mejdrech 370
        return;
371
    }
372
 
373
    /*
374
     * Allocate buffer for file system name.
375
     */
376
    char *fs_name = (char *) malloc(size + 1);
377
    if (fs_name == NULL) {
378
        ipc_answer_0(callid, ENOMEM);
4327 mejdrech 379
        ipc_answer_0(rid, ENOMEM);
4153 mejdrech 380
        free(mp);
4327 mejdrech 381
        free(opts);
4153 mejdrech 382
        return;
383
    }
384
 
385
    /* Deliver the file system name. */
386
    retval = ipc_data_write_finalize(callid, fs_name, size);
387
    if (retval != EOK) {
4327 mejdrech 388
        ipc_answer_0(rid, retval);
4153 mejdrech 389
        free(mp);
4327 mejdrech 390
        free(opts);
4153 mejdrech 391
        free(fs_name);
392
        return;
393
    }
394
    fs_name[size] = '\0';
4327 mejdrech 395
 
4153 mejdrech 396
    /*
4327 mejdrech 397
     * Wait for IPC_M_PING so that we can return an error if we don't know
398
     * fs_name.
399
     */
400
    ipc_call_t data;
401
    callid = async_get_call(&data);
402
    if (IPC_GET_METHOD(data) != IPC_M_PING) {
403
        ipc_answer_0(callid, ENOTSUP);
404
        ipc_answer_0(rid, ENOTSUP);
405
        free(mp);
406
        free(opts);
407
        free(fs_name);
408
        return;
409
    }
410
 
411
    /*
4153 mejdrech 412
     * Check if we know a file system with the same name as is in fs_name.
413
     * This will also give us its file system handle.
414
     */
415
    fs_handle_t fs_handle = fs_name_to_handle(fs_name, true);
416
    if (!fs_handle) {
417
        if (flags & IPC_FLAG_BLOCKING) {
4327 mejdrech 418
            pending_req_t *pr;
419
 
4153 mejdrech 420
            /* Blocking mount, add to pending list */
4327 mejdrech 421
            pr = (pending_req_t *) malloc(sizeof(pending_req_t));
4153 mejdrech 422
            if (!pr) {
423
                ipc_answer_0(callid, ENOMEM);
424
                ipc_answer_0(rid, ENOMEM);
425
                free(mp);
426
                free(fs_name);
4327 mejdrech 427
                free(opts);
4153 mejdrech 428
                return;
429
            }
430
 
431
            pr->fs_name = fs_name;
432
            pr->mp = mp;
4327 mejdrech 433
            pr->opts = opts;
4153 mejdrech 434
            pr->callid = callid;
435
            pr->rid = rid;
436
            pr->dev_handle = dev_handle;
4263 mejdrech 437
            link_initialize(&pr->link);
4153 mejdrech 438
            list_append(&pr->link, &pending_req);
439
            return;
440
        }
441
 
442
        ipc_answer_0(callid, ENOENT);
443
        ipc_answer_0(rid, ENOENT);
444
        free(mp);
445
        free(fs_name);
4327 mejdrech 446
        free(opts);
4153 mejdrech 447
        return;
448
    }
449
 
450
    /* Acknowledge that we know fs_name. */
451
    ipc_answer_0(callid, EOK);
452
 
453
    /* Do the mount */
4327 mejdrech 454
    vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
4153 mejdrech 455
    free(mp);
456
    free(fs_name);
4327 mejdrech 457
    free(opts);
4153 mejdrech 458
}
459
 
2689 jermar 460
void vfs_open(ipc_callid_t rid, ipc_call_t *request)
461
{
462
    if (!vfs_files_init()) {
463
        ipc_answer_0(rid, ENOMEM);
464
        return;
465
    }
466
 
467
    /*
2700 jermar 468
     * The POSIX interface is open(path, oflag, mode).
469
     * We can receive oflags and mode along with the VFS_OPEN call; the path
2689 jermar 470
     * will need to arrive in another call.
2700 jermar 471
     *
472
     * We also receive one private, non-POSIX set of flags called lflag
473
     * used to pass information to vfs_lookup_internal().
2689 jermar 474
     */
2700 jermar 475
    int lflag = IPC_GET_ARG1(*request);
476
    int oflag = IPC_GET_ARG2(*request);
477
    int mode = IPC_GET_ARG3(*request);
2689 jermar 478
    size_t len;
479
 
4153 mejdrech 480
    /*
481
     * Make sure that we are called with exactly one of L_FILE and
482
     * L_DIRECTORY.
483
     */
484
    if ((lflag & (L_FILE | L_DIRECTORY)) == 0 ||
485
        (lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) {
486
        ipc_answer_0(rid, EINVAL);
487
        return;
488
    }
489
 
2708 jermar 490
    if (oflag & O_CREAT)
491
        lflag |= L_CREATE;
492
    if (oflag & O_EXCL)
493
        lflag |= L_EXCLUSIVE;
494
 
2689 jermar 495
    ipc_callid_t callid;
496
 
497
    if (!ipc_data_write_receive(&callid, &len)) {
498
        ipc_answer_0(callid, EINVAL);
499
        ipc_answer_0(rid, EINVAL);
500
        return;
501
    }
2752 jermar 502
    char *path = malloc(len + 1);
2689 jermar 503
    if (!path) {
504
        ipc_answer_0(callid, ENOMEM);
505
        ipc_answer_0(rid, ENOMEM);
506
        return;
507
    }
508
    int rc;
509
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
510
        ipc_answer_0(rid, rc);
511
        free(path);
512
        return;
513
    }
2752 jermar 514
    path[len] = '\0';
2689 jermar 515
 
516
    /*
517
     * Avoid the race condition in which the file can be deleted before we
518
     * find/create-and-lock the VFS node corresponding to the looked-up
519
     * triplet.
520
     */
2708 jermar 521
    if (lflag & L_CREATE)
522
        rwlock_write_lock(&namespace_rwlock);
523
    else
524
        rwlock_read_lock(&namespace_rwlock);
2689 jermar 525
 
2707 jermar 526
    /* The path is now populated and we can call vfs_lookup_internal(). */
2691 jermar 527
    vfs_lookup_res_t lr;
2752 jermar 528
    rc = vfs_lookup_internal(path, lflag, &lr, NULL);
2689 jermar 529
    if (rc) {
2708 jermar 530
        if (lflag & L_CREATE)
531
            rwlock_write_unlock(&namespace_rwlock);
532
        else
533
            rwlock_read_unlock(&namespace_rwlock);
2689 jermar 534
        ipc_answer_0(rid, rc);
535
        free(path);
536
        return;
537
    }
538
 
2748 jermar 539
    /* Path is no longer needed. */
2689 jermar 540
    free(path);
541
 
2691 jermar 542
    vfs_node_t *node = vfs_node_get(&lr);
2708 jermar 543
    if (lflag & L_CREATE)
544
        rwlock_write_unlock(&namespace_rwlock);
545
    else
546
        rwlock_read_unlock(&namespace_rwlock);
2689 jermar 547
 
2748 jermar 548
    /* Truncate the file if requested and if necessary. */
549
    if (oflag & O_TRUNC) {
2749 jermar 550
        rwlock_write_lock(&node->contents_rwlock);
2748 jermar 551
        if (node->size) {
552
            rc = vfs_truncate_internal(node->fs_handle,
553
                node->dev_handle, node->index, 0);
554
            if (rc) {
2749 jermar 555
                rwlock_write_unlock(&node->contents_rwlock);
2748 jermar 556
                vfs_node_put(node);
557
                ipc_answer_0(rid, rc);
558
                return;
559
            }
560
            node->size = 0;
561
        }
2749 jermar 562
        rwlock_write_unlock(&node->contents_rwlock);
2748 jermar 563
    }
564
 
2689 jermar 565
    /*
566
     * Get ourselves a file descriptor and the corresponding vfs_file_t
567
     * structure.
568
     */
569
    int fd = vfs_fd_alloc();
570
    if (fd < 0) {
571
        vfs_node_put(node);
572
        ipc_answer_0(rid, fd);
573
        return;
574
    }
575
    vfs_file_t *file = vfs_file_get(fd);
576
    file->node = node;
2710 jermar 577
    if (oflag & O_APPEND)
2709 jermar 578
        file->append = true;
2689 jermar 579
 
580
    /*
581
     * The following increase in reference count is for the fact that the
582
     * file is being opened and that a file structure is pointing to it.
583
     * It is necessary so that the file will not disappear when
584
     * vfs_node_put() is called. The reference will be dropped by the
585
     * respective VFS_CLOSE.
586
     */
587
    vfs_node_addref(node);
588
    vfs_node_put(node);
589
 
2707 jermar 590
    /* Success! Return the new file descriptor to the client. */
2689 jermar 591
    ipc_answer_1(rid, EOK, fd);
592
}
593
 
2734 jermar 594
void vfs_close(ipc_callid_t rid, ipc_call_t *request)
595
{
596
    int fd = IPC_GET_ARG1(*request);
3215 jermar 597
    int rc = vfs_fd_free(fd);
598
    ipc_answer_0(rid, rc);
2734 jermar 599
}
600
 
2689 jermar 601
static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
602
{
603
 
604
    /*
605
     * The following code strongly depends on the fact that the files data
606
     * structure can be only accessed by a single fibril and all file
607
     * operations are serialized (i.e. the reads and writes cannot
608
     * interleave and a file cannot be closed while it is being read).
609
     *
610
     * Additional synchronization needs to be added once the table of
611
     * open files supports parallel access!
612
     */
613
 
614
    int fd = IPC_GET_ARG1(*request);
3079 decky 615
 
2707 jermar 616
    /* Lookup the file structure corresponding to the file descriptor. */
2689 jermar 617
    vfs_file_t *file = vfs_file_get(fd);
618
    if (!file) {
619
        ipc_answer_0(rid, ENOENT);
620
        return;
621
    }
3079 decky 622
 
2689 jermar 623
    /*
624
     * Now we need to receive a call with client's
625
     * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
626
     */
627
    ipc_callid_t callid;
628
    int res;
629
    if (read)
630
        res = ipc_data_read_receive(&callid, NULL);
631
    else
632
        res = ipc_data_write_receive(&callid, NULL);
633
    if (!res) {
634
        ipc_answer_0(callid, EINVAL);
635
        ipc_answer_0(rid, EINVAL);
636
        return;
637
    }
3079 decky 638
 
2689 jermar 639
    /*
640
     * Lock the open file structure so that no other thread can manipulate
641
     * the same open file at a time.
642
     */
643
    futex_down(&file->lock);
4153 mejdrech 644
 
2689 jermar 645
    /*
646
     * Lock the file's node so that no other client can read/write to it at
647
     * the same time.
648
     */
649
    if (read)
650
        rwlock_read_lock(&file->node->contents_rwlock);
651
    else
652
        rwlock_write_lock(&file->node->contents_rwlock);
4153 mejdrech 653
 
654
    if (file->node->type == VFS_NODE_DIRECTORY) {
655
        /*
656
         * Make sure that no one is modifying the namespace
657
         * while we are in readdir().
658
         */
659
        assert(read);
660
        rwlock_read_lock(&namespace_rwlock);
661
    }
3079 decky 662
 
2689 jermar 663
    int fs_phone = vfs_grab_phone(file->node->fs_handle);  
664
 
2707 jermar 665
    /* Make a VFS_READ/VFS_WRITE request at the destination FS server. */
2689 jermar 666
    aid_t msg;
667
    ipc_call_t answer;
2709 jermar 668
    if (!read && file->append)
669
        file->pos = file->node->size;
2689 jermar 670
    msg = async_send_3(fs_phone, IPC_GET_METHOD(*request),
671
        file->node->dev_handle, file->node->index, file->pos, &answer);
672
 
673
    /*
674
     * Forward the IPC_M_DATA_READ/IPC_M_DATA_WRITE request to the
675
     * destination FS server. The call will be routed as if sent by
676
     * ourselves. Note that call arguments are immutable in this case so we
677
     * don't have to bother.
678
     */
679
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
3079 decky 680
 
2689 jermar 681
    vfs_release_phone(fs_phone);
3079 decky 682
 
2707 jermar 683
    /* Wait for reply from the FS server. */
2689 jermar 684
    ipcarg_t rc;
685
    async_wait_for(msg, &rc);
686
    size_t bytes = IPC_GET_ARG1(answer);
4153 mejdrech 687
 
688
    if (file->node->type == VFS_NODE_DIRECTORY)
689
        rwlock_read_unlock(&namespace_rwlock);
3079 decky 690
 
2707 jermar 691
    /* Unlock the VFS node. */
2689 jermar 692
    if (read)
693
        rwlock_read_unlock(&file->node->contents_rwlock);
694
    else {
695
        /* Update the cached version of node's size. */
2710 jermar 696
        if (rc == EOK)
697
            file->node->size = IPC_GET_ARG2(answer);
2689 jermar 698
        rwlock_write_unlock(&file->node->contents_rwlock);
699
    }
3079 decky 700
 
2707 jermar 701
    /* Update the position pointer and unlock the open file. */
2710 jermar 702
    if (rc == EOK)
703
        file->pos += bytes;
2689 jermar 704
    futex_up(&file->lock);
3079 decky 705
 
2689 jermar 706
    /*
707
     * FS server's reply is the final result of the whole operation we
708
     * return to the client.
709
     */
710
    ipc_answer_1(rid, rc, bytes);
711
}
712
 
713
void vfs_read(ipc_callid_t rid, ipc_call_t *request)
714
{
715
    vfs_rdwr(rid, request, true);
716
}
717
 
718
void vfs_write(ipc_callid_t rid, ipc_call_t *request)
719
{
720
    vfs_rdwr(rid, request, false);
721
}
722
 
723
void vfs_seek(ipc_callid_t rid, ipc_call_t *request)
724
{
725
    int fd = (int) IPC_GET_ARG1(*request);
726
    off_t off = (off_t) IPC_GET_ARG2(*request);
727
    int whence = (int) IPC_GET_ARG3(*request);
728
 
729
 
2707 jermar 730
    /* Lookup the file structure corresponding to the file descriptor. */
2689 jermar 731
    vfs_file_t *file = vfs_file_get(fd);
732
    if (!file) {
733
        ipc_answer_0(rid, ENOENT);
734
        return;
735
    }
736
 
737
    off_t newpos;
738
    futex_down(&file->lock);
739
    if (whence == SEEK_SET) {
740
        file->pos = off;
741
        futex_up(&file->lock);
742
        ipc_answer_1(rid, EOK, off);
743
        return;
744
    }
745
    if (whence == SEEK_CUR) {
746
        if (file->pos + off < file->pos) {
747
            futex_up(&file->lock);
748
            ipc_answer_0(rid, EOVERFLOW);
749
            return;
750
        }
751
        file->pos += off;
752
        newpos = file->pos;
753
        futex_up(&file->lock);
754
        ipc_answer_1(rid, EOK, newpos);
755
        return;
756
    }
757
    if (whence == SEEK_END) {
758
        rwlock_read_lock(&file->node->contents_rwlock);
759
        size_t size = file->node->size;
760
        rwlock_read_unlock(&file->node->contents_rwlock);
761
        if (size + off < size) {
762
            futex_up(&file->lock);
763
            ipc_answer_0(rid, EOVERFLOW);
764
            return;
765
        }
766
        newpos = size + off;
767
        futex_up(&file->lock);
768
        ipc_answer_1(rid, EOK, newpos);
769
        return;
770
    }
771
    futex_up(&file->lock);
772
    ipc_answer_0(rid, EINVAL);
773
}
774
 
2770 jermar 775
int
776
vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
777
    fs_index_t index, size_t size)
2748 jermar 778
{
779
    ipcarg_t rc;
780
    int fs_phone;
781
 
782
    fs_phone = vfs_grab_phone(fs_handle);
783
    rc = async_req_3_0(fs_phone, VFS_TRUNCATE, (ipcarg_t)dev_handle,
784
        (ipcarg_t)index, (ipcarg_t)size);
785
    vfs_release_phone(fs_phone);
786
    return (int)rc;
787
}
788
 
2693 jermar 789
void vfs_truncate(ipc_callid_t rid, ipc_call_t *request)
790
{
791
    int fd = IPC_GET_ARG1(*request);
792
    size_t size = IPC_GET_ARG2(*request);
2748 jermar 793
    int rc;
2693 jermar 794
 
795
    vfs_file_t *file = vfs_file_get(fd);
796
    if (!file) {
797
        ipc_answer_0(rid, ENOENT);
798
        return;
799
    }
800
    futex_down(&file->lock);
801
 
802
    rwlock_write_lock(&file->node->contents_rwlock);
2748 jermar 803
    rc = vfs_truncate_internal(file->node->fs_handle,
804
        file->node->dev_handle, file->node->index, size);
2693 jermar 805
    if (rc == EOK)
806
        file->node->size = size;
807
    rwlock_write_unlock(&file->node->contents_rwlock);
808
 
809
    futex_up(&file->lock);
2748 jermar 810
    ipc_answer_0(rid, (ipcarg_t)rc);
2693 jermar 811
}
812
 
2707 jermar 813
void vfs_mkdir(ipc_callid_t rid, ipc_call_t *request)
814
{
815
    int mode = IPC_GET_ARG1(*request);
2735 jermar 816
 
2707 jermar 817
    size_t len;
818
    ipc_callid_t callid;
819
 
820
    if (!ipc_data_write_receive(&callid, &len)) {
821
        ipc_answer_0(callid, EINVAL);
822
        ipc_answer_0(rid, EINVAL);
823
        return;
824
    }
2752 jermar 825
    char *path = malloc(len + 1);
2707 jermar 826
    if (!path) {
827
        ipc_answer_0(callid, ENOMEM);
828
        ipc_answer_0(rid, ENOMEM);
829
        return;
830
    }
831
    int rc;
832
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
833
        ipc_answer_0(rid, rc);
834
        free(path);
835
        return;
836
    }
2752 jermar 837
    path[len] = '\0';
2707 jermar 838
 
839
    rwlock_write_lock(&namespace_rwlock);
840
    int lflag = L_DIRECTORY | L_CREATE | L_EXCLUSIVE;
2752 jermar 841
    rc = vfs_lookup_internal(path, lflag, NULL, NULL);
2707 jermar 842
    rwlock_write_unlock(&namespace_rwlock);
843
    free(path);
844
    ipc_answer_0(rid, rc);
845
}
846
 
2735 jermar 847
void vfs_unlink(ipc_callid_t rid, ipc_call_t *request)
848
{
849
    int lflag = IPC_GET_ARG1(*request);
850
 
851
    size_t len;
852
    ipc_callid_t callid;
853
 
854
    if (!ipc_data_write_receive(&callid, &len)) {
855
        ipc_answer_0(callid, EINVAL);
856
        ipc_answer_0(rid, EINVAL);
857
        return;
858
    }
2752 jermar 859
    char *path = malloc(len + 1);
2735 jermar 860
    if (!path) {
861
        ipc_answer_0(callid, ENOMEM);
862
        ipc_answer_0(rid, ENOMEM);
863
        return;
864
    }
865
    int rc;
866
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
867
        ipc_answer_0(rid, rc);
868
        free(path);
869
        return;
870
    }
2752 jermar 871
    path[len] = '\0';
2735 jermar 872
 
873
    rwlock_write_lock(&namespace_rwlock);
874
    lflag &= L_DIRECTORY;   /* sanitize lflag */
875
    vfs_lookup_res_t lr;
2763 jermar 876
    rc = vfs_lookup_internal(path, lflag | L_UNLINK, &lr, NULL);
2735 jermar 877
    free(path);
878
    if (rc != EOK) {
879
        rwlock_write_unlock(&namespace_rwlock);
880
        ipc_answer_0(rid, rc);
881
        return;
882
    }
883
 
884
    /*
885
     * The name has already been unlinked by vfs_lookup_internal().
886
     * We have to get and put the VFS node to ensure that it is
2742 jermar 887
     * VFS_DESTROY'ed after the last reference to it is dropped.
2735 jermar 888
     */
889
    vfs_node_t *node = vfs_node_get(&lr);
2766 jermar 890
    futex_down(&nodes_futex);
2735 jermar 891
    node->lnkcnt--;
2766 jermar 892
    futex_up(&nodes_futex);
2735 jermar 893
    rwlock_write_unlock(&namespace_rwlock);
894
    vfs_node_put(node);
895
    ipc_answer_0(rid, EOK);
896
}
897
 
2763 jermar 898
void vfs_rename(ipc_callid_t rid, ipc_call_t *request)
899
{
4327 mejdrech 900
    size_t olen, nlen;
2763 jermar 901
    ipc_callid_t callid;
902
    int rc;
903
 
904
    /* Retrieve the old path. */
4327 mejdrech 905
    if (!ipc_data_write_receive(&callid, &olen)) {
2763 jermar 906
        ipc_answer_0(callid, EINVAL);
907
        ipc_answer_0(rid, EINVAL);
908
        return;
909
    }
4327 mejdrech 910
    char *old = malloc(olen + 1);
2763 jermar 911
    if (!old) {
912
        ipc_answer_0(callid, ENOMEM);
913
        ipc_answer_0(rid, ENOMEM);
914
        return;
915
    }
4327 mejdrech 916
    if ((rc = ipc_data_write_finalize(callid, old, olen))) {
2763 jermar 917
        ipc_answer_0(rid, rc);
918
        free(old);
919
        return;
920
    }
4327 mejdrech 921
    old[olen] = '\0';
2763 jermar 922
 
923
    /* Retrieve the new path. */
4327 mejdrech 924
    if (!ipc_data_write_receive(&callid, &nlen)) {
2763 jermar 925
        ipc_answer_0(callid, EINVAL);
926
        ipc_answer_0(rid, EINVAL);
927
        free(old);
928
        return;
929
    }
4327 mejdrech 930
    char *new = malloc(nlen + 1);
2763 jermar 931
    if (!new) {
932
        ipc_answer_0(callid, ENOMEM);
933
        ipc_answer_0(rid, ENOMEM);
934
        free(old);
935
        return;
936
    }
4327 mejdrech 937
    if ((rc = ipc_data_write_finalize(callid, new, nlen))) {
2763 jermar 938
        ipc_answer_0(rid, rc);
939
        free(old);
940
        free(new);
941
        return;
942
    }
4327 mejdrech 943
    new[nlen] = '\0';
2763 jermar 944
 
4327 mejdrech 945
    char *oldc = canonify(old, &olen);
946
    char *newc = canonify(new, &nlen);
2763 jermar 947
    if (!oldc || !newc) {
948
        ipc_answer_0(rid, EINVAL);
949
        free(old);
950
        free(new);
951
        return;
952
    }
4327 mejdrech 953
    oldc[olen] = '\0';
954
    newc[nlen] = '\0';
955
    if (!str_lcmp(newc, oldc, str_length(oldc))) {
2763 jermar 956
        /* oldc is a prefix of newc */
957
        ipc_answer_0(rid, EINVAL);
958
        free(old);
959
        free(new);
960
        return;
961
    }
962
 
963
    vfs_lookup_res_t old_lr;
964
    vfs_lookup_res_t new_lr;
965
    vfs_lookup_res_t new_par_lr;
966
    rwlock_write_lock(&namespace_rwlock);
967
    /* Lookup the node belonging to the old file name. */
968
    rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
969
    if (rc != EOK) {
970
        rwlock_write_unlock(&namespace_rwlock);
971
        ipc_answer_0(rid, rc);
972
        free(old);
973
        free(new);
974
        return;
975
    }
976
    vfs_node_t *old_node = vfs_node_get(&old_lr);
977
    if (!old_node) {
978
        rwlock_write_unlock(&namespace_rwlock);
979
        ipc_answer_0(rid, ENOMEM);
980
        free(old);
981
        free(new);
982
        return;
983
    }
984
    /* Lookup parent of the new file name. */
985
    rc = vfs_lookup_internal(newc, L_PARENT, &new_par_lr, NULL);
986
    if (rc != EOK) {
987
        rwlock_write_unlock(&namespace_rwlock);
988
        ipc_answer_0(rid, rc);
989
        free(old);
990
        free(new);
991
        return;
992
    }
993
    /* Check whether linking to the same file system instance. */
994
    if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
995
        (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
996
        rwlock_write_unlock(&namespace_rwlock);
997
        ipc_answer_0(rid, EXDEV);   /* different file systems */
998
        free(old);
999
        free(new);
1000
        return;
1001
    }
1002
    /* Destroy the old link for the new name. */
1003
    vfs_node_t *new_node = NULL;
1004
    rc = vfs_lookup_internal(newc, L_UNLINK, &new_lr, NULL);
1005
    switch (rc) {
1006
    case ENOENT:
1007
        /* simply not in our way */
1008
        break;
1009
    case EOK:
1010
        new_node = vfs_node_get(&new_lr);
1011
        if (!new_node) {
1012
            rwlock_write_unlock(&namespace_rwlock);
1013
            ipc_answer_0(rid, ENOMEM);
1014
            free(old);
1015
            free(new);
1016
            return;
1017
        }
2766 jermar 1018
        futex_down(&nodes_futex);
2763 jermar 1019
        new_node->lnkcnt--;
2766 jermar 1020
        futex_up(&nodes_futex);
2763 jermar 1021
        break;
1022
    default:
1023
        rwlock_write_unlock(&namespace_rwlock);
1024
        ipc_answer_0(rid, ENOTEMPTY);
1025
        free(old);
1026
        free(new);
1027
        return;
1028
    }
1029
    /* Create the new link for the new name. */
1030
    rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
1031
    if (rc != EOK) {
1032
        rwlock_write_unlock(&namespace_rwlock);
1033
        if (new_node)
1034
            vfs_node_put(new_node);
1035
        ipc_answer_0(rid, rc);
1036
        free(old);
1037
        free(new);
1038
        return;
1039
    }
2766 jermar 1040
    futex_down(&nodes_futex);
2763 jermar 1041
    old_node->lnkcnt++;
2766 jermar 1042
    futex_up(&nodes_futex);
2763 jermar 1043
    /* Destroy the link for the old name. */
1044
    rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
1045
    if (rc != EOK) {
1046
        rwlock_write_unlock(&namespace_rwlock);
1047
        vfs_node_put(old_node);
1048
        if (new_node)
1049
            vfs_node_put(new_node);
1050
        ipc_answer_0(rid, rc);
1051
        free(old);
1052
        free(new);
1053
        return;
1054
    }
2766 jermar 1055
    futex_down(&nodes_futex);
2763 jermar 1056
    old_node->lnkcnt--;
2766 jermar 1057
    futex_up(&nodes_futex);
2763 jermar 1058
    rwlock_write_unlock(&namespace_rwlock);
1059
    vfs_node_put(old_node);
1060
    if (new_node)
1061
        vfs_node_put(new_node);
1062
    free(old);
1063
    free(new);
1064
    ipc_answer_0(rid, EOK);
1065
}
1066
 
2689 jermar 1067
/**
1068
 * @}
1069
 */