Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
2671 jermar 1
/*
2684 jermar 2
 * Copyright (c) 2008 Jakub Jermar
2671 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 libc
30
 * @{
31
 */
32
/** @file
33
 */
4002 decky 34
 
2755 jermar 35
#include <vfs/vfs.h>
36
#include <vfs/canonify.h>
2694 jermar 37
#include <stdlib.h>
2674 jermar 38
#include <unistd.h>
2694 jermar 39
#include <dirent.h>
2674 jermar 40
#include <fcntl.h>
4585 jermar 41
#include <stdio.h>
2707 jermar 42
#include <sys/stat.h>
43
#include <sys/types.h>
2671 jermar 44
#include <ipc/ipc.h>
45
#include <ipc/services.h>
46
#include <async.h>
47
#include <atomic.h>
48
#include <futex.h>
49
#include <errno.h>
50
#include <string.h>
4401 svoboda 51
#include <devmap.h>
4482 decky 52
#include <ipc/vfs.h>
53
#include <ipc/devmap.h>
2671 jermar 54
 
4482 decky 55
static int vfs_phone = -1;
56
static futex_t vfs_phone_futex = FUTEX_INITIALIZER;
57
static futex_t cwd_futex = FUTEX_INITIALIZER;
2671 jermar 58
 
2755 jermar 59
DIR *cwd_dir = NULL;
60
char *cwd_path = NULL;
4256 svoboda 61
size_t cwd_size = 0;
2755 jermar 62
 
3306 jermar 63
char *absolutize(const char *path, size_t *retlen)
2755 jermar 64
{
65
    char *ncwd_path;
3292 jermar 66
    char *ncwd_path_nc;
2755 jermar 67
 
68
    futex_down(&cwd_futex);
4256 svoboda 69
    size_t size = str_size(path);
2755 jermar 70
    if (*path != '/') {
71
        if (!cwd_path) {
72
            futex_up(&cwd_futex);
73
            return NULL;
74
        }
4256 svoboda 75
        ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
3292 jermar 76
        if (!ncwd_path_nc) {
2755 jermar 77
            futex_up(&cwd_futex);
78
            return NULL;
79
        }
4268 svoboda 80
        str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path);
4256 svoboda 81
        ncwd_path_nc[cwd_size] = '/';
82
        ncwd_path_nc[cwd_size + 1] = '\0';
2755 jermar 83
    } else {
4256 svoboda 84
        ncwd_path_nc = malloc(size + 1);
3292 jermar 85
        if (!ncwd_path_nc) {
2755 jermar 86
            futex_up(&cwd_futex);
87
            return NULL;
88
        }
3292 jermar 89
        ncwd_path_nc[0] = '\0';
2755 jermar 90
    }
4280 svoboda 91
    str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
3292 jermar 92
    ncwd_path = canonify(ncwd_path_nc, retlen);
93
    if (!ncwd_path) {
2771 jermar 94
        futex_up(&cwd_futex);
3292 jermar 95
        free(ncwd_path_nc);
2771 jermar 96
        return NULL;
97
    }
3292 jermar 98
    /*
99
     * We need to clone ncwd_path because canonify() works in-place and thus
100
     * the address in ncwd_path need not be the same as ncwd_path_nc, even
101
     * though they both point into the same dynamically allocated buffer.
102
     */
4266 svoboda 103
    ncwd_path = str_dup(ncwd_path);
3292 jermar 104
    free(ncwd_path_nc);
105
    if (!ncwd_path) {
106
        futex_up(&cwd_futex);
107
        return NULL;
108
    }
2755 jermar 109
    futex_up(&cwd_futex);
110
    return ncwd_path;
111
}
112
 
4002 decky 113
static void vfs_connect(void)
2671 jermar 114
{
4002 decky 115
    while (vfs_phone < 0)
116
        vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
2671 jermar 117
}
118
 
4002 decky 119
int mount(const char *fs_name, const char *mp, const char *dev,
4401 svoboda 120
    const char *opts, unsigned int flags)
2671 jermar 121
{
122
    int res;
123
    ipcarg_t rc;
124
    aid_t req;
3077 decky 125
    dev_handle_t dev_handle;
126
 
4401 svoboda 127
    res = devmap_device_get_handle(dev, &dev_handle, flags);
3077 decky 128
    if (res != EOK)
129
        return res;
130
 
4256 svoboda 131
    size_t mpa_size;
132
    char *mpa = absolutize(mp, &mpa_size);
2755 jermar 133
    if (!mpa)
134
        return ENOMEM;
4002 decky 135
 
2671 jermar 136
    futex_down(&vfs_phone_futex);
137
    async_serialize_start();
4002 decky 138
    vfs_connect();
139
 
4584 jermar 140
    req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
4256 svoboda 141
    rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
2671 jermar 142
    if (rc != EOK) {
143
        async_wait_for(req, NULL);
144
        async_serialize_end();
145
        futex_up(&vfs_phone_futex);
2755 jermar 146
        free(mpa);
2671 jermar 147
        return (int) rc;
148
    }
4002 decky 149
 
4305 jermar 150
    rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
151
    if (rc != EOK) {
152
        async_wait_for(req, NULL);
153
        async_serialize_end();
154
        futex_up(&vfs_phone_futex);
155
        free(mpa);
156
        return (int) rc;
157
    }
158
 
4256 svoboda 159
    rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
3255 jermar 160
    if (rc != EOK) {
161
        async_wait_for(req, NULL);
162
        async_serialize_end();
163
        futex_up(&vfs_phone_futex);
164
        free(mpa);
165
        return (int) rc;
166
    }
4302 jermar 167
 
168
    /* Ask VFS whether it likes fs_name. */
169
    rc = async_req_0_0(vfs_phone, IPC_M_PING);
170
    if (rc != EOK) {
171
        async_wait_for(req, NULL);
172
        async_serialize_end();
173
        futex_up(&vfs_phone_futex);
174
        free(mpa);
175
        return (int) rc;
176
    }
4002 decky 177
 
2671 jermar 178
    async_wait_for(req, &rc);
179
    async_serialize_end();
180
    futex_up(&vfs_phone_futex);
2755 jermar 181
    free(mpa);
4002 decky 182
 
2671 jermar 183
    return (int) rc;
184
}
185
 
2700 jermar 186
static int _open(const char *path, int lflag, int oflag, ...)
2671 jermar 187
{
188
    ipcarg_t rc;
189
    ipc_call_t answer;
190
    aid_t req;
191
 
4256 svoboda 192
    size_t pa_size;
193
    char *pa = absolutize(path, &pa_size);
2755 jermar 194
    if (!pa)
195
        return ENOMEM;
196
 
2671 jermar 197
    futex_down(&vfs_phone_futex);
198
    async_serialize_start();
4002 decky 199
    vfs_connect();
200
 
4584 jermar 201
    req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
4256 svoboda 202
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
2671 jermar 203
    if (rc != EOK) {
204
        async_wait_for(req, NULL);
205
        async_serialize_end();
206
        futex_up(&vfs_phone_futex);
2755 jermar 207
        free(pa);
2671 jermar 208
        return (int) rc;
209
    }
210
    async_wait_for(req, &rc);
211
    async_serialize_end();
212
    futex_up(&vfs_phone_futex);
2755 jermar 213
    free(pa);
4482 decky 214
 
3246 jermar 215
    if (rc != EOK)
216
        return (int) rc;
4482 decky 217
 
2671 jermar 218
    return (int) IPC_GET_ARG1(answer);
219
}
220
 
2700 jermar 221
int open(const char *path, int oflag, ...)
222
{
223
    return _open(path, L_FILE, oflag);
224
}
225
 
4492 jermar 226
int open_node(fdi_node_t *node, int oflag)
4482 decky 227
{
228
    futex_down(&vfs_phone_futex);
229
    async_serialize_start();
230
    vfs_connect();
231
 
232
    ipc_call_t answer;
4584 jermar 233
    aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle,
4482 decky 234
        node->dev_handle, node->index, oflag, &answer);
235
 
236
    ipcarg_t rc;
237
    async_wait_for(req, &rc);
238
    async_serialize_end();
239
    futex_up(&vfs_phone_futex);
240
 
241
    if (rc != EOK)
242
        return (int) rc;
243
 
244
    return (int) IPC_GET_ARG1(answer);
245
}
246
 
2707 jermar 247
int close(int fildes)
248
{
2734 jermar 249
    ipcarg_t rc;
4002 decky 250
 
2734 jermar 251
    futex_down(&vfs_phone_futex);
252
    async_serialize_start();
4002 decky 253
    vfs_connect();
254
 
4584 jermar 255
    rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes);
4002 decky 256
 
2734 jermar 257
    async_serialize_end();
258
    futex_up(&vfs_phone_futex);
259
 
260
    return (int)rc;
2707 jermar 261
}
262
 
2671 jermar 263
ssize_t read(int fildes, void *buf, size_t nbyte)
264
{
265
    ipcarg_t rc;
266
    ipc_call_t answer;
267
    aid_t req;
268
 
269
    futex_down(&vfs_phone_futex);
270
    async_serialize_start();
4002 decky 271
    vfs_connect();
272
 
4584 jermar 273
    req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
2741 jermar 274
    rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
275
    if (rc != EOK) {
2671 jermar 276
        async_wait_for(req, NULL);
277
        async_serialize_end();
278
        futex_up(&vfs_phone_futex);
279
        return (ssize_t) rc;
280
    }
281
    async_wait_for(req, &rc);
282
    async_serialize_end();
283
    futex_up(&vfs_phone_futex);
2710 jermar 284
    if (rc == EOK)
285
        return (ssize_t) IPC_GET_ARG1(answer);
286
    else
3313 jermar 287
        return rc;
2671 jermar 288
}
289
 
2674 jermar 290
ssize_t write(int fildes, const void *buf, size_t nbyte)
291
{
292
    ipcarg_t rc;
293
    ipc_call_t answer;
294
    aid_t req;
295
 
296
    futex_down(&vfs_phone_futex);
297
    async_serialize_start();
4002 decky 298
    vfs_connect();
299
 
4584 jermar 300
    req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
2741 jermar 301
    rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
302
    if (rc != EOK) {
2674 jermar 303
        async_wait_for(req, NULL);
304
        async_serialize_end();
305
        futex_up(&vfs_phone_futex);
306
        return (ssize_t) rc;
307
    }
308
    async_wait_for(req, &rc);
309
    async_serialize_end();
310
    futex_up(&vfs_phone_futex);
2710 jermar 311
    if (rc == EOK)
312
        return (ssize_t) IPC_GET_ARG1(answer);
313
    else
314
        return -1;
2674 jermar 315
}
2684 jermar 316
 
4482 decky 317
int fsync(int fildes)
318
{
319
    futex_down(&vfs_phone_futex);
320
    async_serialize_start();
321
    vfs_connect();
322
 
4584 jermar 323
    ipcarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
4482 decky 324
 
325
    async_serialize_end();
326
    futex_up(&vfs_phone_futex);
327
 
328
    return (int) rc;
329
}
330
 
2684 jermar 331
off_t lseek(int fildes, off_t offset, int whence)
332
{
333
    ipcarg_t rc;
334
 
335
    futex_down(&vfs_phone_futex);
336
    async_serialize_start();
4002 decky 337
    vfs_connect();
338
 
3488 svoboda 339
    ipcarg_t newoffs;
4584 jermar 340
    rc = async_req_3_1(vfs_phone, VFS_IN_SEEK, fildes, offset, whence,
3488 svoboda 341
        &newoffs);
2684 jermar 342
 
343
    async_serialize_end();
344
    futex_up(&vfs_phone_futex);
345
 
346
    if (rc != EOK)
347
        return (off_t) -1;
348
 
3488 svoboda 349
    return (off_t) newoffs;
2684 jermar 350
}
351
 
2693 jermar 352
int ftruncate(int fildes, off_t length)
353
{
354
    ipcarg_t rc;
355
 
356
    futex_down(&vfs_phone_futex);
357
    async_serialize_start();
4002 decky 358
    vfs_connect();
359
 
4584 jermar 360
    rc = async_req_2_0(vfs_phone, VFS_IN_TRUNCATE, fildes, length);
2693 jermar 361
    async_serialize_end();
362
    futex_up(&vfs_phone_futex);
363
    return (int) rc;
364
}
365
 
4585 jermar 366
int fstat(int fildes, struct stat *stat)
367
{
368
    ipcarg_t rc;
369
    ipc_call_t answer;
370
    aid_t req;
371
 
372
    futex_down(&vfs_phone_futex);
373
    async_serialize_start();
374
    vfs_connect();
375
 
376
    req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
377
    rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
378
    if (rc != EOK) {
379
        async_wait_for(req, NULL);
380
        async_serialize_end();
381
        futex_up(&vfs_phone_futex);
382
        return (ssize_t) rc;
383
    }
384
    async_wait_for(req, &rc);
385
    async_serialize_end();
386
    futex_up(&vfs_phone_futex);
387
 
388
    return rc;
389
}
390
 
4587 jermar 391
int stat(const char *path, struct stat *stat)
392
{
393
    ipcarg_t rc;
394
    aid_t req;
395
 
396
    size_t pa_size;
397
    char *pa = absolutize(path, &pa_size);
398
    if (!pa)
399
        return ENOMEM;
400
 
401
    futex_down(&vfs_phone_futex);
402
    async_serialize_start();
403
    vfs_connect();
404
 
405
    req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
406
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
407
    if (rc != EOK) {
408
        async_wait_for(req, NULL);
409
        async_serialize_end();
410
        futex_up(&vfs_phone_futex);
411
        free(pa);
412
        return (int) rc;
413
    }
414
    rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat));
415
    if (rc != EOK) {
416
        async_wait_for(req, NULL);
417
        async_serialize_end();
418
        futex_up(&vfs_phone_futex);
419
        free(pa);
420
        return (int) rc;
421
    }
422
    async_wait_for(req, &rc);
423
    async_serialize_end();
424
    futex_up(&vfs_phone_futex);
425
    free(pa);
426
    return rc;
427
}
428
 
2694 jermar 429
DIR *opendir(const char *dirname)
430
{
431
    DIR *dirp = malloc(sizeof(DIR));
432
    if (!dirp)
433
        return NULL;
2700 jermar 434
    dirp->fd = _open(dirname, L_DIRECTORY, 0);
2699 jermar 435
    if (dirp->fd < 0) {
2694 jermar 436
        free(dirp);
437
        return NULL;
438
    }
439
    return dirp;
440
}
441
 
442
struct dirent *readdir(DIR *dirp)
443
{
2699 jermar 444
    ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
445
    if (len <= 0)
446
        return NULL;
447
    return &dirp->res;
2694 jermar 448
}
449
 
450
void rewinddir(DIR *dirp)
451
{
2699 jermar 452
    (void) lseek(dirp->fd, 0, SEEK_SET);
2694 jermar 453
}
454
 
455
int closedir(DIR *dirp)
456
{
457
    (void) close(dirp->fd);
458
    free(dirp);
459
    return 0;
460
}
461
 
2707 jermar 462
int mkdir(const char *path, mode_t mode)
2694 jermar 463
{
2707 jermar 464
    ipcarg_t rc;
465
    aid_t req;
466
 
4256 svoboda 467
    size_t pa_size;
468
    char *pa = absolutize(path, &pa_size);
2755 jermar 469
    if (!pa)
470
        return ENOMEM;
4002 decky 471
 
2707 jermar 472
    futex_down(&vfs_phone_futex);
473
    async_serialize_start();
4002 decky 474
    vfs_connect();
475
 
4584 jermar 476
    req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
4256 svoboda 477
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
2707 jermar 478
    if (rc != EOK) {
479
        async_wait_for(req, NULL);
480
        async_serialize_end();
481
        futex_up(&vfs_phone_futex);
2755 jermar 482
        free(pa);
2707 jermar 483
        return (int) rc;
484
    }
485
    async_wait_for(req, &rc);
486
    async_serialize_end();
487
    futex_up(&vfs_phone_futex);
2755 jermar 488
    free(pa);
4482 decky 489
    return rc;
2694 jermar 490
}
491
 
2735 jermar 492
static int _unlink(const char *path, int lflag)
493
{
494
    ipcarg_t rc;
495
    aid_t req;
496
 
4256 svoboda 497
    size_t pa_size;
498
    char *pa = absolutize(path, &pa_size);
2755 jermar 499
    if (!pa)
500
        return ENOMEM;
2771 jermar 501
 
2735 jermar 502
    futex_down(&vfs_phone_futex);
503
    async_serialize_start();
4002 decky 504
    vfs_connect();
505
 
4584 jermar 506
    req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
4256 svoboda 507
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
2735 jermar 508
    if (rc != EOK) {
509
        async_wait_for(req, NULL);
510
        async_serialize_end();
511
        futex_up(&vfs_phone_futex);
2755 jermar 512
        free(pa);
2735 jermar 513
        return (int) rc;
514
    }
515
    async_wait_for(req, &rc);
516
    async_serialize_end();
517
    futex_up(&vfs_phone_futex);
2755 jermar 518
    free(pa);
4482 decky 519
    return rc;
2735 jermar 520
}
521
 
522
int unlink(const char *path)
523
{
524
    return _unlink(path, L_NONE);
525
}
526
 
527
int rmdir(const char *path)
528
{
529
    return _unlink(path, L_DIRECTORY);
530
}
531
 
2763 jermar 532
int rename(const char *old, const char *new)
533
{
534
    ipcarg_t rc;
535
    aid_t req;
536
 
4256 svoboda 537
    size_t olda_size;
538
    char *olda = absolutize(old, &olda_size);
2763 jermar 539
    if (!olda)
540
        return ENOMEM;
2771 jermar 541
 
4256 svoboda 542
    size_t newa_size;
543
    char *newa = absolutize(new, &newa_size);
2763 jermar 544
    if (!newa) {
545
        free(olda);
546
        return ENOMEM;
547
    }
548
 
549
    futex_down(&vfs_phone_futex);
550
    async_serialize_start();
4002 decky 551
    vfs_connect();
552
 
4584 jermar 553
    req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
4256 svoboda 554
    rc = ipc_data_write_start(vfs_phone, olda, olda_size);
2763 jermar 555
    if (rc != EOK) {
556
        async_wait_for(req, NULL);
557
        async_serialize_end();
558
        futex_up(&vfs_phone_futex);
559
        free(olda);
560
        free(newa);
561
        return (int) rc;
562
    }
4256 svoboda 563
    rc = ipc_data_write_start(vfs_phone, newa, newa_size);
2763 jermar 564
    if (rc != EOK) {
565
        async_wait_for(req, NULL);
566
        async_serialize_end();
567
        futex_up(&vfs_phone_futex);
568
        free(olda);
569
        free(newa);
570
        return (int) rc;
571
    }
572
    async_wait_for(req, &rc);
573
    async_serialize_end();
574
    futex_up(&vfs_phone_futex);
575
    free(olda);
576
    free(newa);
577
    return rc;
578
}
579
 
2755 jermar 580
int chdir(const char *path)
581
{
4256 svoboda 582
    size_t pa_size;
583
    char *pa = absolutize(path, &pa_size);
2755 jermar 584
    if (!pa)
585
        return ENOMEM;
586
 
2771 jermar 587
    DIR *d = opendir(pa);
2755 jermar 588
    if (!d) {
589
        free(pa);
590
        return ENOENT;
591
    }
592
 
593
    futex_down(&cwd_futex);
594
    if (cwd_dir) {
595
        closedir(cwd_dir);
596
        cwd_dir = NULL;
597
        free(cwd_path);
598
        cwd_path = NULL;
4256 svoboda 599
        cwd_size = 0;
2755 jermar 600
    }
601
    cwd_dir = d;
2771 jermar 602
    cwd_path = pa;
4256 svoboda 603
    cwd_size = pa_size;
2755 jermar 604
    futex_up(&cwd_futex);
3464 jermar 605
    return EOK;
2755 jermar 606
}
607
 
608
char *getcwd(char *buf, size_t size)
609
{
610
    if (!size)
611
        return NULL;
612
    futex_down(&cwd_futex);
4256 svoboda 613
    if (size < cwd_size + 1) {
2755 jermar 614
        futex_up(&cwd_futex);
615
        return NULL;
616
    }
4268 svoboda 617
    str_cpy(buf, size, cwd_path);
2755 jermar 618
    futex_up(&cwd_futex);
619
    return buf;
620
}
621
 
4585 jermar 622
int fd_phone(int fildes)
623
{
624
    struct stat stat;
625
    int rc;
626
 
627
    rc = fstat(fildes, &stat);
628
 
629
    if (!stat.devfs_stat.device)
630
        return -1;
631
 
632
    return devmap_device_connect(stat.devfs_stat.device, 0);
633
}
634
 
635
int fd_node(int fildes, fdi_node_t *node)
636
{
637
    struct stat stat;
638
    int rc;
639
 
640
    rc = fstat(fildes, &stat);
641
 
642
    if (rc == EOK) {
643
        node->fs_handle = stat.fs_handle;
644
        node->dev_handle = stat.dev_handle;
645
        node->index = stat.index;
646
    }
647
 
648
    return rc;
649
}
650
 
2671 jermar 651
/** @}
652
 */