Subversion Repositories HelenOS

Rev

Rev 3219 | Rev 3535 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3219 Rev 3403
1
/*
1
/*
2
 * Copyright (c) 2008 Jakub Jermar
2
 * Copyright (c) 2008 Jakub Jermar
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
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
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.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
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
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
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
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
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
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.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
/** @addtogroup libc
29
/** @addtogroup libc
30
 * @{
30
 * @{
31
 */
31
 */
32
/** @file
32
/** @file
33
 */
33
 */
34
 
34
 
35
#include <vfs/vfs.h>
35
#include <vfs/vfs.h>
36
#include <vfs/canonify.h>
36
#include <vfs/canonify.h>
37
#include <stdlib.h>
37
#include <stdlib.h>
38
#include <unistd.h>
38
#include <unistd.h>
39
#include <dirent.h>
39
#include <dirent.h>
40
#include <fcntl.h>
40
#include <fcntl.h>
41
#include <sys/stat.h>
41
#include <sys/stat.h>
42
#include <stdio.h>
42
#include <stdio.h>
43
#include <sys/types.h>
43
#include <sys/types.h>
44
#include <ipc/ipc.h>
44
#include <ipc/ipc.h>
45
#include <ipc/services.h>
45
#include <ipc/services.h>
46
#include <async.h>
46
#include <async.h>
47
#include <atomic.h>
47
#include <atomic.h>
48
#include <futex.h>
48
#include <futex.h>
49
#include <errno.h>
49
#include <errno.h>
50
#include <string.h>
50
#include <string.h>
51
#include <ipc/devmap.h>
51
#include <ipc/devmap.h>
52
#include "../../srv/vfs/vfs.h"
52
#include "../../srv/vfs/vfs.h"
53
 
53
 
54
int vfs_phone = -1;
54
int vfs_phone = -1;
55
futex_t vfs_phone_futex = FUTEX_INITIALIZER;
55
futex_t vfs_phone_futex = FUTEX_INITIALIZER;
56
 
56
 
57
futex_t cwd_futex = FUTEX_INITIALIZER;
57
futex_t cwd_futex = FUTEX_INITIALIZER;
58
DIR *cwd_dir = NULL;
58
DIR *cwd_dir = NULL;
59
char *cwd_path = NULL;
59
char *cwd_path = NULL;
60
size_t cwd_len = 0;
60
size_t cwd_len = 0;
61
 
61
 
62
static char *absolutize(const char *path, size_t *retlen)
62
char *absolutize(const char *path, size_t *retlen)
63
{
63
{
64
    char *ncwd_path;
64
    char *ncwd_path;
-
 
65
    char *ncwd_path_nc;
65
 
66
 
66
    futex_down(&cwd_futex);
67
    futex_down(&cwd_futex);
67
    size_t len = strlen(path);
68
    size_t len = strlen(path);
68
    if (*path != '/') {
69
    if (*path != '/') {
69
        if (!cwd_path) {
70
        if (!cwd_path) {
70
            futex_up(&cwd_futex);
71
            futex_up(&cwd_futex);
71
            return NULL;
72
            return NULL;
72
        }
73
        }
73
        ncwd_path = malloc(len + cwd_len + 1);
74
        ncwd_path_nc = malloc(cwd_len + 1 + len + 1);
74
        if (!ncwd_path) {
75
        if (!ncwd_path_nc) {
75
            futex_up(&cwd_futex);
76
            futex_up(&cwd_futex);
76
            return NULL;
77
            return NULL;
77
        }
78
        }
78
        strcpy(ncwd_path, cwd_path);
79
        strcpy(ncwd_path_nc, cwd_path);
79
        ncwd_path[cwd_len] = '/';
80
        ncwd_path_nc[cwd_len] = '/';
80
        ncwd_path[cwd_len + 1] = '\0';
81
        ncwd_path_nc[cwd_len + 1] = '\0';
81
    } else {
82
    } else {
82
        ncwd_path = malloc(len + 1);
83
        ncwd_path_nc = malloc(len + 1);
83
        if (!ncwd_path) {
84
        if (!ncwd_path_nc) {
84
            futex_up(&cwd_futex);
85
            futex_up(&cwd_futex);
85
            return NULL;
86
            return NULL;
86
        }
87
        }
87
        ncwd_path[0] = '\0';
88
        ncwd_path_nc[0] = '\0';
88
    }
89
    }
89
    strcat(ncwd_path, path);
90
    strcat(ncwd_path_nc, path);
90
    if (!canonify(ncwd_path, retlen)) {
91
    ncwd_path = canonify(ncwd_path_nc, retlen);
-
 
92
    if (!ncwd_path) {
-
 
93
        futex_up(&cwd_futex);
-
 
94
        free(ncwd_path_nc);
-
 
95
        return NULL;
-
 
96
    }
-
 
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) {
91
        futex_up(&cwd_futex);
105
        futex_up(&cwd_futex);
92
        free(ncwd_path);
-
 
93
        return NULL;
106
        return NULL;
94
    }
107
    }
95
    futex_up(&cwd_futex);
108
    futex_up(&cwd_futex);
96
    return ncwd_path;
109
    return ncwd_path;
97
}
110
}
98
 
111
 
99
static int vfs_connect(void)
112
static int vfs_connect(void)
100
{
113
{
101
    if (vfs_phone < 0)
114
    if (vfs_phone < 0)
102
        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
115
        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
103
    return vfs_phone;
116
    return vfs_phone;
104
}
117
}
105
 
118
 
106
static int device_get_handle(char *name, dev_handle_t *handle)
119
static int device_get_handle(char *name, dev_handle_t *handle)
107
{
120
{
108
    int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
121
    int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
-
 
122
        0);
109
    if (phone < 0)
123
    if (phone < 0)
110
        return phone;
124
        return phone;
111
   
125
   
112
    ipc_call_t answer;
126
    ipc_call_t answer;
113
    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
127
    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
114
        &answer);
128
        &answer);
115
   
129
   
116
    ipcarg_t retval = ipc_data_write_start(phone, name, strlen(name) + 1);
130
    ipcarg_t retval = ipc_data_write_start(phone, name, strlen(name) + 1);
117
 
131
 
118
    if (retval != EOK) {
132
    if (retval != EOK) {
119
        async_wait_for(req, NULL);
133
        async_wait_for(req, NULL);
120
        ipc_hangup(phone);
134
        ipc_hangup(phone);
121
        return retval;
135
        return retval;
122
    }
136
    }
123
 
137
 
124
    async_wait_for(req, &retval);
138
    async_wait_for(req, &retval);
125
 
139
 
126
    if (handle != NULL)
140
    if (handle != NULL)
127
        *handle = -1;
141
        *handle = -1;
128
   
142
   
129
    if (retval == EOK) {
143
    if (retval == EOK) {
130
        if (handle != NULL)
144
        if (handle != NULL)
131
            *handle = (dev_handle_t) IPC_GET_ARG1(answer);
145
            *handle = (dev_handle_t) IPC_GET_ARG1(answer);
132
    }
146
    }
133
   
147
   
134
    ipc_hangup(phone);
148
    ipc_hangup(phone);
135
    return retval;
149
    return retval;
136
}
150
}
137
 
151
 
138
int mount(const char *fs_name, const char *mp, const char *dev)
152
int mount(const char *fs_name, const char *mp, const char *dev)
139
{
153
{
140
    int res;
154
    int res;
141
    ipcarg_t rc;
155
    ipcarg_t rc;
142
    aid_t req;
156
    aid_t req;
143
    dev_handle_t dev_handle;
157
    dev_handle_t dev_handle;
144
   
158
   
145
    res = device_get_handle(dev, &dev_handle);
159
    res = device_get_handle(dev, &dev_handle);
146
    if (res != EOK)
160
    if (res != EOK)
147
        return res;
161
        return res;
148
   
162
   
149
    size_t mpa_len;
163
    size_t mpa_len;
150
    char *mpa = absolutize(mp, &mpa_len);
164
    char *mpa = absolutize(mp, &mpa_len);
151
    if (!mpa)
165
    if (!mpa)
152
        return ENOMEM;
166
        return ENOMEM;
153
 
167
 
154
    futex_down(&vfs_phone_futex);
168
    futex_down(&vfs_phone_futex);
155
    async_serialize_start();
169
    async_serialize_start();
156
    if (vfs_phone < 0) {
170
    if (vfs_phone < 0) {
157
        res = vfs_connect();
171
        res = vfs_connect();
158
        if (res < 0) {
172
        if (res < 0) {
159
            async_serialize_end();
173
            async_serialize_end();
160
            futex_up(&vfs_phone_futex);
174
            futex_up(&vfs_phone_futex);
161
            free(mpa);
175
            free(mpa);
162
            return res;
176
            return res;
163
        }
177
        }
164
    }
178
    }
165
    req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
179
    req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
166
    rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
180
    rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
167
    if (rc != EOK) {
181
    if (rc != EOK) {
168
        async_wait_for(req, NULL);
182
        async_wait_for(req, NULL);
169
        async_serialize_end();
183
        async_serialize_end();
170
        futex_up(&vfs_phone_futex);
184
        futex_up(&vfs_phone_futex);
171
        free(mpa);
185
        free(mpa);
172
        return (int) rc;
186
        return (int) rc;
173
    }
187
    }
-
 
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
    }
174
    rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
197
    rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
175
    if (rc != EOK) {
198
    if (rc != EOK) {
176
        async_wait_for(req, NULL);
199
        async_wait_for(req, NULL);
177
        async_serialize_end();
200
        async_serialize_end();
178
        futex_up(&vfs_phone_futex);
201
        futex_up(&vfs_phone_futex);
179
        free(mpa);
202
        free(mpa);
180
        return (int) rc;
203
        return (int) rc;
181
    }
204
    }
182
    async_wait_for(req, &rc);
205
    async_wait_for(req, &rc);
183
    async_serialize_end();
206
    async_serialize_end();
184
    futex_up(&vfs_phone_futex);
207
    futex_up(&vfs_phone_futex);
185
    free(mpa);
208
    free(mpa);
186
    return (int) rc;
209
    return (int) rc;
187
}
210
}
188
 
211
 
189
static int _open(const char *path, int lflag, int oflag, ...)
212
static int _open(const char *path, int lflag, int oflag, ...)
190
{
213
{
191
    int res;
214
    int res;
192
    ipcarg_t rc;
215
    ipcarg_t rc;
193
    ipc_call_t answer;
216
    ipc_call_t answer;
194
    aid_t req;
217
    aid_t req;
195
   
218
   
196
    size_t pa_len;
219
    size_t pa_len;
197
    char *pa = absolutize(path, &pa_len);
220
    char *pa = absolutize(path, &pa_len);
198
    if (!pa)
221
    if (!pa)
199
        return ENOMEM;
222
        return ENOMEM;
200
   
223
   
201
    futex_down(&vfs_phone_futex);
224
    futex_down(&vfs_phone_futex);
202
    async_serialize_start();
225
    async_serialize_start();
203
    if (vfs_phone < 0) {
226
    if (vfs_phone < 0) {
204
        res = vfs_connect();
227
        res = vfs_connect();
205
        if (res < 0) {
228
        if (res < 0) {
206
            async_serialize_end();
229
            async_serialize_end();
207
            futex_up(&vfs_phone_futex);
230
            futex_up(&vfs_phone_futex);
208
            free(pa);
231
            free(pa);
209
            return res;
232
            return res;
210
        }
233
        }
211
    }
234
    }
212
    req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
235
    req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
213
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
236
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
214
    if (rc != EOK) {
237
    if (rc != EOK) {
215
        async_wait_for(req, NULL);
238
        async_wait_for(req, NULL);
216
        async_serialize_end();
239
        async_serialize_end();
217
        futex_up(&vfs_phone_futex);
240
        futex_up(&vfs_phone_futex);
218
        free(pa);
241
        free(pa);
219
        return (int) rc;
242
        return (int) rc;
220
    }
243
    }
221
    async_wait_for(req, &rc);
244
    async_wait_for(req, &rc);
222
    async_serialize_end();
245
    async_serialize_end();
223
    futex_up(&vfs_phone_futex);
246
    futex_up(&vfs_phone_futex);
224
    free(pa);
247
    free(pa);
225
 
248
 
-
 
249
    if (rc != EOK)
226
    if (rc != EOK) return (int) rc;
250
        return (int) rc;
227
    return (int) IPC_GET_ARG1(answer);
251
    return (int) IPC_GET_ARG1(answer);
228
}
252
}
229
 
253
 
230
int open(const char *path, int oflag, ...)
254
int open(const char *path, int oflag, ...)
231
{
255
{
232
    return _open(path, L_FILE, oflag);
256
    return _open(path, L_FILE, oflag);
233
}
257
}
234
 
258
 
235
int close(int fildes)
259
int close(int fildes)
236
{
260
{
237
    int res;
261
    int res;
238
    ipcarg_t rc;
262
    ipcarg_t rc;
239
 
263
 
240
    futex_down(&vfs_phone_futex);
264
    futex_down(&vfs_phone_futex);
241
    async_serialize_start();
265
    async_serialize_start();
242
    if (vfs_phone < 0) {
266
    if (vfs_phone < 0) {
243
        res = vfs_connect();
267
        res = vfs_connect();
244
        if (res < 0) {
268
        if (res < 0) {
245
            async_serialize_end();
269
            async_serialize_end();
246
            futex_up(&vfs_phone_futex);
270
            futex_up(&vfs_phone_futex);
247
            return res;
271
            return res;
248
        }
272
        }
249
    }
273
    }
250
       
274
       
251
    rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
275
    rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
252
 
276
 
253
    async_serialize_end();
277
    async_serialize_end();
254
    futex_up(&vfs_phone_futex);
278
    futex_up(&vfs_phone_futex);
255
   
279
   
256
    return (int)rc;
280
    return (int)rc;
257
}
281
}
258
 
282
 
259
ssize_t read(int fildes, void *buf, size_t nbyte)
283
ssize_t read(int fildes, void *buf, size_t nbyte)
260
{
284
{
261
    int res;
285
    int res;
262
    ipcarg_t rc;
286
    ipcarg_t rc;
263
    ipc_call_t answer;
287
    ipc_call_t answer;
264
    aid_t req;
288
    aid_t req;
265
 
289
 
266
    futex_down(&vfs_phone_futex);
290
    futex_down(&vfs_phone_futex);
267
    async_serialize_start();
291
    async_serialize_start();
268
    if (vfs_phone < 0) {
292
    if (vfs_phone < 0) {
269
        res = vfs_connect();
293
        res = vfs_connect();
270
        if (res < 0) {
294
        if (res < 0) {
271
            async_serialize_end();
295
            async_serialize_end();
272
            futex_up(&vfs_phone_futex);
296
            futex_up(&vfs_phone_futex);
273
            return res;
297
            return res;
274
        }
298
        }
275
    }
299
    }
276
    req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
300
    req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
277
    rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
301
    rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
278
    if (rc != EOK) {
302
    if (rc != EOK) {
279
        async_wait_for(req, NULL);
303
        async_wait_for(req, NULL);
280
        async_serialize_end();
304
        async_serialize_end();
281
        futex_up(&vfs_phone_futex);
305
        futex_up(&vfs_phone_futex);
282
        return (ssize_t) rc;
306
        return (ssize_t) rc;
283
    }
307
    }
284
    async_wait_for(req, &rc);
308
    async_wait_for(req, &rc);
285
    async_serialize_end();
309
    async_serialize_end();
286
    futex_up(&vfs_phone_futex);
310
    futex_up(&vfs_phone_futex);
287
    if (rc == EOK)
311
    if (rc == EOK)
288
        return (ssize_t) IPC_GET_ARG1(answer);
312
        return (ssize_t) IPC_GET_ARG1(answer);
289
    else
313
    else
290
        return -1;
314
        return rc;
291
}
315
}
292
 
316
 
293
ssize_t write(int fildes, const void *buf, size_t nbyte)
317
ssize_t write(int fildes, const void *buf, size_t nbyte)
294
{
318
{
295
    int res;
319
    int res;
296
    ipcarg_t rc;
320
    ipcarg_t rc;
297
    ipc_call_t answer;
321
    ipc_call_t answer;
298
    aid_t req;
322
    aid_t req;
299
 
323
 
300
    futex_down(&vfs_phone_futex);
324
    futex_down(&vfs_phone_futex);
301
    async_serialize_start();
325
    async_serialize_start();
302
    if (vfs_phone < 0) {
326
    if (vfs_phone < 0) {
303
        res = vfs_connect();
327
        res = vfs_connect();
304
        if (res < 0) {
328
        if (res < 0) {
305
            async_serialize_end();
329
            async_serialize_end();
306
            futex_up(&vfs_phone_futex);
330
            futex_up(&vfs_phone_futex);
307
            return res;
331
            return res;
308
        }
332
        }
309
    }
333
    }
310
    req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
334
    req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
311
    rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
335
    rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
312
    if (rc != EOK) {
336
    if (rc != EOK) {
313
        async_wait_for(req, NULL);
337
        async_wait_for(req, NULL);
314
        async_serialize_end();
338
        async_serialize_end();
315
        futex_up(&vfs_phone_futex);
339
        futex_up(&vfs_phone_futex);
316
        return (ssize_t) rc;
340
        return (ssize_t) rc;
317
    }
341
    }
318
    async_wait_for(req, &rc);
342
    async_wait_for(req, &rc);
319
    async_serialize_end();
343
    async_serialize_end();
320
    futex_up(&vfs_phone_futex);
344
    futex_up(&vfs_phone_futex);
321
    if (rc == EOK)
345
    if (rc == EOK)
322
        return (ssize_t) IPC_GET_ARG1(answer);
346
        return (ssize_t) IPC_GET_ARG1(answer);
323
    else
347
    else
324
        return -1;
348
        return -1;
325
}
349
}
326
 
350
 
327
off_t lseek(int fildes, off_t offset, int whence)
351
off_t lseek(int fildes, off_t offset, int whence)
328
{
352
{
329
    int res;
353
    int res;
330
    ipcarg_t rc;
354
    ipcarg_t rc;
331
 
355
 
332
    futex_down(&vfs_phone_futex);
356
    futex_down(&vfs_phone_futex);
333
    async_serialize_start();
357
    async_serialize_start();
334
    if (vfs_phone < 0) {
358
    if (vfs_phone < 0) {
335
        res = vfs_connect();
359
        res = vfs_connect();
336
        if (res < 0) {
360
        if (res < 0) {
337
            async_serialize_end();
361
            async_serialize_end();
338
            futex_up(&vfs_phone_futex);
362
            futex_up(&vfs_phone_futex);
339
            return res;
363
            return res;
340
        }
364
        }
341
    }
365
    }
342
       
366
       
343
    off_t newoffs;
367
    off_t newoffs;
344
    rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
368
    rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
345
        (ipcarg_t)&newoffs);
369
        (ipcarg_t)&newoffs);
346
 
370
 
347
    async_serialize_end();
371
    async_serialize_end();
348
    futex_up(&vfs_phone_futex);
372
    futex_up(&vfs_phone_futex);
349
 
373
 
350
    if (rc != EOK)
374
    if (rc != EOK)
351
        return (off_t) -1;
375
        return (off_t) -1;
352
   
376
   
353
    return newoffs;
377
    return newoffs;
354
}
378
}
355
 
379
 
356
int ftruncate(int fildes, off_t length)
380
int ftruncate(int fildes, off_t length)
357
{
381
{
358
    int res;
382
    int res;
359
    ipcarg_t rc;
383
    ipcarg_t rc;
360
   
384
   
361
    futex_down(&vfs_phone_futex);
385
    futex_down(&vfs_phone_futex);
362
    async_serialize_start();
386
    async_serialize_start();
363
    if (vfs_phone < 0) {
387
    if (vfs_phone < 0) {
364
        res = vfs_connect();
388
        res = vfs_connect();
365
        if (res < 0) {
389
        if (res < 0) {
366
            async_serialize_end();
390
            async_serialize_end();
367
            futex_up(&vfs_phone_futex);
391
            futex_up(&vfs_phone_futex);
368
            return res;
392
            return res;
369
        }
393
        }
370
    }
394
    }
371
    rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
395
    rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
372
    async_serialize_end();
396
    async_serialize_end();
373
    futex_up(&vfs_phone_futex);
397
    futex_up(&vfs_phone_futex);
374
    return (int) rc;
398
    return (int) rc;
375
}
399
}
376
 
400
 
377
DIR *opendir(const char *dirname)
401
DIR *opendir(const char *dirname)
378
{
402
{
379
    DIR *dirp = malloc(sizeof(DIR));
403
    DIR *dirp = malloc(sizeof(DIR));
380
    if (!dirp)
404
    if (!dirp)
381
        return NULL;
405
        return NULL;
382
    dirp->fd = _open(dirname, L_DIRECTORY, 0);
406
    dirp->fd = _open(dirname, L_DIRECTORY, 0);
383
    if (dirp->fd < 0) {
407
    if (dirp->fd < 0) {
384
        free(dirp);
408
        free(dirp);
385
        return NULL;
409
        return NULL;
386
    }
410
    }
387
    return dirp;
411
    return dirp;
388
}
412
}
389
 
413
 
390
struct dirent *readdir(DIR *dirp)
414
struct dirent *readdir(DIR *dirp)
391
{
415
{
392
    ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
416
    ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
393
    if (len <= 0)
417
    if (len <= 0)
394
        return NULL;
418
        return NULL;
395
    return &dirp->res;
419
    return &dirp->res;
396
}
420
}
397
 
421
 
398
void rewinddir(DIR *dirp)
422
void rewinddir(DIR *dirp)
399
{
423
{
400
    (void) lseek(dirp->fd, 0, SEEK_SET);
424
    (void) lseek(dirp->fd, 0, SEEK_SET);
401
}
425
}
402
 
426
 
403
int closedir(DIR *dirp)
427
int closedir(DIR *dirp)
404
{
428
{
405
    (void) close(dirp->fd);
429
    (void) close(dirp->fd);
406
    free(dirp);
430
    free(dirp);
407
    return 0;
431
    return 0;
408
}
432
}
409
 
433
 
410
int mkdir(const char *path, mode_t mode)
434
int mkdir(const char *path, mode_t mode)
411
{
435
{
412
    int res;
436
    int res;
413
    ipcarg_t rc;
437
    ipcarg_t rc;
414
    aid_t req;
438
    aid_t req;
415
   
439
   
416
    size_t pa_len;
440
    size_t pa_len;
417
    char *pa = absolutize(path, &pa_len);
441
    char *pa = absolutize(path, &pa_len);
418
    if (!pa)
442
    if (!pa)
419
        return ENOMEM;
443
        return ENOMEM;
420
 
444
 
421
    futex_down(&vfs_phone_futex);
445
    futex_down(&vfs_phone_futex);
422
    async_serialize_start();
446
    async_serialize_start();
423
    if (vfs_phone < 0) {
447
    if (vfs_phone < 0) {
424
        res = vfs_connect();
448
        res = vfs_connect();
425
        if (res < 0) {
449
        if (res < 0) {
426
            async_serialize_end();
450
            async_serialize_end();
427
            futex_up(&vfs_phone_futex);
451
            futex_up(&vfs_phone_futex);
428
            free(pa);
452
            free(pa);
429
            return res;
453
            return res;
430
        }
454
        }
431
    }
455
    }
432
    req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
456
    req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
433
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
457
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
434
    if (rc != EOK) {
458
    if (rc != EOK) {
435
        async_wait_for(req, NULL);
459
        async_wait_for(req, NULL);
436
        async_serialize_end();
460
        async_serialize_end();
437
        futex_up(&vfs_phone_futex);
461
        futex_up(&vfs_phone_futex);
438
        free(pa);
462
        free(pa);
439
        return (int) rc;
463
        return (int) rc;
440
    }
464
    }
441
    async_wait_for(req, &rc);
465
    async_wait_for(req, &rc);
442
    async_serialize_end();
466
    async_serialize_end();
443
    futex_up(&vfs_phone_futex);
467
    futex_up(&vfs_phone_futex);
444
    free(pa);
468
    free(pa);
445
    return rc;
469
    return rc;
446
}
470
}
447
 
471
 
448
static int _unlink(const char *path, int lflag)
472
static int _unlink(const char *path, int lflag)
449
{
473
{
450
    int res;
474
    int res;
451
    ipcarg_t rc;
475
    ipcarg_t rc;
452
    aid_t req;
476
    aid_t req;
453
   
477
   
454
    size_t pa_len;
478
    size_t pa_len;
455
    char *pa = absolutize(path, &pa_len);
479
    char *pa = absolutize(path, &pa_len);
456
    if (!pa)
480
    if (!pa)
457
        return ENOMEM;
481
        return ENOMEM;
458
 
482
 
459
    futex_down(&vfs_phone_futex);
483
    futex_down(&vfs_phone_futex);
460
    async_serialize_start();
484
    async_serialize_start();
461
    if (vfs_phone < 0) {
485
    if (vfs_phone < 0) {
462
        res = vfs_connect();
486
        res = vfs_connect();
463
        if (res < 0) {
487
        if (res < 0) {
464
            async_serialize_end();
488
            async_serialize_end();
465
            futex_up(&vfs_phone_futex);
489
            futex_up(&vfs_phone_futex);
466
            free(pa);
490
            free(pa);
467
            return res;
491
            return res;
468
        }
492
        }
469
    }
493
    }
470
    req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
494
    req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
471
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
495
    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
472
    if (rc != EOK) {
496
    if (rc != EOK) {
473
        async_wait_for(req, NULL);
497
        async_wait_for(req, NULL);
474
        async_serialize_end();
498
        async_serialize_end();
475
        futex_up(&vfs_phone_futex);
499
        futex_up(&vfs_phone_futex);
476
        free(pa);
500
        free(pa);
477
        return (int) rc;
501
        return (int) rc;
478
    }
502
    }
479
    async_wait_for(req, &rc);
503
    async_wait_for(req, &rc);
480
    async_serialize_end();
504
    async_serialize_end();
481
    futex_up(&vfs_phone_futex);
505
    futex_up(&vfs_phone_futex);
482
    free(pa);
506
    free(pa);
483
    return rc;
507
    return rc;
484
}
508
}
485
 
509
 
486
int unlink(const char *path)
510
int unlink(const char *path)
487
{
511
{
488
    return _unlink(path, L_NONE);
512
    return _unlink(path, L_NONE);
489
}
513
}
490
 
514
 
491
int rmdir(const char *path)
515
int rmdir(const char *path)
492
{
516
{
493
    return _unlink(path, L_DIRECTORY);
517
    return _unlink(path, L_DIRECTORY);
494
}
518
}
495
 
519
 
496
int rename(const char *old, const char *new)
520
int rename(const char *old, const char *new)
497
{
521
{
498
    int res;
522
    int res;
499
    ipcarg_t rc;
523
    ipcarg_t rc;
500
    aid_t req;
524
    aid_t req;
501
   
525
   
502
    size_t olda_len;
526
    size_t olda_len;
503
    char *olda = absolutize(old, &olda_len);
527
    char *olda = absolutize(old, &olda_len);
504
    if (!olda)
528
    if (!olda)
505
        return ENOMEM;
529
        return ENOMEM;
506
 
530
 
507
    size_t newa_len;
531
    size_t newa_len;
508
    char *newa = absolutize(new, &newa_len);
532
    char *newa = absolutize(new, &newa_len);
509
    if (!newa) {
533
    if (!newa) {
510
        free(olda);
534
        free(olda);
511
        return ENOMEM;
535
        return ENOMEM;
512
    }
536
    }
513
 
537
 
514
    futex_down(&vfs_phone_futex);
538
    futex_down(&vfs_phone_futex);
515
    async_serialize_start();
539
    async_serialize_start();
516
    if (vfs_phone < 0) {
540
    if (vfs_phone < 0) {
517
        res = vfs_connect();
541
        res = vfs_connect();
518
        if (res < 0) {
542
        if (res < 0) {
519
            async_serialize_end();
543
            async_serialize_end();
520
            futex_up(&vfs_phone_futex);
544
            futex_up(&vfs_phone_futex);
521
            free(olda);
545
            free(olda);
522
            free(newa);
546
            free(newa);
523
            return res;
547
            return res;
524
        }
548
        }
525
    }
549
    }
526
    req = async_send_0(vfs_phone, VFS_RENAME, NULL);
550
    req = async_send_0(vfs_phone, VFS_RENAME, NULL);
527
    rc = ipc_data_write_start(vfs_phone, olda, olda_len);
551
    rc = ipc_data_write_start(vfs_phone, olda, olda_len);
528
    if (rc != EOK) {
552
    if (rc != EOK) {
529
        async_wait_for(req, NULL);
553
        async_wait_for(req, NULL);
530
        async_serialize_end();
554
        async_serialize_end();
531
        futex_up(&vfs_phone_futex);
555
        futex_up(&vfs_phone_futex);
532
        free(olda);
556
        free(olda);
533
        free(newa);
557
        free(newa);
534
        return (int) rc;
558
        return (int) rc;
535
    }
559
    }
536
    rc = ipc_data_write_start(vfs_phone, newa, newa_len);
560
    rc = ipc_data_write_start(vfs_phone, newa, newa_len);
537
    if (rc != EOK) {
561
    if (rc != EOK) {
538
        async_wait_for(req, NULL);
562
        async_wait_for(req, NULL);
539
        async_serialize_end();
563
        async_serialize_end();
540
        futex_up(&vfs_phone_futex);
564
        futex_up(&vfs_phone_futex);
541
        free(olda);
565
        free(olda);
542
        free(newa);
566
        free(newa);
543
        return (int) rc;
567
        return (int) rc;
544
    }
568
    }
545
    async_wait_for(req, &rc);
569
    async_wait_for(req, &rc);
546
    async_serialize_end();
570
    async_serialize_end();
547
    futex_up(&vfs_phone_futex);
571
    futex_up(&vfs_phone_futex);
548
    free(olda);
572
    free(olda);
549
    free(newa);
573
    free(newa);
550
    return rc;
574
    return rc;
551
}
575
}
552
 
576
 
553
int chdir(const char *path)
577
int chdir(const char *path)
554
{
578
{
555
    size_t pa_len;
579
    size_t pa_len;
556
    char *pa = absolutize(path, &pa_len);
580
    char *pa = absolutize(path, &pa_len);
557
    if (!pa)
581
    if (!pa)
558
        return ENOMEM;
582
        return ENOMEM;
559
 
583
 
560
    DIR *d = opendir(pa);
584
    DIR *d = opendir(pa);
561
    if (!d) {
585
    if (!d) {
562
        free(pa);
586
        free(pa);
563
        return ENOENT;
587
        return ENOENT;
564
    }
588
    }
565
 
589
 
566
    futex_down(&cwd_futex);
590
    futex_down(&cwd_futex);
567
    if (cwd_dir) {
591
    if (cwd_dir) {
568
        closedir(cwd_dir);
592
        closedir(cwd_dir);
569
        cwd_dir = NULL;
593
        cwd_dir = NULL;
570
        free(cwd_path);
594
        free(cwd_path);
571
        cwd_path = NULL;
595
        cwd_path = NULL;
572
        cwd_len = 0;
596
        cwd_len = 0;
573
    }
597
    }
574
    cwd_dir = d;
598
    cwd_dir = d;
575
    cwd_path = pa;
599
    cwd_path = pa;
576
    cwd_len = pa_len;
600
    cwd_len = pa_len;
577
    futex_up(&cwd_futex);
601
    futex_up(&cwd_futex);
578
}
602
}
579
 
603
 
580
char *getcwd(char *buf, size_t size)
604
char *getcwd(char *buf, size_t size)
581
{
605
{
582
    if (!size)
606
    if (!size)
583
        return NULL;
607
        return NULL;
584
    futex_down(&cwd_futex);
608
    futex_down(&cwd_futex);
585
    if (size < cwd_len + 1) {
609
    if (size < cwd_len + 1) {
586
        futex_up(&cwd_futex);
610
        futex_up(&cwd_futex);
587
        return NULL;
611
        return NULL;
588
    }
612
    }
589
    strcpy(buf, cwd_path);
613
    strcpy(buf, cwd_path);
590
    futex_up(&cwd_futex);
614
    futex_up(&cwd_futex);
591
    return buf;
615
    return buf;
592
}
616
}
593
 
617
 
594
/** @}
618
/** @}
595
 */
619
 */
596
 
620