Subversion Repositories HelenOS

Rev

Rev 2770 | Rev 2927 | 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
 * @{
31
 */
32
 
33
/**
34
 * @file    vfs_ops.c
35
 * @brief   Operations that VFS offers to its clients.
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
 
2689 jermar 58
/**
59
 * This rwlock prevents the race between a triplet-to-VFS-node resolution and a
60
 * concurrent VFS operation which modifies the file system namespace.
61
 */
62
RWLOCK_INITIALIZE(namespace_rwlock);
63
 
2766 jermar 64
futex_t rootfs_futex = FUTEX_INITIALIZER;
2689 jermar 65
vfs_triplet_t rootfs = {
66
    .fs_handle = 0,
67
    .dev_handle = 0,
68
    .index = 0,
69
};
70
 
2770 jermar 71
static int
72
lookup_root(fs_handle_t fs_handle, dev_handle_t dev_handle,
73
    vfs_lookup_res_t *result)
2689 jermar 74
{
75
    vfs_pair_t altroot = {
76
        .fs_handle = fs_handle,
77
        .dev_handle = dev_handle,
78
    };
79
 
2752 jermar 80
    return vfs_lookup_internal("/", L_DIRECTORY, result, &altroot);
2689 jermar 81
}
82
 
83
void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
84
{
2770 jermar 85
    dev_handle_t dev_handle;
2689 jermar 86
    vfs_node_t *mp_node = NULL;
87
 
88
    /*
89
     * We expect the library to do the device-name to device-handle
90
     * translation for us, thus the device handle will arrive as ARG1
91
     * in the request.
92
     */
2770 jermar 93
    dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
2689 jermar 94
 
95
    /*
96
     * For now, don't make use of ARG2 and ARG3, but they can be used to
97
     * carry mount options in the future.
98
     */
99
 
100
    ipc_callid_t callid;
101
    size_t size;
102
 
103
    /*
104
     * Now, we expect the client to send us data with the name of the file
105
     * system.
106
     */
107
    if (!ipc_data_write_receive(&callid, &size)) {
108
        ipc_answer_0(callid, EINVAL);
109
        ipc_answer_0(rid, EINVAL);
110
        return;
111
    }
112
 
113
    /*
114
     * Don't receive more than is necessary for storing a full file system
115
     * name.
116
     */
117
    if (size < 1 || size > FS_NAME_MAXLEN) {
118
        ipc_answer_0(callid, EINVAL);
119
        ipc_answer_0(rid, EINVAL);
120
        return;
121
    }
122
 
2707 jermar 123
    /* Deliver the file system name. */
2689 jermar 124
    char fs_name[FS_NAME_MAXLEN + 1];
125
    (void) ipc_data_write_finalize(callid, fs_name, size);
126
    fs_name[size] = '\0';
127
 
128
    /*
129
     * Check if we know a file system with the same name as is in fs_name.
130
     * This will also give us its file system handle.
131
     */
2770 jermar 132
    fs_handle_t fs_handle = fs_name_to_handle(fs_name, true);
2689 jermar 133
    if (!fs_handle) {
134
        ipc_answer_0(rid, ENOENT);
135
        return;
136
    }
137
 
2707 jermar 138
    /* Now, we want the client to send us the mount point. */
2689 jermar 139
    if (!ipc_data_write_receive(&callid, &size)) {
140
        ipc_answer_0(callid, EINVAL);
141
        ipc_answer_0(rid, EINVAL);
142
        return;
143
    }
144
 
2707 jermar 145
    /* Check whether size is reasonable wrt. the mount point. */
2689 jermar 146
    if (size < 1 || size > MAX_PATH_LEN) {
147
        ipc_answer_0(callid, EINVAL);
148
        ipc_answer_0(rid, EINVAL);
149
        return;
150
    }
2707 jermar 151
    /* Allocate buffer for the mount point data being received. */
2689 jermar 152
    uint8_t *buf;
2752 jermar 153
    buf = malloc(size + 1);
2689 jermar 154
    if (!buf) {
155
        ipc_answer_0(callid, ENOMEM);
156
        ipc_answer_0(rid, ENOMEM);
157
        return;
158
    }
159
 
2707 jermar 160
    /* Deliver the mount point. */
2689 jermar 161
    (void) ipc_data_write_finalize(callid, buf, size);
2752 jermar 162
    buf[size] = '\0';
2689 jermar 163
 
164
    /*
165
     * Lookup the root node of the filesystem being mounted.
166
     * In this case, we don't need to take the namespace_futex as the root
167
     * node cannot be removed. However, we do take a reference to it so
168
     * that we can track how many times it has been mounted.
169
     */
170
    int rc;
2691 jermar 171
    vfs_lookup_res_t mr_res;
172
    rc = lookup_root(fs_handle, dev_handle, &mr_res);
2689 jermar 173
    if (rc != EOK) {
174
        free(buf);
175
        ipc_answer_0(rid, rc);
176
        return;
177
    }
2691 jermar 178
    vfs_node_t *mr_node = vfs_node_get(&mr_res);
2689 jermar 179
    if (!mr_node) {
180
        free(buf);
181
        ipc_answer_0(rid, ENOMEM);
182
        return;
183
    }
184
 
2707 jermar 185
    /* Finally, we need to resolve the path to the mountpoint. */
2691 jermar 186
    vfs_lookup_res_t mp_res;
2689 jermar 187
    futex_down(&rootfs_futex);
188
    if (rootfs.fs_handle) {
2707 jermar 189
        /* We already have the root FS. */
2689 jermar 190
        rwlock_write_lock(&namespace_rwlock);
2788 jermar 191
        if ((size == 1) && (buf[0] == '/')) {
192
            /* Trying to mount root FS over root FS */
193
            rwlock_write_unlock(&namespace_rwlock);
194
            futex_up(&rootfs_futex);
195
            vfs_node_put(mr_node);
196
            free(buf);
197
            ipc_answer_0(rid, EBUSY);
198
            return;
199
        }
2752 jermar 200
        rc = vfs_lookup_internal(buf, L_DIRECTORY, &mp_res, NULL);
2689 jermar 201
        if (rc != EOK) {
2707 jermar 202
            /* The lookup failed for some reason. */
2689 jermar 203
            rwlock_write_unlock(&namespace_rwlock);
204
            futex_up(&rootfs_futex);
205
            vfs_node_put(mr_node);  /* failed -> drop reference */
206
            free(buf);
207
            ipc_answer_0(rid, rc);
208
            return;
209
        }
2691 jermar 210
        mp_node = vfs_node_get(&mp_res);
2689 jermar 211
        if (!mp_node) {
212
            rwlock_write_unlock(&namespace_rwlock);
213
            futex_up(&rootfs_futex);
214
            vfs_node_put(mr_node);  /* failed -> drop reference */
215
            free(buf);
216
            ipc_answer_0(rid, ENOMEM);
217
            return;
218
        }
219
        /*
220
         * Now we hold a reference to mp_node.
221
         * It will be dropped upon the corresponding VFS_UNMOUNT.
222
         * This prevents the mount point from being deleted.
223
         */
224
        rwlock_write_unlock(&namespace_rwlock);
225
    } else {
2707 jermar 226
        /* We still don't have the root file system mounted. */
2689 jermar 227
        if ((size == 1) && (buf[0] == '/')) {
2707 jermar 228
            /* For this simple, but important case, we are done. */
2691 jermar 229
            rootfs = mr_res.triplet;
2689 jermar 230
            futex_up(&rootfs_futex);
231
            free(buf);
232
            ipc_answer_0(rid, EOK);
233
            return;
234
        } else {
235
            /*
236
             * We can't resolve this without the root filesystem
237
             * being mounted first.
238
             */
239
            futex_up(&rootfs_futex);
240
            free(buf);
241
            vfs_node_put(mr_node);  /* failed -> drop reference */
242
            ipc_answer_0(rid, ENOENT);
243
            return;
244
        }
245
    }
246
    futex_up(&rootfs_futex);
247
 
248
    free(buf);  /* The buffer is not needed anymore. */
249
 
250
    /*
251
     * At this point, we have all necessary pieces: file system and device
252
     * handles, and we know the mount point VFS node and also the root node
253
     * of the file system being mounted.
254
     */
255
 
2691 jermar 256
    int phone = vfs_grab_phone(mp_res.triplet.fs_handle);
2689 jermar 257
    /* Later we can use ARG3 to pass mode/flags. */
2691 jermar 258
    aid_t req1 = async_send_3(phone, VFS_MOUNT,
259
        (ipcarg_t) mp_res.triplet.dev_handle,
260
        (ipcarg_t) mp_res.triplet.index, 0, NULL);
2689 jermar 261
    /* The second call uses the same method. */
262
    aid_t req2 = async_send_3(phone, VFS_MOUNT,
2691 jermar 263
        (ipcarg_t) mr_res.triplet.fs_handle,
264
        (ipcarg_t) mr_res.triplet.dev_handle,
265
        (ipcarg_t) mr_res.triplet.index, NULL);
2689 jermar 266
    vfs_release_phone(phone);
267
 
268
    ipcarg_t rc1;
269
    ipcarg_t rc2;
270
    async_wait_for(req1, &rc1);
271
    async_wait_for(req2, &rc2);
272
 
273
    if ((rc1 != EOK) || (rc2 != EOK)) {
274
        /* Mount failed, drop references to mr_node and mp_node. */
275
        vfs_node_put(mr_node);
276
        if (mp_node)
277
            vfs_node_put(mp_node);
278
    }
279
 
280
    if (rc2 == EOK)
281
        ipc_answer_0(rid, rc1);
282
    else if (rc1 == EOK)
283
        ipc_answer_0(rid, rc2);
284
    else
285
        ipc_answer_0(rid, rc1);
286
}
287
 
288
void vfs_open(ipc_callid_t rid, ipc_call_t *request)
289
{
290
    if (!vfs_files_init()) {
291
        ipc_answer_0(rid, ENOMEM);
292
        return;
293
    }
294
 
295
    /*
2700 jermar 296
     * The POSIX interface is open(path, oflag, mode).
297
     * We can receive oflags and mode along with the VFS_OPEN call; the path
2689 jermar 298
     * will need to arrive in another call.
2700 jermar 299
     *
300
     * We also receive one private, non-POSIX set of flags called lflag
301
     * used to pass information to vfs_lookup_internal().
2689 jermar 302
     */
2700 jermar 303
    int lflag = IPC_GET_ARG1(*request);
304
    int oflag = IPC_GET_ARG2(*request);
305
    int mode = IPC_GET_ARG3(*request);
2689 jermar 306
    size_t len;
307
 
2708 jermar 308
    if (oflag & O_CREAT)
309
        lflag |= L_CREATE;
310
    if (oflag & O_EXCL)
311
        lflag |= L_EXCLUSIVE;
312
 
2689 jermar 313
    ipc_callid_t callid;
314
 
315
    if (!ipc_data_write_receive(&callid, &len)) {
316
        ipc_answer_0(callid, EINVAL);
317
        ipc_answer_0(rid, EINVAL);
318
        return;
319
    }
2752 jermar 320
    char *path = malloc(len + 1);
2689 jermar 321
    if (!path) {
322
        ipc_answer_0(callid, ENOMEM);
323
        ipc_answer_0(rid, ENOMEM);
324
        return;
325
    }
326
    int rc;
327
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
328
        ipc_answer_0(rid, rc);
329
        free(path);
330
        return;
331
    }
2752 jermar 332
    path[len] = '\0';
2689 jermar 333
 
334
    /*
335
     * Avoid the race condition in which the file can be deleted before we
336
     * find/create-and-lock the VFS node corresponding to the looked-up
337
     * triplet.
338
     */
2708 jermar 339
    if (lflag & L_CREATE)
340
        rwlock_write_lock(&namespace_rwlock);
341
    else
342
        rwlock_read_lock(&namespace_rwlock);
2689 jermar 343
 
2707 jermar 344
    /* The path is now populated and we can call vfs_lookup_internal(). */
2691 jermar 345
    vfs_lookup_res_t lr;
2752 jermar 346
    rc = vfs_lookup_internal(path, lflag, &lr, NULL);
2689 jermar 347
    if (rc) {
2708 jermar 348
        if (lflag & L_CREATE)
349
            rwlock_write_unlock(&namespace_rwlock);
350
        else
351
            rwlock_read_unlock(&namespace_rwlock);
2689 jermar 352
        ipc_answer_0(rid, rc);
353
        free(path);
354
        return;
355
    }
356
 
2748 jermar 357
    /* Path is no longer needed. */
2689 jermar 358
    free(path);
359
 
2691 jermar 360
    vfs_node_t *node = vfs_node_get(&lr);
2708 jermar 361
    if (lflag & L_CREATE)
362
        rwlock_write_unlock(&namespace_rwlock);
363
    else
364
        rwlock_read_unlock(&namespace_rwlock);
2689 jermar 365
 
2748 jermar 366
    /* Truncate the file if requested and if necessary. */
367
    if (oflag & O_TRUNC) {
2749 jermar 368
        rwlock_write_lock(&node->contents_rwlock);
2748 jermar 369
        if (node->size) {
370
            rc = vfs_truncate_internal(node->fs_handle,
371
                node->dev_handle, node->index, 0);
372
            if (rc) {
2749 jermar 373
                rwlock_write_unlock(&node->contents_rwlock);
2748 jermar 374
                vfs_node_put(node);
375
                ipc_answer_0(rid, rc);
376
                return;
377
            }
378
            node->size = 0;
379
        }
2749 jermar 380
        rwlock_write_unlock(&node->contents_rwlock);
2748 jermar 381
    }
382
 
2689 jermar 383
    /*
384
     * Get ourselves a file descriptor and the corresponding vfs_file_t
385
     * structure.
386
     */
387
    int fd = vfs_fd_alloc();
388
    if (fd < 0) {
389
        vfs_node_put(node);
390
        ipc_answer_0(rid, fd);
391
        return;
392
    }
393
    vfs_file_t *file = vfs_file_get(fd);
394
    file->node = node;
2710 jermar 395
    if (oflag & O_APPEND)
2709 jermar 396
        file->append = true;
2689 jermar 397
 
398
    /*
399
     * The following increase in reference count is for the fact that the
400
     * file is being opened and that a file structure is pointing to it.
401
     * It is necessary so that the file will not disappear when
402
     * vfs_node_put() is called. The reference will be dropped by the
403
     * respective VFS_CLOSE.
404
     */
405
    vfs_node_addref(node);
406
    vfs_node_put(node);
407
 
2707 jermar 408
    /* Success! Return the new file descriptor to the client. */
2689 jermar 409
    ipc_answer_1(rid, EOK, fd);
410
}
411
 
2734 jermar 412
void vfs_close(ipc_callid_t rid, ipc_call_t *request)
413
{
414
    int fd = IPC_GET_ARG1(*request);
415
    if (fd >= MAX_OPEN_FILES) {
416
        ipc_answer_0(rid, EBADF);
417
        return;
418
    }
419
    vfs_fd_free(fd);
420
    ipc_answer_0(rid, EOK);
421
}
422
 
2689 jermar 423
static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
424
{
425
 
426
    /*
427
     * The following code strongly depends on the fact that the files data
428
     * structure can be only accessed by a single fibril and all file
429
     * operations are serialized (i.e. the reads and writes cannot
430
     * interleave and a file cannot be closed while it is being read).
431
     *
432
     * Additional synchronization needs to be added once the table of
433
     * open files supports parallel access!
434
     */
435
 
436
    int fd = IPC_GET_ARG1(*request);
437
 
2707 jermar 438
    /* Lookup the file structure corresponding to the file descriptor. */
2689 jermar 439
    vfs_file_t *file = vfs_file_get(fd);
440
    if (!file) {
441
        ipc_answer_0(rid, ENOENT);
442
        return;
443
    }
444
 
445
    /*
446
     * Now we need to receive a call with client's
447
     * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
448
     */
449
    ipc_callid_t callid;
450
    int res;
451
    if (read)
452
        res = ipc_data_read_receive(&callid, NULL);
453
    else
454
        res = ipc_data_write_receive(&callid, NULL);
455
    if (!res) {
456
        ipc_answer_0(callid, EINVAL);
457
        ipc_answer_0(rid, EINVAL);
458
        return;
459
    }
460
 
461
    /*
462
     * Lock the open file structure so that no other thread can manipulate
463
     * the same open file at a time.
464
     */
465
    futex_down(&file->lock);
466
 
467
    /*
468
     * Lock the file's node so that no other client can read/write to it at
469
     * the same time.
470
     */
471
    if (read)
472
        rwlock_read_lock(&file->node->contents_rwlock);
473
    else
474
        rwlock_write_lock(&file->node->contents_rwlock);
475
 
476
    int fs_phone = vfs_grab_phone(file->node->fs_handle);  
477
 
2707 jermar 478
    /* Make a VFS_READ/VFS_WRITE request at the destination FS server. */
2689 jermar 479
    aid_t msg;
480
    ipc_call_t answer;
2709 jermar 481
    if (!read && file->append)
482
        file->pos = file->node->size;
2689 jermar 483
    msg = async_send_3(fs_phone, IPC_GET_METHOD(*request),
484
        file->node->dev_handle, file->node->index, file->pos, &answer);
485
 
486
    /*
487
     * Forward the IPC_M_DATA_READ/IPC_M_DATA_WRITE request to the
488
     * destination FS server. The call will be routed as if sent by
489
     * ourselves. Note that call arguments are immutable in this case so we
490
     * don't have to bother.
491
     */
492
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
493
 
494
    vfs_release_phone(fs_phone);
495
 
2707 jermar 496
    /* Wait for reply from the FS server. */
2689 jermar 497
    ipcarg_t rc;
498
    async_wait_for(msg, &rc);
499
    size_t bytes = IPC_GET_ARG1(answer);
500
 
2707 jermar 501
    /* Unlock the VFS node. */
2689 jermar 502
    if (read)
503
        rwlock_read_unlock(&file->node->contents_rwlock);
504
    else {
505
        /* Update the cached version of node's size. */
2710 jermar 506
        if (rc == EOK)
507
            file->node->size = IPC_GET_ARG2(answer);
2689 jermar 508
        rwlock_write_unlock(&file->node->contents_rwlock);
509
    }
510
 
2707 jermar 511
    /* Update the position pointer and unlock the open file. */
2710 jermar 512
    if (rc == EOK)
513
        file->pos += bytes;
2689 jermar 514
    futex_up(&file->lock);
515
 
516
    /*
517
     * FS server's reply is the final result of the whole operation we
518
     * return to the client.
519
     */
520
    ipc_answer_1(rid, rc, bytes);
521
}
522
 
523
void vfs_read(ipc_callid_t rid, ipc_call_t *request)
524
{
525
    vfs_rdwr(rid, request, true);
526
}
527
 
528
void vfs_write(ipc_callid_t rid, ipc_call_t *request)
529
{
530
    vfs_rdwr(rid, request, false);
531
}
532
 
533
void vfs_seek(ipc_callid_t rid, ipc_call_t *request)
534
{
535
    int fd = (int) IPC_GET_ARG1(*request);
536
    off_t off = (off_t) IPC_GET_ARG2(*request);
537
    int whence = (int) IPC_GET_ARG3(*request);
538
 
539
 
2707 jermar 540
    /* Lookup the file structure corresponding to the file descriptor. */
2689 jermar 541
    vfs_file_t *file = vfs_file_get(fd);
542
    if (!file) {
543
        ipc_answer_0(rid, ENOENT);
544
        return;
545
    }
546
 
547
    off_t newpos;
548
    futex_down(&file->lock);
549
    if (whence == SEEK_SET) {
550
        file->pos = off;
551
        futex_up(&file->lock);
552
        ipc_answer_1(rid, EOK, off);
553
        return;
554
    }
555
    if (whence == SEEK_CUR) {
556
        if (file->pos + off < file->pos) {
557
            futex_up(&file->lock);
558
            ipc_answer_0(rid, EOVERFLOW);
559
            return;
560
        }
561
        file->pos += off;
562
        newpos = file->pos;
563
        futex_up(&file->lock);
564
        ipc_answer_1(rid, EOK, newpos);
565
        return;
566
    }
567
    if (whence == SEEK_END) {
568
        rwlock_read_lock(&file->node->contents_rwlock);
569
        size_t size = file->node->size;
570
        rwlock_read_unlock(&file->node->contents_rwlock);
571
        if (size + off < size) {
572
            futex_up(&file->lock);
573
            ipc_answer_0(rid, EOVERFLOW);
574
            return;
575
        }
576
        newpos = size + off;
577
        futex_up(&file->lock);
578
        ipc_answer_1(rid, EOK, newpos);
579
        return;
580
    }
581
    futex_up(&file->lock);
582
    ipc_answer_0(rid, EINVAL);
583
}
584
 
2770 jermar 585
int
586
vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
587
    fs_index_t index, size_t size)
2748 jermar 588
{
589
    ipcarg_t rc;
590
    int fs_phone;
591
 
592
    fs_phone = vfs_grab_phone(fs_handle);
593
    rc = async_req_3_0(fs_phone, VFS_TRUNCATE, (ipcarg_t)dev_handle,
594
        (ipcarg_t)index, (ipcarg_t)size);
595
    vfs_release_phone(fs_phone);
596
    return (int)rc;
597
}
598
 
2693 jermar 599
void vfs_truncate(ipc_callid_t rid, ipc_call_t *request)
600
{
601
    int fd = IPC_GET_ARG1(*request);
602
    size_t size = IPC_GET_ARG2(*request);
2748 jermar 603
    int rc;
2693 jermar 604
 
605
    vfs_file_t *file = vfs_file_get(fd);
606
    if (!file) {
607
        ipc_answer_0(rid, ENOENT);
608
        return;
609
    }
610
    futex_down(&file->lock);
611
 
612
    rwlock_write_lock(&file->node->contents_rwlock);
2748 jermar 613
    rc = vfs_truncate_internal(file->node->fs_handle,
614
        file->node->dev_handle, file->node->index, size);
2693 jermar 615
    if (rc == EOK)
616
        file->node->size = size;
617
    rwlock_write_unlock(&file->node->contents_rwlock);
618
 
619
    futex_up(&file->lock);
2748 jermar 620
    ipc_answer_0(rid, (ipcarg_t)rc);
2693 jermar 621
}
622
 
2707 jermar 623
void vfs_mkdir(ipc_callid_t rid, ipc_call_t *request)
624
{
625
    int mode = IPC_GET_ARG1(*request);
2735 jermar 626
 
2707 jermar 627
    size_t len;
628
    ipc_callid_t callid;
629
 
630
    if (!ipc_data_write_receive(&callid, &len)) {
631
        ipc_answer_0(callid, EINVAL);
632
        ipc_answer_0(rid, EINVAL);
633
        return;
634
    }
2752 jermar 635
    char *path = malloc(len + 1);
2707 jermar 636
    if (!path) {
637
        ipc_answer_0(callid, ENOMEM);
638
        ipc_answer_0(rid, ENOMEM);
639
        return;
640
    }
641
    int rc;
642
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
643
        ipc_answer_0(rid, rc);
644
        free(path);
645
        return;
646
    }
2752 jermar 647
    path[len] = '\0';
2707 jermar 648
 
649
    rwlock_write_lock(&namespace_rwlock);
650
    int lflag = L_DIRECTORY | L_CREATE | L_EXCLUSIVE;
2752 jermar 651
    rc = vfs_lookup_internal(path, lflag, NULL, NULL);
2707 jermar 652
    rwlock_write_unlock(&namespace_rwlock);
653
    free(path);
654
    ipc_answer_0(rid, rc);
655
}
656
 
2735 jermar 657
void vfs_unlink(ipc_callid_t rid, ipc_call_t *request)
658
{
659
    int lflag = IPC_GET_ARG1(*request);
660
 
661
    size_t len;
662
    ipc_callid_t callid;
663
 
664
    if (!ipc_data_write_receive(&callid, &len)) {
665
        ipc_answer_0(callid, EINVAL);
666
        ipc_answer_0(rid, EINVAL);
667
        return;
668
    }
2752 jermar 669
    char *path = malloc(len + 1);
2735 jermar 670
    if (!path) {
671
        ipc_answer_0(callid, ENOMEM);
672
        ipc_answer_0(rid, ENOMEM);
673
        return;
674
    }
675
    int rc;
676
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
677
        ipc_answer_0(rid, rc);
678
        free(path);
679
        return;
680
    }
2752 jermar 681
    path[len] = '\0';
2735 jermar 682
 
683
    rwlock_write_lock(&namespace_rwlock);
684
    lflag &= L_DIRECTORY;   /* sanitize lflag */
685
    vfs_lookup_res_t lr;
2763 jermar 686
    rc = vfs_lookup_internal(path, lflag | L_UNLINK, &lr, NULL);
2735 jermar 687
    free(path);
688
    if (rc != EOK) {
689
        rwlock_write_unlock(&namespace_rwlock);
690
        ipc_answer_0(rid, rc);
691
        return;
692
    }
693
 
694
    /*
695
     * The name has already been unlinked by vfs_lookup_internal().
696
     * We have to get and put the VFS node to ensure that it is
2742 jermar 697
     * VFS_DESTROY'ed after the last reference to it is dropped.
2735 jermar 698
     */
699
    vfs_node_t *node = vfs_node_get(&lr);
2766 jermar 700
    futex_down(&nodes_futex);
2735 jermar 701
    node->lnkcnt--;
2766 jermar 702
    futex_up(&nodes_futex);
2735 jermar 703
    rwlock_write_unlock(&namespace_rwlock);
704
    vfs_node_put(node);
705
    ipc_answer_0(rid, EOK);
706
}
707
 
2763 jermar 708
void vfs_rename(ipc_callid_t rid, ipc_call_t *request)
709
{
710
    size_t len;
711
    ipc_callid_t callid;
712
    int rc;
713
 
714
    /* Retrieve the old path. */
715
    if (!ipc_data_write_receive(&callid, &len)) {
716
        ipc_answer_0(callid, EINVAL);
717
        ipc_answer_0(rid, EINVAL);
718
        return;
719
    }
720
    char *old = malloc(len + 1);
721
    if (!old) {
722
        ipc_answer_0(callid, ENOMEM);
723
        ipc_answer_0(rid, ENOMEM);
724
        return;
725
    }
726
    if ((rc = ipc_data_write_finalize(callid, old, len))) {
727
        ipc_answer_0(rid, rc);
728
        free(old);
729
        return;
730
    }
731
    old[len] = '\0';
732
 
733
    /* Retrieve the new path. */
734
    if (!ipc_data_write_receive(&callid, &len)) {
735
        ipc_answer_0(callid, EINVAL);
736
        ipc_answer_0(rid, EINVAL);
737
        free(old);
738
        return;
739
    }
740
    char *new = malloc(len + 1);
741
    if (!new) {
742
        ipc_answer_0(callid, ENOMEM);
743
        ipc_answer_0(rid, ENOMEM);
744
        free(old);
745
        return;
746
    }
747
    if ((rc = ipc_data_write_finalize(callid, new, len))) {
748
        ipc_answer_0(rid, rc);
749
        free(old);
750
        free(new);
751
        return;
752
    }
753
    new[len] = '\0';
754
 
755
    char *oldc = canonify(old, &len);
756
    char *newc = canonify(new, NULL);
757
    if (!oldc || !newc) {
758
        ipc_answer_0(rid, EINVAL);
759
        free(old);
760
        free(new);
761
        return;
762
    }
763
    if (!strncmp(newc, oldc, len)) {
764
        /* oldc is a prefix of newc */
765
        ipc_answer_0(rid, EINVAL);
766
        free(old);
767
        free(new);
768
        return;
769
    }
770
 
771
    vfs_lookup_res_t old_lr;
772
    vfs_lookup_res_t new_lr;
773
    vfs_lookup_res_t new_par_lr;
774
    rwlock_write_lock(&namespace_rwlock);
775
    /* Lookup the node belonging to the old file name. */
776
    rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
777
    if (rc != EOK) {
778
        rwlock_write_unlock(&namespace_rwlock);
779
        ipc_answer_0(rid, rc);
780
        free(old);
781
        free(new);
782
        return;
783
    }
784
    vfs_node_t *old_node = vfs_node_get(&old_lr);
785
    if (!old_node) {
786
        rwlock_write_unlock(&namespace_rwlock);
787
        ipc_answer_0(rid, ENOMEM);
788
        free(old);
789
        free(new);
790
        return;
791
    }
792
    /* Lookup parent of the new file name. */
793
    rc = vfs_lookup_internal(newc, L_PARENT, &new_par_lr, NULL);
794
    if (rc != EOK) {
795
        rwlock_write_unlock(&namespace_rwlock);
796
        ipc_answer_0(rid, rc);
797
        free(old);
798
        free(new);
799
        return;
800
    }
801
    /* Check whether linking to the same file system instance. */
802
    if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
803
        (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
804
        rwlock_write_unlock(&namespace_rwlock);
805
        ipc_answer_0(rid, EXDEV);   /* different file systems */
806
        free(old);
807
        free(new);
808
        return;
809
    }
810
    /* Destroy the old link for the new name. */
811
    vfs_node_t *new_node = NULL;
812
    rc = vfs_lookup_internal(newc, L_UNLINK, &new_lr, NULL);
813
    switch (rc) {
814
    case ENOENT:
815
        /* simply not in our way */
816
        break;
817
    case EOK:
818
        new_node = vfs_node_get(&new_lr);
819
        if (!new_node) {
820
            rwlock_write_unlock(&namespace_rwlock);
821
            ipc_answer_0(rid, ENOMEM);
822
            free(old);
823
            free(new);
824
            return;
825
        }
2766 jermar 826
        futex_down(&nodes_futex);
2763 jermar 827
        new_node->lnkcnt--;
2766 jermar 828
        futex_up(&nodes_futex);
2763 jermar 829
        break;
830
    default:
831
        rwlock_write_unlock(&namespace_rwlock);
832
        ipc_answer_0(rid, ENOTEMPTY);
833
        free(old);
834
        free(new);
835
        return;
836
    }
837
    /* Create the new link for the new name. */
838
    rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
839
    if (rc != EOK) {
840
        rwlock_write_unlock(&namespace_rwlock);
841
        if (new_node)
842
            vfs_node_put(new_node);
843
        ipc_answer_0(rid, rc);
844
        free(old);
845
        free(new);
846
        return;
847
    }
2766 jermar 848
    futex_down(&nodes_futex);
2763 jermar 849
    old_node->lnkcnt++;
2766 jermar 850
    futex_up(&nodes_futex);
2763 jermar 851
    /* Destroy the link for the old name. */
852
    rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
853
    if (rc != EOK) {
854
        rwlock_write_unlock(&namespace_rwlock);
855
        vfs_node_put(old_node);
856
        if (new_node)
857
            vfs_node_put(new_node);
858
        ipc_answer_0(rid, rc);
859
        free(old);
860
        free(new);
861
        return;
862
    }
2766 jermar 863
    futex_down(&nodes_futex);
2763 jermar 864
    old_node->lnkcnt--;
2766 jermar 865
    futex_up(&nodes_futex);
2763 jermar 866
    rwlock_write_unlock(&namespace_rwlock);
867
    vfs_node_put(old_node);
868
    if (new_node)
869
        vfs_node_put(new_node);
870
    free(old);
871
    free(new);
872
    ipc_answer_0(rid, EOK);
873
}
874
 
2689 jermar 875
/**
876
 * @}
877
 */