Subversion Repositories HelenOS

Rev

Rev 3343 | 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
 */
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>
2671 jermar 52
#include "../../srv/vfs/vfs.h"
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;
60
size_t cwd_len = 0;
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);
68
    size_t len = strlen(path);
69
    if (*path != '/') {
70
        if (!cwd_path) {
71
            futex_up(&cwd_futex);
72
            return NULL;
73
        }
3328 jermar 74
        ncwd_path_nc = malloc(cwd_len + 1 + len + 1);
3292 jermar 75
        if (!ncwd_path_nc) {
2755 jermar 76
            futex_up(&cwd_futex);
77
            return NULL;
78
        }
3292 jermar 79
        strcpy(ncwd_path_nc, cwd_path);
80
        ncwd_path_nc[cwd_len] = '/';
81
        ncwd_path_nc[cwd_len + 1] = '\0';
2755 jermar 82
    } else {
3292 jermar 83
        ncwd_path_nc = malloc(len + 1);
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
    }
3292 jermar 90
    strcat(ncwd_path_nc, path);
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
     */
102
    ncwd_path = strdup(ncwd_path);
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
 
2671 jermar 112
static int vfs_connect(void)
113
{
114
    if (vfs_phone < 0)
115
        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
116
    return vfs_phone;
117
}
118
 
3492 rimsky 119
static int device_get_handle(const char *name, dev_handle_t *handle)
3077 decky 120
{
3246 jermar 121
    int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
122
        0);
3077 decky 123
    if (phone < 0)
124
        return phone;
125
 
126
    ipc_call_t answer;
127
    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
128
        &answer);
129
 
130
    ipcarg_t retval = ipc_data_write_start(phone, name, strlen(name) + 1);
131
 
132
    if (retval != EOK) {
133
        async_wait_for(req, NULL);
134
        ipc_hangup(phone);
135
        return retval;
136
    }
137
 
138
    async_wait_for(req, &retval);
139
 
140
    if (handle != NULL)
141
        *handle = -1;
142
 
143
    if (retval == EOK) {
144
        if (handle != NULL)
145
            *handle = (dev_handle_t) IPC_GET_ARG1(answer);
146
    }
147
 
148
    ipc_hangup(phone);
149
    return retval;
150
}
151
 
2671 jermar 152
int mount(const char *fs_name, const char *mp, const char *dev)
153
{
154
    int res;
155
    ipcarg_t rc;
156
    aid_t req;
3077 decky 157
    dev_handle_t dev_handle;
158
 
159
    res = device_get_handle(dev, &dev_handle);
160
    if (res != EOK)
161
        return res;
162
 
2771 jermar 163
    size_t mpa_len;
164
    char *mpa = absolutize(mp, &mpa_len);
2755 jermar 165
    if (!mpa)
166
        return ENOMEM;
167
 
2671 jermar 168
    futex_down(&vfs_phone_futex);
169
    async_serialize_start();
170
    if (vfs_phone < 0) {
171
        res = vfs_connect();
172
        if (res < 0) {
173
            async_serialize_end();
174
            futex_up(&vfs_phone_futex);
2755 jermar 175
            free(mpa);
2671 jermar 176
            return res;
177
        }
178
    }
179
    req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
2678 jermar 180
    rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
2671 jermar 181
    if (rc != EOK) {
182
        async_wait_for(req, NULL);
183
        async_serialize_end();
184
        futex_up(&vfs_phone_futex);
2755 jermar 185
        free(mpa);
2671 jermar 186
        return (int) rc;
187
    }
3255 jermar 188
    /* Ask VFS whether it likes fs_name. */
189
    rc = async_req_0_0(vfs_phone, IPC_M_PING);
190
    if (rc != EOK) {
191
        async_wait_for(req, NULL);
192
        async_serialize_end();
193
        futex_up(&vfs_phone_futex);
194
        free(mpa);
195
        return (int) rc;
196
    }
2771 jermar 197
    rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
2671 jermar 198
    if (rc != EOK) {
199
        async_wait_for(req, NULL);
200
        async_serialize_end();
201
        futex_up(&vfs_phone_futex);
2755 jermar 202
        free(mpa);
2671 jermar 203
        return (int) rc;
204
    }
205
    async_wait_for(req, &rc);
206
    async_serialize_end();
207
    futex_up(&vfs_phone_futex);
2755 jermar 208
    free(mpa);
2671 jermar 209
    return (int) rc;
210
}
211
 
2700 jermar 212
static int _open(const char *path, int lflag, int oflag, ...)
2671 jermar 213
{
214
    int res;
215
    ipcarg_t rc;
216
    ipc_call_t answer;
217
    aid_t req;
218
 
2771 jermar 219
    size_t pa_len;
220
    char *pa = absolutize(path, &pa_len);
2755 jermar 221
    if (!pa)
222
        return ENOMEM;
223
 
2671 jermar 224
    futex_down(&vfs_phone_futex);
225
    async_serialize_start();
226
    if (vfs_phone < 0) {
227
        res = vfs_connect();
228
        if (res < 0) {
229
            async_serialize_end();
230
            futex_up(&vfs_phone_futex);
2755 jermar 231
            free(pa);
2671 jermar 232
            return res;
233
        }
234
    }
2700 jermar 235
    req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
2771 jermar 236
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
2671 jermar 237
    if (rc != EOK) {
238
        async_wait_for(req, NULL);
239
        async_serialize_end();
240
        futex_up(&vfs_phone_futex);
2755 jermar 241
        free(pa);
2671 jermar 242
        return (int) rc;
243
    }
244
    async_wait_for(req, &rc);
245
    async_serialize_end();
246
    futex_up(&vfs_phone_futex);
2755 jermar 247
    free(pa);
3214 svoboda 248
 
3246 jermar 249
    if (rc != EOK)
250
        return (int) rc;
2671 jermar 251
    return (int) IPC_GET_ARG1(answer);
252
}
253
 
2700 jermar 254
int open(const char *path, int oflag, ...)
255
{
256
    return _open(path, L_FILE, oflag);
257
}
258
 
2707 jermar 259
int close(int fildes)
260
{
2734 jermar 261
    int res;
262
    ipcarg_t rc;
263
 
264
    futex_down(&vfs_phone_futex);
265
    async_serialize_start();
266
    if (vfs_phone < 0) {
267
        res = vfs_connect();
268
        if (res < 0) {
269
            async_serialize_end();
270
            futex_up(&vfs_phone_futex);
271
            return res;
272
        }
273
    }
274
 
275
    rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
276
 
277
    async_serialize_end();
278
    futex_up(&vfs_phone_futex);
279
 
280
    return (int)rc;
2707 jermar 281
}
282
 
2671 jermar 283
ssize_t read(int fildes, void *buf, size_t nbyte)
284
{
285
    int res;
286
    ipcarg_t rc;
287
    ipc_call_t answer;
288
    aid_t req;
289
 
290
    futex_down(&vfs_phone_futex);
291
    async_serialize_start();
292
    if (vfs_phone < 0) {
293
        res = vfs_connect();
294
        if (res < 0) {
295
            async_serialize_end();
296
            futex_up(&vfs_phone_futex);
297
            return res;
298
        }
299
    }
2674 jermar 300
    req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
2741 jermar 301
    rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
302
    if (rc != EOK) {
2671 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
3313 jermar 314
        return rc;
2671 jermar 315
}
316
 
2674 jermar 317
ssize_t write(int fildes, const void *buf, size_t nbyte)
318
{
319
    int res;
320
    ipcarg_t rc;
321
    ipc_call_t answer;
322
    aid_t req;
323
 
324
    futex_down(&vfs_phone_futex);
325
    async_serialize_start();
326
    if (vfs_phone < 0) {
327
        res = vfs_connect();
328
        if (res < 0) {
329
            async_serialize_end();
330
            futex_up(&vfs_phone_futex);
331
            return res;
332
        }
333
    }
334
    req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
2741 jermar 335
    rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
336
    if (rc != EOK) {
2674 jermar 337
        async_wait_for(req, NULL);
338
        async_serialize_end();
339
        futex_up(&vfs_phone_futex);
340
        return (ssize_t) rc;
341
    }
342
    async_wait_for(req, &rc);
343
    async_serialize_end();
344
    futex_up(&vfs_phone_futex);
2710 jermar 345
    if (rc == EOK)
346
        return (ssize_t) IPC_GET_ARG1(answer);
347
    else
348
        return -1;
2674 jermar 349
}
2684 jermar 350
 
351
off_t lseek(int fildes, off_t offset, int whence)
352
{
353
    int res;
354
    ipcarg_t rc;
355
 
356
    futex_down(&vfs_phone_futex);
357
    async_serialize_start();
358
    if (vfs_phone < 0) {
359
        res = vfs_connect();
360
        if (res < 0) {
361
            async_serialize_end();
362
            futex_up(&vfs_phone_futex);
363
            return res;
364
        }
365
    }
366
 
3492 rimsky 367
    ipcarg_t newoffs;
2684 jermar 368
    rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
3492 rimsky 369
        &newoffs);
2684 jermar 370
 
371
    async_serialize_end();
372
    futex_up(&vfs_phone_futex);
373
 
374
    if (rc != EOK)
375
        return (off_t) -1;
376
 
3492 rimsky 377
    return (off_t) newoffs;
2684 jermar 378
}
379
 
2693 jermar 380
int ftruncate(int fildes, off_t length)
381
{
382
    int res;
383
    ipcarg_t rc;
384
 
385
    futex_down(&vfs_phone_futex);
386
    async_serialize_start();
387
    if (vfs_phone < 0) {
388
        res = vfs_connect();
389
        if (res < 0) {
390
            async_serialize_end();
391
            futex_up(&vfs_phone_futex);
392
            return res;
393
        }
394
    }
395
    rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
396
    async_serialize_end();
397
    futex_up(&vfs_phone_futex);
398
    return (int) rc;
399
}
400
 
2694 jermar 401
DIR *opendir(const char *dirname)
402
{
403
    DIR *dirp = malloc(sizeof(DIR));
404
    if (!dirp)
405
        return NULL;
2700 jermar 406
    dirp->fd = _open(dirname, L_DIRECTORY, 0);
2699 jermar 407
    if (dirp->fd < 0) {
2694 jermar 408
        free(dirp);
409
        return NULL;
410
    }
411
    return dirp;
412
}
413
 
414
struct dirent *readdir(DIR *dirp)
415
{
2699 jermar 416
    ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
417
    if (len <= 0)
418
        return NULL;
419
    return &dirp->res;
2694 jermar 420
}
421
 
422
void rewinddir(DIR *dirp)
423
{
2699 jermar 424
    (void) lseek(dirp->fd, 0, SEEK_SET);
2694 jermar 425
}
426
 
427
int closedir(DIR *dirp)
428
{
429
    (void) close(dirp->fd);
430
    free(dirp);
431
    return 0;
432
}
433
 
2707 jermar 434
int mkdir(const char *path, mode_t mode)
2694 jermar 435
{
2707 jermar 436
    int res;
437
    ipcarg_t rc;
438
    aid_t req;
439
 
2771 jermar 440
    size_t pa_len;
441
    char *pa = absolutize(path, &pa_len);
2755 jermar 442
    if (!pa)
443
        return ENOMEM;
444
 
2707 jermar 445
    futex_down(&vfs_phone_futex);
446
    async_serialize_start();
447
    if (vfs_phone < 0) {
448
        res = vfs_connect();
449
        if (res < 0) {
450
            async_serialize_end();
451
            futex_up(&vfs_phone_futex);
2755 jermar 452
            free(pa);
2707 jermar 453
            return res;
454
        }
455
    }
2735 jermar 456
    req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
2771 jermar 457
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
2707 jermar 458
    if (rc != EOK) {
459
        async_wait_for(req, NULL);
460
        async_serialize_end();
461
        futex_up(&vfs_phone_futex);
2755 jermar 462
        free(pa);
2707 jermar 463
        return (int) rc;
464
    }
465
    async_wait_for(req, &rc);
466
    async_serialize_end();
467
    futex_up(&vfs_phone_futex);
2755 jermar 468
    free(pa);
2761 jermar 469
    return rc;
2694 jermar 470
}
471
 
2735 jermar 472
static int _unlink(const char *path, int lflag)
473
{
474
    int res;
475
    ipcarg_t rc;
476
    aid_t req;
477
 
2771 jermar 478
    size_t pa_len;
479
    char *pa = absolutize(path, &pa_len);
2755 jermar 480
    if (!pa)
481
        return ENOMEM;
2771 jermar 482
 
2735 jermar 483
    futex_down(&vfs_phone_futex);
484
    async_serialize_start();
485
    if (vfs_phone < 0) {
486
        res = vfs_connect();
487
        if (res < 0) {
488
            async_serialize_end();
489
            futex_up(&vfs_phone_futex);
2755 jermar 490
            free(pa);
2735 jermar 491
            return res;
492
        }
493
    }
494
    req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
2771 jermar 495
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
2735 jermar 496
    if (rc != EOK) {
497
        async_wait_for(req, NULL);
498
        async_serialize_end();
499
        futex_up(&vfs_phone_futex);
2755 jermar 500
        free(pa);
2735 jermar 501
        return (int) rc;
502
    }
503
    async_wait_for(req, &rc);
504
    async_serialize_end();
505
    futex_up(&vfs_phone_futex);
2755 jermar 506
    free(pa);
2761 jermar 507
    return rc;
2735 jermar 508
}
509
 
510
int unlink(const char *path)
511
{
512
    return _unlink(path, L_NONE);
513
}
514
 
515
int rmdir(const char *path)
516
{
517
    return _unlink(path, L_DIRECTORY);
518
}
519
 
2763 jermar 520
int rename(const char *old, const char *new)
521
{
522
    int res;
523
    ipcarg_t rc;
524
    aid_t req;
525
 
2771 jermar 526
    size_t olda_len;
527
    char *olda = absolutize(old, &olda_len);
2763 jermar 528
    if (!olda)
529
        return ENOMEM;
2771 jermar 530
 
531
    size_t newa_len;
532
    char *newa = absolutize(new, &newa_len);
2763 jermar 533
    if (!newa) {
534
        free(olda);
535
        return ENOMEM;
536
    }
537
 
538
    futex_down(&vfs_phone_futex);
539
    async_serialize_start();
540
    if (vfs_phone < 0) {
541
        res = vfs_connect();
542
        if (res < 0) {
543
            async_serialize_end();
544
            futex_up(&vfs_phone_futex);
545
            free(olda);
546
            free(newa);
547
            return res;
548
        }
549
    }
550
    req = async_send_0(vfs_phone, VFS_RENAME, NULL);
2771 jermar 551
    rc = ipc_data_write_start(vfs_phone, olda, olda_len);
2763 jermar 552
    if (rc != EOK) {
553
        async_wait_for(req, NULL);
554
        async_serialize_end();
555
        futex_up(&vfs_phone_futex);
556
        free(olda);
557
        free(newa);
558
        return (int) rc;
559
    }
2771 jermar 560
    rc = ipc_data_write_start(vfs_phone, newa, newa_len);
2763 jermar 561
    if (rc != EOK) {
562
        async_wait_for(req, NULL);
563
        async_serialize_end();
564
        futex_up(&vfs_phone_futex);
565
        free(olda);
566
        free(newa);
567
        return (int) rc;
568
    }
569
    async_wait_for(req, &rc);
570
    async_serialize_end();
571
    futex_up(&vfs_phone_futex);
572
    free(olda);
573
    free(newa);
574
    return rc;
575
}
576
 
2755 jermar 577
int chdir(const char *path)
578
{
2771 jermar 579
    size_t pa_len;
580
    char *pa = absolutize(path, &pa_len);
2755 jermar 581
    if (!pa)
582
        return ENOMEM;
583
 
2771 jermar 584
    DIR *d = opendir(pa);
2755 jermar 585
    if (!d) {
586
        free(pa);
587
        return ENOENT;
588
    }
589
 
590
    futex_down(&cwd_futex);
591
    if (cwd_dir) {
592
        closedir(cwd_dir);
593
        cwd_dir = NULL;
594
        free(cwd_path);
595
        cwd_path = NULL;
596
        cwd_len = 0;
597
    }
598
    cwd_dir = d;
2771 jermar 599
    cwd_path = pa;
600
    cwd_len = pa_len;
2755 jermar 601
    futex_up(&cwd_futex);
3492 rimsky 602
    return EOK;
2755 jermar 603
}
604
 
605
char *getcwd(char *buf, size_t size)
606
{
607
    if (!size)
608
        return NULL;
609
    futex_down(&cwd_futex);
610
    if (size < cwd_len + 1) {
611
        futex_up(&cwd_futex);
612
        return NULL;
613
    }
614
    strcpy(buf, cwd_path);
615
    futex_up(&cwd_futex);
616
    return buf;
617
}
618
 
2671 jermar 619
/** @}
620
 */