source: mainline/uspace/lib/libc/generic/vfs/vfs.c@ 566f4cfb

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 566f4cfb was 594303b, checked in by Jakub Jermar <jakub@…>, 16 years ago

Support mount options.
Let tmpfs decide whether to start empty or restored a TMPFS dump based on the mount option.
  • Property mode set to 100644
File size: 11.6 KB
Line 
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 libc
30 * @{
31 */
32/** @file
33 */
34
35#include <vfs/vfs.h>
36#include <vfs/canonify.h>
37#include <stdlib.h>
38#include <unistd.h>
39#include <dirent.h>
40#include <fcntl.h>
41#include <sys/stat.h>
42#include <stdio.h>
43#include <sys/types.h>
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>
51#include <ipc/devmap.h>
52#include "../../../srv/vfs/vfs.h"
53
54int vfs_phone = -1;
55futex_t vfs_phone_futex = FUTEX_INITIALIZER;
56
57futex_t cwd_futex = FUTEX_INITIALIZER;
58DIR *cwd_dir = NULL;
59char *cwd_path = NULL;
60size_t cwd_size = 0;
61
62char *absolutize(const char *path, size_t *retlen)
63{
64 char *ncwd_path;
65 char *ncwd_path_nc;
66
67 futex_down(&cwd_futex);
68 size_t size = str_size(path);
69 if (*path != '/') {
70 if (!cwd_path) {
71 futex_up(&cwd_futex);
72 return NULL;
73 }
74 ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
75 if (!ncwd_path_nc) {
76 futex_up(&cwd_futex);
77 return NULL;
78 }
79 str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path);
80 ncwd_path_nc[cwd_size] = '/';
81 ncwd_path_nc[cwd_size + 1] = '\0';
82 } else {
83 ncwd_path_nc = malloc(size + 1);
84 if (!ncwd_path_nc) {
85 futex_up(&cwd_futex);
86 return NULL;
87 }
88 ncwd_path_nc[0] = '\0';
89 }
90 str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
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 = str_dup(ncwd_path);
103 free(ncwd_path_nc);
104 if (!ncwd_path) {
105 futex_up(&cwd_futex);
106 return NULL;
107 }
108 futex_up(&cwd_futex);
109 return ncwd_path;
110}
111
112static void vfs_connect(void)
113{
114 while (vfs_phone < 0)
115 vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
116}
117
118static int device_get_handle(const char *name, dev_handle_t *handle,
119 const unsigned int flags)
120{
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
128 if (phone < 0)
129 return phone;
130
131 ipc_call_t answer;
132 aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
133 &answer);
134
135 ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
136
137 if (retval != EOK) {
138 async_wait_for(req, NULL);
139 ipc_hangup(phone);
140 return retval;
141 }
142
143 async_wait_for(req, &retval);
144
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
157int mount(const char *fs_name, const char *mp, const char *dev,
158 const char *opts, const unsigned int flags)
159{
160 int res;
161 ipcarg_t rc;
162 aid_t req;
163 dev_handle_t dev_handle;
164
165 res = device_get_handle(dev, &dev_handle, flags);
166 if (res != EOK)
167 return res;
168
169 size_t mpa_size;
170 char *mpa = absolutize(mp, &mpa_size);
171 if (!mpa)
172 return ENOMEM;
173
174 futex_down(&vfs_phone_futex);
175 async_serialize_start();
176 vfs_connect();
177
178 req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);
179 rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
180 if (rc != EOK) {
181 async_wait_for(req, NULL);
182 async_serialize_end();
183 futex_up(&vfs_phone_futex);
184 free(mpa);
185 return (int) rc;
186 }
187
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
197 rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
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 }
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 }
215
216 async_wait_for(req, &rc);
217 async_serialize_end();
218 futex_up(&vfs_phone_futex);
219 free(mpa);
220
221 return (int) rc;
222}
223
224static int _open(const char *path, int lflag, int oflag, ...)
225{
226 ipcarg_t rc;
227 ipc_call_t answer;
228 aid_t req;
229
230 size_t pa_size;
231 char *pa = absolutize(path, &pa_size);
232 if (!pa)
233 return ENOMEM;
234
235 futex_down(&vfs_phone_futex);
236 async_serialize_start();
237 vfs_connect();
238
239 req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
240 rc = ipc_data_write_start(vfs_phone, pa, pa_size);
241 if (rc != EOK) {
242 async_wait_for(req, NULL);
243 async_serialize_end();
244 futex_up(&vfs_phone_futex);
245 free(pa);
246 return (int) rc;
247 }
248 async_wait_for(req, &rc);
249 async_serialize_end();
250 futex_up(&vfs_phone_futex);
251 free(pa);
252
253 if (rc != EOK)
254 return (int) rc;
255 return (int) IPC_GET_ARG1(answer);
256}
257
258int open(const char *path, int oflag, ...)
259{
260 return _open(path, L_FILE, oflag);
261}
262
263int close(int fildes)
264{
265 ipcarg_t rc;
266
267 futex_down(&vfs_phone_futex);
268 async_serialize_start();
269 vfs_connect();
270
271 rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
272
273 async_serialize_end();
274 futex_up(&vfs_phone_futex);
275
276 return (int)rc;
277}
278
279ssize_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();
287 vfs_connect();
288
289 req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
290 rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
291 if (rc != EOK) {
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);
300 if (rc == EOK)
301 return (ssize_t) IPC_GET_ARG1(answer);
302 else
303 return rc;
304}
305
306ssize_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();
314 vfs_connect();
315
316 req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
317 rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
318 if (rc != EOK) {
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);
327 if (rc == EOK)
328 return (ssize_t) IPC_GET_ARG1(answer);
329 else
330 return -1;
331}
332
333off_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();
339 vfs_connect();
340
341 ipcarg_t newoffs;
342 rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
343 &newoffs);
344
345 async_serialize_end();
346 futex_up(&vfs_phone_futex);
347
348 if (rc != EOK)
349 return (off_t) -1;
350
351 return (off_t) newoffs;
352}
353
354int ftruncate(int fildes, off_t length)
355{
356 ipcarg_t rc;
357
358 futex_down(&vfs_phone_futex);
359 async_serialize_start();
360 vfs_connect();
361
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
368DIR *opendir(const char *dirname)
369{
370 DIR *dirp = malloc(sizeof(DIR));
371 if (!dirp)
372 return NULL;
373 dirp->fd = _open(dirname, L_DIRECTORY, 0);
374 if (dirp->fd < 0) {
375 free(dirp);
376 return NULL;
377 }
378 return dirp;
379}
380
381struct dirent *readdir(DIR *dirp)
382{
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;
387}
388
389void rewinddir(DIR *dirp)
390{
391 (void) lseek(dirp->fd, 0, SEEK_SET);
392}
393
394int closedir(DIR *dirp)
395{
396 (void) close(dirp->fd);
397 free(dirp);
398 return 0;
399}
400
401int mkdir(const char *path, mode_t mode)
402{
403 ipcarg_t rc;
404 aid_t req;
405
406 size_t pa_size;
407 char *pa = absolutize(path, &pa_size);
408 if (!pa)
409 return ENOMEM;
410
411 futex_down(&vfs_phone_futex);
412 async_serialize_start();
413 vfs_connect();
414
415 req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
416 rc = ipc_data_write_start(vfs_phone, pa, pa_size);
417 if (rc != EOK) {
418 async_wait_for(req, NULL);
419 async_serialize_end();
420 futex_up(&vfs_phone_futex);
421 free(pa);
422 return (int) rc;
423 }
424 async_wait_for(req, &rc);
425 async_serialize_end();
426 futex_up(&vfs_phone_futex);
427 free(pa);
428 return rc;
429}
430
431static int _unlink(const char *path, int lflag)
432{
433 ipcarg_t rc;
434 aid_t req;
435
436 size_t pa_size;
437 char *pa = absolutize(path, &pa_size);
438 if (!pa)
439 return ENOMEM;
440
441 futex_down(&vfs_phone_futex);
442 async_serialize_start();
443 vfs_connect();
444
445 req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
446 rc = ipc_data_write_start(vfs_phone, pa, pa_size);
447 if (rc != EOK) {
448 async_wait_for(req, NULL);
449 async_serialize_end();
450 futex_up(&vfs_phone_futex);
451 free(pa);
452 return (int) rc;
453 }
454 async_wait_for(req, &rc);
455 async_serialize_end();
456 futex_up(&vfs_phone_futex);
457 free(pa);
458 return rc;
459}
460
461int unlink(const char *path)
462{
463 return _unlink(path, L_NONE);
464}
465
466int rmdir(const char *path)
467{
468 return _unlink(path, L_DIRECTORY);
469}
470
471int rename(const char *old, const char *new)
472{
473 ipcarg_t rc;
474 aid_t req;
475
476 size_t olda_size;
477 char *olda = absolutize(old, &olda_size);
478 if (!olda)
479 return ENOMEM;
480
481 size_t newa_size;
482 char *newa = absolutize(new, &newa_size);
483 if (!newa) {
484 free(olda);
485 return ENOMEM;
486 }
487
488 futex_down(&vfs_phone_futex);
489 async_serialize_start();
490 vfs_connect();
491
492 req = async_send_0(vfs_phone, VFS_RENAME, NULL);
493 rc = ipc_data_write_start(vfs_phone, olda, olda_size);
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 }
502 rc = ipc_data_write_start(vfs_phone, newa, newa_size);
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
519int chdir(const char *path)
520{
521 size_t pa_size;
522 char *pa = absolutize(path, &pa_size);
523 if (!pa)
524 return ENOMEM;
525
526 DIR *d = opendir(pa);
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;
538 cwd_size = 0;
539 }
540 cwd_dir = d;
541 cwd_path = pa;
542 cwd_size = pa_size;
543 futex_up(&cwd_futex);
544 return EOK;
545}
546
547char *getcwd(char *buf, size_t size)
548{
549 if (!size)
550 return NULL;
551 futex_down(&cwd_futex);
552 if (size < cwd_size + 1) {
553 futex_up(&cwd_futex);
554 return NULL;
555 }
556 str_cpy(buf, size, cwd_path);
557 futex_up(&cwd_futex);
558 return buf;
559}
560
561/** @}
562 */
Note: See TracBrowser for help on using the repository browser.