Subversion Repositories HelenOS

Rev

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