Subversion Repositories HelenOS

Rev

Rev 4302 | Rev 4401 | 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>
2707 jermar 41
#include <sys/stat.h>
2771 jermar 42
#include <stdio.h>
2707 jermar 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>
3077 decky 51
#include <ipc/devmap.h>
3747 svoboda 52
#include "../../../srv/vfs/vfs.h"
2671 jermar 53
 
54
int vfs_phone = -1;
2755 jermar 55
futex_t vfs_phone_futex = FUTEX_INITIALIZER;
2671 jermar 56
 
2755 jermar 57
futex_t cwd_futex = FUTEX_INITIALIZER;
58
DIR *cwd_dir = NULL;
59
char *cwd_path = NULL;
4256 svoboda 60
size_t cwd_size = 0;
2755 jermar 61
 
3306 jermar 62
char *absolutize(const char *path, size_t *retlen)
2755 jermar 63
{
64
    char *ncwd_path;
3292 jermar 65
    char *ncwd_path_nc;
2755 jermar 66
 
67
    futex_down(&cwd_futex);
4256 svoboda 68
    size_t size = str_size(path);
2755 jermar 69
    if (*path != '/') {
70
        if (!cwd_path) {
71
            futex_up(&cwd_futex);
72
            return NULL;
73
        }
4256 svoboda 74
        ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
3292 jermar 75
        if (!ncwd_path_nc) {
2755 jermar 76
            futex_up(&cwd_futex);
77
            return NULL;
78
        }
4268 svoboda 79
        str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path);
4256 svoboda 80
        ncwd_path_nc[cwd_size] = '/';
81
        ncwd_path_nc[cwd_size + 1] = '\0';
2755 jermar 82
    } else {
4256 svoboda 83
        ncwd_path_nc = malloc(size + 1);
3292 jermar 84
        if (!ncwd_path_nc) {
2755 jermar 85
            futex_up(&cwd_futex);
86
            return NULL;
87
        }
3292 jermar 88
        ncwd_path_nc[0] = '\0';
2755 jermar 89
    }
4280 svoboda 90
    str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
3292 jermar 91
    ncwd_path = canonify(ncwd_path_nc, retlen);
92
    if (!ncwd_path) {
2771 jermar 93
        futex_up(&cwd_futex);
3292 jermar 94
        free(ncwd_path_nc);
2771 jermar 95
        return NULL;
96
    }
3292 jermar 97
    /*
98
     * We need to clone ncwd_path because canonify() works in-place and thus
99
     * the address in ncwd_path need not be the same as ncwd_path_nc, even
100
     * though they both point into the same dynamically allocated buffer.
101
     */
4266 svoboda 102
    ncwd_path = str_dup(ncwd_path);
3292 jermar 103
    free(ncwd_path_nc);
104
    if (!ncwd_path) {
105
        futex_up(&cwd_futex);
106
        return NULL;
107
    }
2755 jermar 108
    futex_up(&cwd_futex);
109
    return ncwd_path;
110
}
111
 
4002 decky 112
static void vfs_connect(void)
2671 jermar 113
{
4002 decky 114
    while (vfs_phone < 0)
115
        vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
2671 jermar 116
}
117
 
4002 decky 118
static int device_get_handle(const char *name, dev_handle_t *handle,
119
    const unsigned int flags)
3077 decky 120
{
4002 decky 121
    int phone;
122
 
123
    if (flags & IPC_FLAG_BLOCKING)
124
        phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
125
    else
126
        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
127
 
3077 decky 128
    if (phone < 0)
129
        return phone;
130
 
131
    ipc_call_t answer;
4002 decky 132
    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
3077 decky 133
        &answer);
134
 
4256 svoboda 135
    ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
4002 decky 136
 
3077 decky 137
    if (retval != EOK) {
138
        async_wait_for(req, NULL);
139
        ipc_hangup(phone);
140
        return retval;
141
    }
4002 decky 142
 
3077 decky 143
    async_wait_for(req, &retval);
4002 decky 144
 
3077 decky 145
    if (handle != NULL)
146
        *handle = -1;
147
 
148
    if (retval == EOK) {
149
        if (handle != NULL)
150
            *handle = (dev_handle_t) IPC_GET_ARG1(answer);
151
    }
152
 
153
    ipc_hangup(phone);
154
    return retval;
155
}
156
 
4002 decky 157
int mount(const char *fs_name, const char *mp, const char *dev,
4305 jermar 158
    const char *opts, const unsigned int flags)
2671 jermar 159
{
160
    int res;
161
    ipcarg_t rc;
162
    aid_t req;
3077 decky 163
    dev_handle_t dev_handle;
164
 
4002 decky 165
    res = device_get_handle(dev, &dev_handle, flags);
3077 decky 166
    if (res != EOK)
167
        return res;
168
 
4256 svoboda 169
    size_t mpa_size;
170
    char *mpa = absolutize(mp, &mpa_size);
2755 jermar 171
    if (!mpa)
172
        return ENOMEM;
4002 decky 173
 
2671 jermar 174
    futex_down(&vfs_phone_futex);
175
    async_serialize_start();
4002 decky 176
    vfs_connect();
177
 
178
    req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);
4256 svoboda 179
    rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
2671 jermar 180
    if (rc != EOK) {
181
        async_wait_for(req, NULL);
182
        async_serialize_end();
183
        futex_up(&vfs_phone_futex);
2755 jermar 184
        free(mpa);
2671 jermar 185
        return (int) rc;
186
    }
4002 decky 187
 
4305 jermar 188
    rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
189
    if (rc != EOK) {
190
        async_wait_for(req, NULL);
191
        async_serialize_end();
192
        futex_up(&vfs_phone_futex);
193
        free(mpa);
194
        return (int) rc;
195
    }
196
 
4256 svoboda 197
    rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
3255 jermar 198
    if (rc != EOK) {
199
        async_wait_for(req, NULL);
200
        async_serialize_end();
201
        futex_up(&vfs_phone_futex);
202
        free(mpa);
203
        return (int) rc;
204
    }
4302 jermar 205
 
206
    /* Ask VFS whether it likes fs_name. */
207
    rc = async_req_0_0(vfs_phone, IPC_M_PING);
208
    if (rc != EOK) {
209
        async_wait_for(req, NULL);
210
        async_serialize_end();
211
        futex_up(&vfs_phone_futex);
212
        free(mpa);
213
        return (int) rc;
214
    }
4002 decky 215
 
2671 jermar 216
    async_wait_for(req, &rc);
217
    async_serialize_end();
218
    futex_up(&vfs_phone_futex);
2755 jermar 219
    free(mpa);
4002 decky 220
 
2671 jermar 221
    return (int) rc;
222
}
223
 
2700 jermar 224
static int _open(const char *path, int lflag, int oflag, ...)
2671 jermar 225
{
226
    ipcarg_t rc;
227
    ipc_call_t answer;
228
    aid_t req;
229
 
4256 svoboda 230
    size_t pa_size;
231
    char *pa = absolutize(path, &pa_size);
2755 jermar 232
    if (!pa)
233
        return ENOMEM;
234
 
2671 jermar 235
    futex_down(&vfs_phone_futex);
236
    async_serialize_start();
4002 decky 237
    vfs_connect();
238
 
2700 jermar 239
    req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
4256 svoboda 240
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
2671 jermar 241
    if (rc != EOK) {
242
        async_wait_for(req, NULL);
243
        async_serialize_end();
244
        futex_up(&vfs_phone_futex);
2755 jermar 245
        free(pa);
2671 jermar 246
        return (int) rc;
247
    }
248
    async_wait_for(req, &rc);
249
    async_serialize_end();
250
    futex_up(&vfs_phone_futex);
2755 jermar 251
    free(pa);
3214 svoboda 252
 
3246 jermar 253
    if (rc != EOK)
254
        return (int) rc;
2671 jermar 255
    return (int) IPC_GET_ARG1(answer);
256
}
257
 
2700 jermar 258
int open(const char *path, int oflag, ...)
259
{
260
    return _open(path, L_FILE, oflag);
261
}
262
 
2707 jermar 263
int close(int fildes)
264
{
2734 jermar 265
    ipcarg_t rc;
4002 decky 266
 
2734 jermar 267
    futex_down(&vfs_phone_futex);
268
    async_serialize_start();
4002 decky 269
    vfs_connect();
270
 
2734 jermar 271
    rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
4002 decky 272
 
2734 jermar 273
    async_serialize_end();
274
    futex_up(&vfs_phone_futex);
275
 
276
    return (int)rc;
2707 jermar 277
}
278
 
2671 jermar 279
ssize_t read(int fildes, void *buf, size_t nbyte)
280
{
281
    ipcarg_t rc;
282
    ipc_call_t answer;
283
    aid_t req;
284
 
285
    futex_down(&vfs_phone_futex);
286
    async_serialize_start();
4002 decky 287
    vfs_connect();
288
 
2674 jermar 289
    req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
2741 jermar 290
    rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
291
    if (rc != EOK) {
2671 jermar 292
        async_wait_for(req, NULL);
293
        async_serialize_end();
294
        futex_up(&vfs_phone_futex);
295
        return (ssize_t) rc;
296
    }
297
    async_wait_for(req, &rc);
298
    async_serialize_end();
299
    futex_up(&vfs_phone_futex);
2710 jermar 300
    if (rc == EOK)
301
        return (ssize_t) IPC_GET_ARG1(answer);
302
    else
3313 jermar 303
        return rc;
2671 jermar 304
}
305
 
2674 jermar 306
ssize_t write(int fildes, const void *buf, size_t nbyte)
307
{
308
    ipcarg_t rc;
309
    ipc_call_t answer;
310
    aid_t req;
311
 
312
    futex_down(&vfs_phone_futex);
313
    async_serialize_start();
4002 decky 314
    vfs_connect();
315
 
2674 jermar 316
    req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
2741 jermar 317
    rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
318
    if (rc != EOK) {
2674 jermar 319
        async_wait_for(req, NULL);
320
        async_serialize_end();
321
        futex_up(&vfs_phone_futex);
322
        return (ssize_t) rc;
323
    }
324
    async_wait_for(req, &rc);
325
    async_serialize_end();
326
    futex_up(&vfs_phone_futex);
2710 jermar 327
    if (rc == EOK)
328
        return (ssize_t) IPC_GET_ARG1(answer);
329
    else
330
        return -1;
2674 jermar 331
}
2684 jermar 332
 
333
off_t lseek(int fildes, off_t offset, int whence)
334
{
335
    ipcarg_t rc;
336
 
337
    futex_down(&vfs_phone_futex);
338
    async_serialize_start();
4002 decky 339
    vfs_connect();
340
 
3488 svoboda 341
    ipcarg_t newoffs;
2684 jermar 342
    rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
3488 svoboda 343
        &newoffs);
2684 jermar 344
 
345
    async_serialize_end();
346
    futex_up(&vfs_phone_futex);
347
 
348
    if (rc != EOK)
349
        return (off_t) -1;
350
 
3488 svoboda 351
    return (off_t) newoffs;
2684 jermar 352
}
353
 
2693 jermar 354
int ftruncate(int fildes, off_t length)
355
{
356
    ipcarg_t rc;
357
 
358
    futex_down(&vfs_phone_futex);
359
    async_serialize_start();
4002 decky 360
    vfs_connect();
361
 
2693 jermar 362
    rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
363
    async_serialize_end();
364
    futex_up(&vfs_phone_futex);
365
    return (int) rc;
366
}
367
 
2694 jermar 368
DIR *opendir(const char *dirname)
369
{
370
    DIR *dirp = malloc(sizeof(DIR));
371
    if (!dirp)
372
        return NULL;
2700 jermar 373
    dirp->fd = _open(dirname, L_DIRECTORY, 0);
2699 jermar 374
    if (dirp->fd < 0) {
2694 jermar 375
        free(dirp);
376
        return NULL;
377
    }
378
    return dirp;
379
}
380
 
381
struct dirent *readdir(DIR *dirp)
382
{
2699 jermar 383
    ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
384
    if (len <= 0)
385
        return NULL;
386
    return &dirp->res;
2694 jermar 387
}
388
 
389
void rewinddir(DIR *dirp)
390
{
2699 jermar 391
    (void) lseek(dirp->fd, 0, SEEK_SET);
2694 jermar 392
}
393
 
394
int closedir(DIR *dirp)
395
{
396
    (void) close(dirp->fd);
397
    free(dirp);
398
    return 0;
399
}
400
 
2707 jermar 401
int mkdir(const char *path, mode_t mode)
2694 jermar 402
{
2707 jermar 403
    ipcarg_t rc;
404
    aid_t req;
405
 
4256 svoboda 406
    size_t pa_size;
407
    char *pa = absolutize(path, &pa_size);
2755 jermar 408
    if (!pa)
409
        return ENOMEM;
4002 decky 410
 
2707 jermar 411
    futex_down(&vfs_phone_futex);
412
    async_serialize_start();
4002 decky 413
    vfs_connect();
414
 
2735 jermar 415
    req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
4256 svoboda 416
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
2707 jermar 417
    if (rc != EOK) {
418
        async_wait_for(req, NULL);
419
        async_serialize_end();
420
        futex_up(&vfs_phone_futex);
2755 jermar 421
        free(pa);
2707 jermar 422
        return (int) rc;
423
    }
424
    async_wait_for(req, &rc);
425
    async_serialize_end();
426
    futex_up(&vfs_phone_futex);
2755 jermar 427
    free(pa);
2761 jermar 428
    return rc;
2694 jermar 429
}
430
 
2735 jermar 431
static int _unlink(const char *path, int lflag)
432
{
433
    ipcarg_t rc;
434
    aid_t req;
435
 
4256 svoboda 436
    size_t pa_size;
437
    char *pa = absolutize(path, &pa_size);
2755 jermar 438
    if (!pa)
439
        return ENOMEM;
2771 jermar 440
 
2735 jermar 441
    futex_down(&vfs_phone_futex);
442
    async_serialize_start();
4002 decky 443
    vfs_connect();
444
 
2735 jermar 445
    req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
4256 svoboda 446
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
2735 jermar 447
    if (rc != EOK) {
448
        async_wait_for(req, NULL);
449
        async_serialize_end();
450
        futex_up(&vfs_phone_futex);
2755 jermar 451
        free(pa);
2735 jermar 452
        return (int) rc;
453
    }
454
    async_wait_for(req, &rc);
455
    async_serialize_end();
456
    futex_up(&vfs_phone_futex);
2755 jermar 457
    free(pa);
2761 jermar 458
    return rc;
2735 jermar 459
}
460
 
461
int unlink(const char *path)
462
{
463
    return _unlink(path, L_NONE);
464
}
465
 
466
int rmdir(const char *path)
467
{
468
    return _unlink(path, L_DIRECTORY);
469
}
470
 
2763 jermar 471
int rename(const char *old, const char *new)
472
{
473
    ipcarg_t rc;
474
    aid_t req;
475
 
4256 svoboda 476
    size_t olda_size;
477
    char *olda = absolutize(old, &olda_size);
2763 jermar 478
    if (!olda)
479
        return ENOMEM;
2771 jermar 480
 
4256 svoboda 481
    size_t newa_size;
482
    char *newa = absolutize(new, &newa_size);
2763 jermar 483
    if (!newa) {
484
        free(olda);
485
        return ENOMEM;
486
    }
487
 
488
    futex_down(&vfs_phone_futex);
489
    async_serialize_start();
4002 decky 490
    vfs_connect();
491
 
2763 jermar 492
    req = async_send_0(vfs_phone, VFS_RENAME, NULL);
4256 svoboda 493
    rc = ipc_data_write_start(vfs_phone, olda, olda_size);
2763 jermar 494
    if (rc != EOK) {
495
        async_wait_for(req, NULL);
496
        async_serialize_end();
497
        futex_up(&vfs_phone_futex);
498
        free(olda);
499
        free(newa);
500
        return (int) rc;
501
    }
4256 svoboda 502
    rc = ipc_data_write_start(vfs_phone, newa, newa_size);
2763 jermar 503
    if (rc != EOK) {
504
        async_wait_for(req, NULL);
505
        async_serialize_end();
506
        futex_up(&vfs_phone_futex);
507
        free(olda);
508
        free(newa);
509
        return (int) rc;
510
    }
511
    async_wait_for(req, &rc);
512
    async_serialize_end();
513
    futex_up(&vfs_phone_futex);
514
    free(olda);
515
    free(newa);
516
    return rc;
517
}
518
 
2755 jermar 519
int chdir(const char *path)
520
{
4256 svoboda 521
    size_t pa_size;
522
    char *pa = absolutize(path, &pa_size);
2755 jermar 523
    if (!pa)
524
        return ENOMEM;
525
 
2771 jermar 526
    DIR *d = opendir(pa);
2755 jermar 527
    if (!d) {
528
        free(pa);
529
        return ENOENT;
530
    }
531
 
532
    futex_down(&cwd_futex);
533
    if (cwd_dir) {
534
        closedir(cwd_dir);
535
        cwd_dir = NULL;
536
        free(cwd_path);
537
        cwd_path = NULL;
4256 svoboda 538
        cwd_size = 0;
2755 jermar 539
    }
540
    cwd_dir = d;
2771 jermar 541
    cwd_path = pa;
4256 svoboda 542
    cwd_size = pa_size;
2755 jermar 543
    futex_up(&cwd_futex);
3464 jermar 544
    return EOK;
2755 jermar 545
}
546
 
547
char *getcwd(char *buf, size_t size)
548
{
549
    if (!size)
550
        return NULL;
551
    futex_down(&cwd_futex);
4256 svoboda 552
    if (size < cwd_size + 1) {
2755 jermar 553
        futex_up(&cwd_futex);
554
        return NULL;
555
    }
4268 svoboda 556
    str_cpy(buf, size, cwd_path);
2755 jermar 557
    futex_up(&cwd_futex);
558
    return buf;
559
}
560
 
2671 jermar 561
/** @}
562
 */