source: mainline/uspace/srv/vfs/vfs_ops.c@ d9f4c76

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

Synchronize access to pending_req.
  • Property mode set to 100644
File size: 32.2 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 fs
30 * @{
31 */
32
33/**
34 * @file vfs_ops.c
35 * @brief Operations that VFS offers to its clients.
36 */
37
38#include "vfs.h"
39#include <ipc/ipc.h>
40#include <async.h>
41#include <errno.h>
42#include <stdio.h>
43#include <stdlib.h>
44#include <string.h>
45#include <bool.h>
46#include <futex.h>
47#include <fibril_sync.h>
48#include <adt/list.h>
49#include <unistd.h>
50#include <ctype.h>
51#include <fcntl.h>
52#include <assert.h>
53#include <vfs/canonify.h>
54
55/* Forward declarations of static functions. */
56static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, size_t);
57
58/** Pending mount structure. */
59typedef struct {
60 link_t link;
61 char *fs_name; /**< File system name */
62 char *mp; /**< Mount point */
63 char *opts; /**< Mount options. */
64 ipc_callid_t callid; /**< Call ID waiting for the mount */
65 ipc_callid_t rid; /**< Request ID */
66 dev_handle_t dev_handle; /**< Device handle */
67} pending_req_t;
68
69FIBRIL_MUTEX_INITIALIZE(pending_lock);
70LIST_INITIALIZE(pending_req);
71
72/**
73 * This rwlock prevents the race between a triplet-to-VFS-node resolution and a
74 * concurrent VFS operation which modifies the file system namespace.
75 */
76FIBRIL_RWLOCK_INITIALIZE(namespace_rwlock);
77
78vfs_pair_t rootfs = {
79 .fs_handle = 0,
80 .dev_handle = 0
81};
82
83static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
84 fs_handle_t fs_handle, char *mp, char *opts)
85{
86 vfs_lookup_res_t mp_res;
87 vfs_lookup_res_t mr_res;
88 vfs_node_t *mp_node = NULL;
89 vfs_node_t *mr_node;
90 fs_index_t rindex;
91 size_t rsize;
92 unsigned rlnkcnt;
93 ipcarg_t rc;
94 int phone;
95 aid_t msg;
96 ipc_call_t answer;
97
98 /* Resolve the path to the mountpoint. */
99 fibril_rwlock_write_lock(&namespace_rwlock);
100 if (rootfs.fs_handle) {
101 /* We already have the root FS. */
102 if (str_cmp(mp, "/") == 0) {
103 /* Trying to mount root FS over root FS */
104 fibril_rwlock_write_unlock(&namespace_rwlock);
105 ipc_answer_0(rid, EBUSY);
106 return;
107 }
108
109 rc = vfs_lookup_internal(mp, L_DIRECTORY, &mp_res, NULL);
110 if (rc != EOK) {
111 /* The lookup failed for some reason. */
112 fibril_rwlock_write_unlock(&namespace_rwlock);
113 ipc_answer_0(rid, rc);
114 return;
115 }
116
117 mp_node = vfs_node_get(&mp_res);
118 if (!mp_node) {
119 fibril_rwlock_write_unlock(&namespace_rwlock);
120 ipc_answer_0(rid, ENOMEM);
121 return;
122 }
123
124 /*
125 * Now we hold a reference to mp_node.
126 * It will be dropped upon the corresponding VFS_UNMOUNT.
127 * This prevents the mount point from being deleted.
128 */
129 } else {
130 /* We still don't have the root file system mounted. */
131 if (str_cmp(mp, "/") == 0) {
132 /*
133 * For this simple, but important case,
134 * we are almost done.
135 */
136
137 /* Tell the mountee that it is being mounted. */
138 phone = vfs_grab_phone(fs_handle);
139 msg = async_send_1(phone, VFS_MOUNTED,
140 (ipcarg_t) dev_handle, &answer);
141 /* send the mount options */
142 rc = ipc_data_write_start(phone, (void *)opts,
143 str_size(opts));
144 if (rc != EOK) {
145 vfs_release_phone(phone);
146 async_wait_for(msg, NULL);
147 fibril_rwlock_write_unlock(&namespace_rwlock);
148 ipc_answer_0(rid, rc);
149 return;
150 }
151 vfs_release_phone(phone);
152 async_wait_for(msg, &rc);
153
154 if (rc != EOK) {
155 fibril_rwlock_write_unlock(&namespace_rwlock);
156 ipc_answer_0(rid, rc);
157 return;
158 }
159
160 rindex = (fs_index_t) IPC_GET_ARG1(answer);
161 rsize = (size_t) IPC_GET_ARG2(answer);
162 rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
163
164 mr_res.triplet.fs_handle = fs_handle;
165 mr_res.triplet.dev_handle = dev_handle;
166 mr_res.triplet.index = rindex;
167 mr_res.size = rsize;
168 mr_res.lnkcnt = rlnkcnt;
169 mr_res.type = VFS_NODE_DIRECTORY;
170
171 rootfs.fs_handle = fs_handle;
172 rootfs.dev_handle = dev_handle;
173
174 /* Add reference to the mounted root. */
175 mr_node = vfs_node_get(&mr_res);
176 assert(mr_node);
177
178 fibril_rwlock_write_unlock(&namespace_rwlock);
179 ipc_answer_0(rid, rc);
180 return;
181 } else {
182 /*
183 * We can't resolve this without the root filesystem
184 * being mounted first.
185 */
186 fibril_rwlock_write_unlock(&namespace_rwlock);
187 ipc_answer_0(rid, ENOENT);
188 return;
189 }
190 }
191
192 /*
193 * At this point, we have all necessary pieces: file system and device
194 * handles, and we know the mount point VFS node.
195 */
196
197 int mountee_phone = vfs_grab_phone(fs_handle);
198 assert(mountee_phone >= 0);
199 vfs_release_phone(mountee_phone);
200
201 phone = vfs_grab_phone(mp_res.triplet.fs_handle);
202 msg = async_send_4(phone, VFS_MOUNT,
203 (ipcarg_t) mp_res.triplet.dev_handle,
204 (ipcarg_t) mp_res.triplet.index,
205 (ipcarg_t) fs_handle,
206 (ipcarg_t) dev_handle, &answer);
207
208 /* send connection */
209 rc = async_req_1_0(phone, IPC_M_CONNECTION_CLONE, mountee_phone);
210 if (rc != EOK) {
211 vfs_release_phone(phone);
212 async_wait_for(msg, NULL);
213 /* Mount failed, drop reference to mp_node. */
214 if (mp_node)
215 vfs_node_put(mp_node);
216 ipc_answer_0(rid, rc);
217 fibril_rwlock_write_unlock(&namespace_rwlock);
218 return;
219 }
220
221 /* send the mount options */
222 rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
223 if (rc != EOK) {
224 vfs_release_phone(phone);
225 async_wait_for(msg, NULL);
226 /* Mount failed, drop reference to mp_node. */
227 if (mp_node)
228 vfs_node_put(mp_node);
229 fibril_rwlock_write_unlock(&namespace_rwlock);
230 ipc_answer_0(rid, rc);
231 return;
232 }
233 vfs_release_phone(phone);
234 async_wait_for(msg, &rc);
235
236 if (rc == EOK) {
237 rindex = (fs_index_t) IPC_GET_ARG1(answer);
238 rsize = (size_t) IPC_GET_ARG2(answer);
239 rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
240
241 mr_res.triplet.fs_handle = fs_handle;
242 mr_res.triplet.dev_handle = dev_handle;
243 mr_res.triplet.index = rindex;
244 mr_res.size = rsize;
245 mr_res.lnkcnt = rlnkcnt;
246 mr_res.type = VFS_NODE_DIRECTORY;
247
248 /* Add reference to the mounted root. */
249 mr_node = vfs_node_get(&mr_res);
250 assert(mr_node);
251 } else {
252 /* Mount failed, drop reference to mp_node. */
253 if (mp_node)
254 vfs_node_put(mp_node);
255 }
256
257 ipc_answer_0(rid, rc);
258 fibril_rwlock_write_unlock(&namespace_rwlock);
259}
260
261/** Process pending mount requests */
262void vfs_process_pending_mount(void)
263{
264 link_t *cur;
265
266loop:
267 fibril_mutex_lock(&pending_lock);
268 for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
269 pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
270
271 fs_handle_t fs_handle = fs_name_to_handle(pr->fs_name, true);
272 if (!fs_handle)
273 continue;
274
275 /* Acknowledge that we know fs_name. */
276 ipc_answer_0(pr->callid, EOK);
277
278 /* Do the mount */
279 vfs_mount_internal(pr->rid, pr->dev_handle, fs_handle, pr->mp,
280 pr->opts);
281
282 free(pr->fs_name);
283 free(pr->mp);
284 free(pr->opts);
285 list_remove(cur);
286 free(pr);
287 fibril_mutex_unlock(&pending_lock);
288 fibril_yield();
289 goto loop;
290 }
291 fibril_mutex_unlock(&pending_lock);
292}
293
294void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
295{
296 /*
297 * We expect the library to do the device-name to device-handle
298 * translation for us, thus the device handle will arrive as ARG1
299 * in the request.
300 */
301 dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
302
303 /*
304 * Mount flags are passed as ARG2.
305 */
306 unsigned int flags = (unsigned int) IPC_GET_ARG2(*request);
307
308 /*
309 * For now, don't make use of ARG3, but it can be used to
310 * carry mount options in the future.
311 */
312
313 /* We want the client to send us the mount point. */
314 ipc_callid_t callid;
315 size_t size;
316 if (!ipc_data_write_receive(&callid, &size)) {
317 ipc_answer_0(callid, EINVAL);
318 ipc_answer_0(rid, EINVAL);
319 return;
320 }
321
322 /* Check whether size is reasonable wrt. the mount point. */
323 if ((size < 1) || (size > MAX_PATH_LEN)) {
324 ipc_answer_0(callid, EINVAL);
325 ipc_answer_0(rid, EINVAL);
326 return;
327 }
328
329 /* Allocate buffer for the mount point data being received. */
330 char *mp = malloc(size + 1);
331 if (!mp) {
332 ipc_answer_0(callid, ENOMEM);
333 ipc_answer_0(rid, ENOMEM);
334 return;
335 }
336
337 /* Deliver the mount point. */
338 ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
339 if (retval != EOK) {
340 ipc_answer_0(rid, retval);
341 free(mp);
342 return;
343 }
344 mp[size] = '\0';
345
346 /* Now we expect to receive the mount options. */
347 if (!ipc_data_write_receive(&callid, &size)) {
348 ipc_answer_0(callid, EINVAL);
349 ipc_answer_0(rid, EINVAL);
350 free(mp);
351 return;
352 }
353
354 /* Check the offered options size. */
355 if (size < 0 || size > MAX_MNTOPTS_LEN) {
356 ipc_answer_0(callid, EINVAL);
357 ipc_answer_0(rid, EINVAL);
358 free(mp);
359 return;
360 }
361
362 /* Allocate buffer for the mount options. */
363 char *opts = (char *) malloc(size + 1);
364 if (!opts) {
365 ipc_answer_0(callid, ENOMEM);
366 ipc_answer_0(rid, ENOMEM);
367 free(mp);
368 return;
369 }
370
371 /* Deliver the mount options. */
372 retval = ipc_data_write_finalize(callid, opts, size);
373 if (retval != EOK) {
374 ipc_answer_0(rid, retval);
375 free(mp);
376 free(opts);
377 return;
378 }
379 opts[size] = '\0';
380
381 /*
382 * Now, we expect the client to send us data with the name of the file
383 * system.
384 */
385 if (!ipc_data_write_receive(&callid, &size)) {
386 ipc_answer_0(callid, EINVAL);
387 ipc_answer_0(rid, EINVAL);
388 free(mp);
389 free(opts);
390 return;
391 }
392
393 /*
394 * Don't receive more than is necessary for storing a full file system
395 * name.
396 */
397 if ((size < 1) || (size > FS_NAME_MAXLEN)) {
398 ipc_answer_0(callid, EINVAL);
399 ipc_answer_0(rid, EINVAL);
400 free(mp);
401 free(opts);
402 return;
403 }
404
405 /*
406 * Allocate buffer for file system name.
407 */
408 char *fs_name = (char *) malloc(size + 1);
409 if (fs_name == NULL) {
410 ipc_answer_0(callid, ENOMEM);
411 ipc_answer_0(rid, ENOMEM);
412 free(mp);
413 free(opts);
414 return;
415 }
416
417 /* Deliver the file system name. */
418 retval = ipc_data_write_finalize(callid, fs_name, size);
419 if (retval != EOK) {
420 ipc_answer_0(rid, retval);
421 free(mp);
422 free(opts);
423 free(fs_name);
424 return;
425 }
426 fs_name[size] = '\0';
427
428 /*
429 * Wait for IPC_M_PING so that we can return an error if we don't know
430 * fs_name.
431 */
432 ipc_call_t data;
433 callid = async_get_call(&data);
434 if (IPC_GET_METHOD(data) != IPC_M_PING) {
435 ipc_answer_0(callid, ENOTSUP);
436 ipc_answer_0(rid, ENOTSUP);
437 free(mp);
438 free(opts);
439 free(fs_name);
440 return;
441 }
442
443 /*
444 * Check if we know a file system with the same name as is in fs_name.
445 * This will also give us its file system handle.
446 */
447 fs_handle_t fs_handle = fs_name_to_handle(fs_name, true);
448 if (!fs_handle) {
449 if (flags & IPC_FLAG_BLOCKING) {
450 pending_req_t *pr;
451
452 /* Blocking mount, add to pending list */
453 pr = (pending_req_t *) malloc(sizeof(pending_req_t));
454 if (!pr) {
455 ipc_answer_0(callid, ENOMEM);
456 ipc_answer_0(rid, ENOMEM);
457 free(mp);
458 free(fs_name);
459 free(opts);
460 return;
461 }
462
463 pr->fs_name = fs_name;
464 pr->mp = mp;
465 pr->opts = opts;
466 pr->callid = callid;
467 pr->rid = rid;
468 pr->dev_handle = dev_handle;
469 link_initialize(&pr->link);
470 fibril_mutex_lock(&pending_lock);
471 list_append(&pr->link, &pending_req);
472 fibril_mutex_unlock(&pending_lock);
473 return;
474 }
475
476 ipc_answer_0(callid, ENOENT);
477 ipc_answer_0(rid, ENOENT);
478 free(mp);
479 free(fs_name);
480 free(opts);
481 return;
482 }
483
484 /* Acknowledge that we know fs_name. */
485 ipc_answer_0(callid, EOK);
486
487 /* Do the mount */
488 vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
489 free(mp);
490 free(fs_name);
491 free(opts);
492}
493
494void vfs_open(ipc_callid_t rid, ipc_call_t *request)
495{
496 if (!vfs_files_init()) {
497 ipc_answer_0(rid, ENOMEM);
498 return;
499 }
500
501 /*
502 * The POSIX interface is open(path, oflag, mode).
503 * We can receive oflags and mode along with the VFS_OPEN call; the path
504 * will need to arrive in another call.
505 *
506 * We also receive one private, non-POSIX set of flags called lflag
507 * used to pass information to vfs_lookup_internal().
508 */
509 int lflag = IPC_GET_ARG1(*request);
510 int oflag = IPC_GET_ARG2(*request);
511 int mode = IPC_GET_ARG3(*request);
512 size_t len;
513
514 /*
515 * Make sure that we are called with exactly one of L_FILE and
516 * L_DIRECTORY. Make sure that the user does not pass L_OPEN.
517 */
518 if (((lflag & (L_FILE | L_DIRECTORY)) == 0) ||
519 ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
520 ((lflag & L_OPEN) != 0)) {
521 ipc_answer_0(rid, EINVAL);
522 return;
523 }
524
525 if (oflag & O_CREAT)
526 lflag |= L_CREATE;
527 if (oflag & O_EXCL)
528 lflag |= L_EXCLUSIVE;
529
530 ipc_callid_t callid;
531 if (!ipc_data_write_receive(&callid, &len)) {
532 ipc_answer_0(callid, EINVAL);
533 ipc_answer_0(rid, EINVAL);
534 return;
535 }
536
537 char *path = malloc(len + 1);
538 if (!path) {
539 ipc_answer_0(callid, ENOMEM);
540 ipc_answer_0(rid, ENOMEM);
541 return;
542 }
543
544 int rc;
545 if ((rc = ipc_data_write_finalize(callid, path, len))) {
546 ipc_answer_0(rid, rc);
547 free(path);
548 return;
549 }
550 path[len] = '\0';
551
552 /*
553 * Avoid the race condition in which the file can be deleted before we
554 * find/create-and-lock the VFS node corresponding to the looked-up
555 * triplet.
556 */
557 if (lflag & L_CREATE)
558 fibril_rwlock_write_lock(&namespace_rwlock);
559 else
560 fibril_rwlock_read_lock(&namespace_rwlock);
561
562 /* The path is now populated and we can call vfs_lookup_internal(). */
563 vfs_lookup_res_t lr;
564 rc = vfs_lookup_internal(path, lflag | L_OPEN, &lr, NULL);
565 if (rc != EOK) {
566 if (lflag & L_CREATE)
567 fibril_rwlock_write_unlock(&namespace_rwlock);
568 else
569 fibril_rwlock_read_unlock(&namespace_rwlock);
570 ipc_answer_0(rid, rc);
571 free(path);
572 return;
573 }
574
575 /* Path is no longer needed. */
576 free(path);
577
578 vfs_node_t *node = vfs_node_get(&lr);
579 if (lflag & L_CREATE)
580 fibril_rwlock_write_unlock(&namespace_rwlock);
581 else
582 fibril_rwlock_read_unlock(&namespace_rwlock);
583
584 /* Truncate the file if requested and if necessary. */
585 if (oflag & O_TRUNC) {
586 fibril_rwlock_write_lock(&node->contents_rwlock);
587 if (node->size) {
588 rc = vfs_truncate_internal(node->fs_handle,
589 node->dev_handle, node->index, 0);
590 if (rc) {
591 fibril_rwlock_write_unlock(&node->contents_rwlock);
592 vfs_node_put(node);
593 ipc_answer_0(rid, rc);
594 return;
595 }
596 node->size = 0;
597 }
598 fibril_rwlock_write_unlock(&node->contents_rwlock);
599 }
600
601 /*
602 * Get ourselves a file descriptor and the corresponding vfs_file_t
603 * structure.
604 */
605 int fd = vfs_fd_alloc();
606 if (fd < 0) {
607 vfs_node_put(node);
608 ipc_answer_0(rid, fd);
609 return;
610 }
611 vfs_file_t *file = vfs_file_get(fd);
612 file->node = node;
613 if (oflag & O_APPEND)
614 file->append = true;
615
616 /*
617 * The following increase in reference count is for the fact that the
618 * file is being opened and that a file structure is pointing to it.
619 * It is necessary so that the file will not disappear when
620 * vfs_node_put() is called. The reference will be dropped by the
621 * respective VFS_CLOSE.
622 */
623 vfs_node_addref(node);
624 vfs_node_put(node);
625
626 /* Success! Return the new file descriptor to the client. */
627 ipc_answer_1(rid, EOK, fd);
628}
629
630void vfs_open_node(ipc_callid_t rid, ipc_call_t *request)
631{
632 // FIXME: check for sanity of the supplied fs, dev and index
633
634 if (!vfs_files_init()) {
635 ipc_answer_0(rid, ENOMEM);
636 return;
637 }
638
639 /*
640 * The interface is open_node(fs, dev, index, oflag).
641 */
642 vfs_lookup_res_t lr;
643
644 lr.triplet.fs_handle = IPC_GET_ARG1(*request);
645 lr.triplet.dev_handle = IPC_GET_ARG2(*request);
646 lr.triplet.index = IPC_GET_ARG3(*request);
647 int oflag = IPC_GET_ARG4(*request);
648
649 fibril_rwlock_read_lock(&namespace_rwlock);
650
651 int rc = vfs_open_node_internal(&lr);
652 if (rc != EOK) {
653 fibril_rwlock_read_unlock(&namespace_rwlock);
654 ipc_answer_0(rid, rc);
655 return;
656 }
657
658 vfs_node_t *node = vfs_node_get(&lr);
659 fibril_rwlock_read_unlock(&namespace_rwlock);
660
661 /* Truncate the file if requested and if necessary. */
662 if (oflag & O_TRUNC) {
663 fibril_rwlock_write_lock(&node->contents_rwlock);
664 if (node->size) {
665 rc = vfs_truncate_internal(node->fs_handle,
666 node->dev_handle, node->index, 0);
667 if (rc) {
668 fibril_rwlock_write_unlock(&node->contents_rwlock);
669 vfs_node_put(node);
670 ipc_answer_0(rid, rc);
671 return;
672 }
673 node->size = 0;
674 }
675 fibril_rwlock_write_unlock(&node->contents_rwlock);
676 }
677
678 /*
679 * Get ourselves a file descriptor and the corresponding vfs_file_t
680 * structure.
681 */
682 int fd = vfs_fd_alloc();
683 if (fd < 0) {
684 vfs_node_put(node);
685 ipc_answer_0(rid, fd);
686 return;
687 }
688 vfs_file_t *file = vfs_file_get(fd);
689 file->node = node;
690 if (oflag & O_APPEND)
691 file->append = true;
692
693 /*
694 * The following increase in reference count is for the fact that the
695 * file is being opened and that a file structure is pointing to it.
696 * It is necessary so that the file will not disappear when
697 * vfs_node_put() is called. The reference will be dropped by the
698 * respective VFS_CLOSE.
699 */
700 vfs_node_addref(node);
701 vfs_node_put(node);
702
703 /* Success! Return the new file descriptor to the client. */
704 ipc_answer_1(rid, EOK, fd);
705}
706
707void vfs_node(ipc_callid_t rid, ipc_call_t *request)
708{
709 int fd = IPC_GET_ARG1(*request);
710
711 /* Lookup the file structure corresponding to the file descriptor. */
712 vfs_file_t *file = vfs_file_get(fd);
713 if (!file) {
714 ipc_answer_0(rid, ENOENT);
715 return;
716 }
717
718 ipc_answer_3(rid, EOK, file->node->fs_handle, file->node->dev_handle,
719 file->node->index);
720}
721
722void vfs_device(ipc_callid_t rid, ipc_call_t *request)
723{
724 int fd = IPC_GET_ARG1(*request);
725
726 /* Lookup the file structure corresponding to the file descriptor. */
727 vfs_file_t *file = vfs_file_get(fd);
728 if (!file) {
729 ipc_answer_0(rid, ENOENT);
730 return;
731 }
732
733 /*
734 * Lock the open file structure so that no other thread can manipulate
735 * the same open file at a time.
736 */
737 fibril_mutex_lock(&file->lock);
738 int fs_phone = vfs_grab_phone(file->node->fs_handle);
739
740 /* Make a VFS_DEVICE request at the destination FS server. */
741 aid_t msg;
742 ipc_call_t answer;
743 msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
744 file->node->dev_handle, file->node->index, &answer);
745
746 vfs_release_phone(fs_phone);
747
748 /* Wait for reply from the FS server. */
749 ipcarg_t rc;
750 async_wait_for(msg, &rc);
751
752 fibril_mutex_unlock(&file->lock);
753
754 ipc_answer_1(rid, EOK, IPC_GET_ARG1(answer));
755}
756
757void vfs_sync(ipc_callid_t rid, ipc_call_t *request)
758{
759 int fd = IPC_GET_ARG1(*request);
760
761 /* Lookup the file structure corresponding to the file descriptor. */
762 vfs_file_t *file = vfs_file_get(fd);
763 if (!file) {
764 ipc_answer_0(rid, ENOENT);
765 return;
766 }
767
768 /*
769 * Lock the open file structure so that no other thread can manipulate
770 * the same open file at a time.
771 */
772 fibril_mutex_lock(&file->lock);
773 int fs_phone = vfs_grab_phone(file->node->fs_handle);
774
775 /* Make a VFS_SYMC request at the destination FS server. */
776 aid_t msg;
777 ipc_call_t answer;
778 msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
779 file->node->dev_handle, file->node->index, &answer);
780
781 vfs_release_phone(fs_phone);
782
783 /* Wait for reply from the FS server. */
784 ipcarg_t rc;
785 async_wait_for(msg, &rc);
786
787 fibril_mutex_unlock(&file->lock);
788
789 ipc_answer_0(rid, rc);
790}
791
792void vfs_close(ipc_callid_t rid, ipc_call_t *request)
793{
794 int fd = IPC_GET_ARG1(*request);
795
796 /* Lookup the file structure corresponding to the file descriptor. */
797 vfs_file_t *file = vfs_file_get(fd);
798 if (!file) {
799 ipc_answer_0(rid, ENOENT);
800 return;
801 }
802
803 /*
804 * Lock the open file structure so that no other thread can manipulate
805 * the same open file at a time.
806 */
807 fibril_mutex_lock(&file->lock);
808
809 int fs_phone = vfs_grab_phone(file->node->fs_handle);
810
811 /* Make a VFS_CLOSE request at the destination FS server. */
812 aid_t msg;
813 ipc_call_t answer;
814 msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
815 file->node->dev_handle, file->node->index, &answer);
816
817 vfs_release_phone(fs_phone);
818
819 /* Wait for reply from the FS server. */
820 ipcarg_t rc;
821 async_wait_for(msg, &rc);
822
823 fibril_mutex_unlock(&file->lock);
824
825 int retval = IPC_GET_ARG1(answer);
826 if (retval != EOK)
827 ipc_answer_0(rid, retval);
828
829 retval = vfs_fd_free(fd);
830 ipc_answer_0(rid, retval);
831}
832
833static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
834{
835
836 /*
837 * The following code strongly depends on the fact that the files data
838 * structure can be only accessed by a single fibril and all file
839 * operations are serialized (i.e. the reads and writes cannot
840 * interleave and a file cannot be closed while it is being read).
841 *
842 * Additional synchronization needs to be added once the table of
843 * open files supports parallel access!
844 */
845
846 int fd = IPC_GET_ARG1(*request);
847
848 /* Lookup the file structure corresponding to the file descriptor. */
849 vfs_file_t *file = vfs_file_get(fd);
850 if (!file) {
851 ipc_answer_0(rid, ENOENT);
852 return;
853 }
854
855 /*
856 * Now we need to receive a call with client's
857 * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
858 */
859 ipc_callid_t callid;
860 int res;
861 if (read)
862 res = ipc_data_read_receive(&callid, NULL);
863 else
864 res = ipc_data_write_receive(&callid, NULL);
865 if (!res) {
866 ipc_answer_0(callid, EINVAL);
867 ipc_answer_0(rid, EINVAL);
868 return;
869 }
870
871 /*
872 * Lock the open file structure so that no other thread can manipulate
873 * the same open file at a time.
874 */
875 fibril_mutex_lock(&file->lock);
876
877 /*
878 * Lock the file's node so that no other client can read/write to it at
879 * the same time.
880 */
881 if (read)
882 fibril_rwlock_read_lock(&file->node->contents_rwlock);
883 else
884 fibril_rwlock_write_lock(&file->node->contents_rwlock);
885
886 if (file->node->type == VFS_NODE_DIRECTORY) {
887 /*
888 * Make sure that no one is modifying the namespace
889 * while we are in readdir().
890 */
891 assert(read);
892 fibril_rwlock_read_lock(&namespace_rwlock);
893 }
894
895 int fs_phone = vfs_grab_phone(file->node->fs_handle);
896
897 /* Make a VFS_READ/VFS_WRITE request at the destination FS server. */
898 aid_t msg;
899 ipc_call_t answer;
900 if (!read && file->append)
901 file->pos = file->node->size;
902 msg = async_send_3(fs_phone, IPC_GET_METHOD(*request),
903 file->node->dev_handle, file->node->index, file->pos, &answer);
904
905 /*
906 * Forward the IPC_M_DATA_READ/IPC_M_DATA_WRITE request to the
907 * destination FS server. The call will be routed as if sent by
908 * ourselves. Note that call arguments are immutable in this case so we
909 * don't have to bother.
910 */
911 ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
912
913 vfs_release_phone(fs_phone);
914
915 /* Wait for reply from the FS server. */
916 ipcarg_t rc;
917 async_wait_for(msg, &rc);
918
919 size_t bytes = IPC_GET_ARG1(answer);
920
921 if (file->node->type == VFS_NODE_DIRECTORY)
922 fibril_rwlock_read_unlock(&namespace_rwlock);
923
924 /* Unlock the VFS node. */
925 if (read)
926 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
927 else {
928 /* Update the cached version of node's size. */
929 if (rc == EOK)
930 file->node->size = IPC_GET_ARG2(answer);
931 fibril_rwlock_write_unlock(&file->node->contents_rwlock);
932 }
933
934 /* Update the position pointer and unlock the open file. */
935 if (rc == EOK)
936 file->pos += bytes;
937 fibril_mutex_unlock(&file->lock);
938
939 /*
940 * FS server's reply is the final result of the whole operation we
941 * return to the client.
942 */
943 ipc_answer_1(rid, rc, bytes);
944}
945
946void vfs_read(ipc_callid_t rid, ipc_call_t *request)
947{
948 vfs_rdwr(rid, request, true);
949}
950
951void vfs_write(ipc_callid_t rid, ipc_call_t *request)
952{
953 vfs_rdwr(rid, request, false);
954}
955
956void vfs_seek(ipc_callid_t rid, ipc_call_t *request)
957{
958 int fd = (int) IPC_GET_ARG1(*request);
959 off_t off = (off_t) IPC_GET_ARG2(*request);
960 int whence = (int) IPC_GET_ARG3(*request);
961
962
963 /* Lookup the file structure corresponding to the file descriptor. */
964 vfs_file_t *file = vfs_file_get(fd);
965 if (!file) {
966 ipc_answer_0(rid, ENOENT);
967 return;
968 }
969
970 off_t newpos;
971 fibril_mutex_lock(&file->lock);
972 if (whence == SEEK_SET) {
973 file->pos = off;
974 fibril_mutex_unlock(&file->lock);
975 ipc_answer_1(rid, EOK, off);
976 return;
977 }
978 if (whence == SEEK_CUR) {
979 if (file->pos + off < file->pos) {
980 fibril_mutex_unlock(&file->lock);
981 ipc_answer_0(rid, EOVERFLOW);
982 return;
983 }
984 file->pos += off;
985 newpos = file->pos;
986 fibril_mutex_unlock(&file->lock);
987 ipc_answer_1(rid, EOK, newpos);
988 return;
989 }
990 if (whence == SEEK_END) {
991 fibril_rwlock_read_lock(&file->node->contents_rwlock);
992 size_t size = file->node->size;
993 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
994 if (size + off < size) {
995 fibril_mutex_unlock(&file->lock);
996 ipc_answer_0(rid, EOVERFLOW);
997 return;
998 }
999 newpos = size + off;
1000 fibril_mutex_unlock(&file->lock);
1001 ipc_answer_1(rid, EOK, newpos);
1002 return;
1003 }
1004 fibril_mutex_unlock(&file->lock);
1005 ipc_answer_0(rid, EINVAL);
1006}
1007
1008int
1009vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
1010 fs_index_t index, size_t size)
1011{
1012 ipcarg_t rc;
1013 int fs_phone;
1014
1015 fs_phone = vfs_grab_phone(fs_handle);
1016 rc = async_req_3_0(fs_phone, VFS_TRUNCATE, (ipcarg_t)dev_handle,
1017 (ipcarg_t)index, (ipcarg_t)size);
1018 vfs_release_phone(fs_phone);
1019 return (int)rc;
1020}
1021
1022void vfs_truncate(ipc_callid_t rid, ipc_call_t *request)
1023{
1024 int fd = IPC_GET_ARG1(*request);
1025 size_t size = IPC_GET_ARG2(*request);
1026 int rc;
1027
1028 vfs_file_t *file = vfs_file_get(fd);
1029 if (!file) {
1030 ipc_answer_0(rid, ENOENT);
1031 return;
1032 }
1033 fibril_mutex_lock(&file->lock);
1034
1035 fibril_rwlock_write_lock(&file->node->contents_rwlock);
1036 rc = vfs_truncate_internal(file->node->fs_handle,
1037 file->node->dev_handle, file->node->index, size);
1038 if (rc == EOK)
1039 file->node->size = size;
1040 fibril_rwlock_write_unlock(&file->node->contents_rwlock);
1041
1042 fibril_mutex_unlock(&file->lock);
1043 ipc_answer_0(rid, (ipcarg_t)rc);
1044}
1045
1046void vfs_mkdir(ipc_callid_t rid, ipc_call_t *request)
1047{
1048 int mode = IPC_GET_ARG1(*request);
1049
1050 size_t len;
1051 ipc_callid_t callid;
1052
1053 if (!ipc_data_write_receive(&callid, &len)) {
1054 ipc_answer_0(callid, EINVAL);
1055 ipc_answer_0(rid, EINVAL);
1056 return;
1057 }
1058 char *path = malloc(len + 1);
1059 if (!path) {
1060 ipc_answer_0(callid, ENOMEM);
1061 ipc_answer_0(rid, ENOMEM);
1062 return;
1063 }
1064 int rc;
1065 if ((rc = ipc_data_write_finalize(callid, path, len))) {
1066 ipc_answer_0(rid, rc);
1067 free(path);
1068 return;
1069 }
1070 path[len] = '\0';
1071
1072 fibril_rwlock_write_lock(&namespace_rwlock);
1073 int lflag = L_DIRECTORY | L_CREATE | L_EXCLUSIVE;
1074 rc = vfs_lookup_internal(path, lflag, NULL, NULL);
1075 fibril_rwlock_write_unlock(&namespace_rwlock);
1076 free(path);
1077 ipc_answer_0(rid, rc);
1078}
1079
1080void vfs_unlink(ipc_callid_t rid, ipc_call_t *request)
1081{
1082 int lflag = IPC_GET_ARG1(*request);
1083
1084 size_t len;
1085 ipc_callid_t callid;
1086
1087 if (!ipc_data_write_receive(&callid, &len)) {
1088 ipc_answer_0(callid, EINVAL);
1089 ipc_answer_0(rid, EINVAL);
1090 return;
1091 }
1092 char *path = malloc(len + 1);
1093 if (!path) {
1094 ipc_answer_0(callid, ENOMEM);
1095 ipc_answer_0(rid, ENOMEM);
1096 return;
1097 }
1098 int rc;
1099 if ((rc = ipc_data_write_finalize(callid, path, len))) {
1100 ipc_answer_0(rid, rc);
1101 free(path);
1102 return;
1103 }
1104 path[len] = '\0';
1105
1106 fibril_rwlock_write_lock(&namespace_rwlock);
1107 lflag &= L_DIRECTORY; /* sanitize lflag */
1108 vfs_lookup_res_t lr;
1109 rc = vfs_lookup_internal(path, lflag | L_UNLINK, &lr, NULL);
1110 free(path);
1111 if (rc != EOK) {
1112 fibril_rwlock_write_unlock(&namespace_rwlock);
1113 ipc_answer_0(rid, rc);
1114 return;
1115 }
1116
1117 /*
1118 * The name has already been unlinked by vfs_lookup_internal().
1119 * We have to get and put the VFS node to ensure that it is
1120 * VFS_DESTROY'ed after the last reference to it is dropped.
1121 */
1122 vfs_node_t *node = vfs_node_get(&lr);
1123 futex_down(&nodes_futex);
1124 node->lnkcnt--;
1125 futex_up(&nodes_futex);
1126 fibril_rwlock_write_unlock(&namespace_rwlock);
1127 vfs_node_put(node);
1128 ipc_answer_0(rid, EOK);
1129}
1130
1131void vfs_rename(ipc_callid_t rid, ipc_call_t *request)
1132{
1133 size_t olen, nlen;
1134 ipc_callid_t callid;
1135 int rc;
1136
1137 /* Retrieve the old path. */
1138 if (!ipc_data_write_receive(&callid, &olen)) {
1139 ipc_answer_0(callid, EINVAL);
1140 ipc_answer_0(rid, EINVAL);
1141 return;
1142 }
1143 char *old = malloc(olen + 1);
1144 if (!old) {
1145 ipc_answer_0(callid, ENOMEM);
1146 ipc_answer_0(rid, ENOMEM);
1147 return;
1148 }
1149 if ((rc = ipc_data_write_finalize(callid, old, olen))) {
1150 ipc_answer_0(rid, rc);
1151 free(old);
1152 return;
1153 }
1154 old[olen] = '\0';
1155
1156 /* Retrieve the new path. */
1157 if (!ipc_data_write_receive(&callid, &nlen)) {
1158 ipc_answer_0(callid, EINVAL);
1159 ipc_answer_0(rid, EINVAL);
1160 free(old);
1161 return;
1162 }
1163 char *new = malloc(nlen + 1);
1164 if (!new) {
1165 ipc_answer_0(callid, ENOMEM);
1166 ipc_answer_0(rid, ENOMEM);
1167 free(old);
1168 return;
1169 }
1170 if ((rc = ipc_data_write_finalize(callid, new, nlen))) {
1171 ipc_answer_0(rid, rc);
1172 free(old);
1173 free(new);
1174 return;
1175 }
1176 new[nlen] = '\0';
1177
1178 char *oldc = canonify(old, &olen);
1179 char *newc = canonify(new, &nlen);
1180 if (!oldc || !newc) {
1181 ipc_answer_0(rid, EINVAL);
1182 free(old);
1183 free(new);
1184 return;
1185 }
1186 oldc[olen] = '\0';
1187 newc[nlen] = '\0';
1188 if ((!str_lcmp(newc, oldc, str_length(oldc))) &&
1189 ((newc[str_length(oldc)] == '/') ||
1190 (str_length(oldc) == 1) ||
1191 (str_length(oldc) == str_length(newc)))) {
1192 /*
1193 * oldc is a prefix of newc and either
1194 * - newc continues with a / where oldc ends, or
1195 * - oldc was / itself, or
1196 * - oldc and newc are equal.
1197 */
1198 ipc_answer_0(rid, EINVAL);
1199 free(old);
1200 free(new);
1201 return;
1202 }
1203
1204 vfs_lookup_res_t old_lr;
1205 vfs_lookup_res_t new_lr;
1206 vfs_lookup_res_t new_par_lr;
1207 fibril_rwlock_write_lock(&namespace_rwlock);
1208 /* Lookup the node belonging to the old file name. */
1209 rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
1210 if (rc != EOK) {
1211 fibril_rwlock_write_unlock(&namespace_rwlock);
1212 ipc_answer_0(rid, rc);
1213 free(old);
1214 free(new);
1215 return;
1216 }
1217 vfs_node_t *old_node = vfs_node_get(&old_lr);
1218 if (!old_node) {
1219 fibril_rwlock_write_unlock(&namespace_rwlock);
1220 ipc_answer_0(rid, ENOMEM);
1221 free(old);
1222 free(new);
1223 return;
1224 }
1225 /* Determine the path to the parent of the node with the new name. */
1226 char *parentc = str_dup(newc);
1227 if (!parentc) {
1228 fibril_rwlock_write_unlock(&namespace_rwlock);
1229 ipc_answer_0(rid, rc);
1230 free(old);
1231 free(new);
1232 return;
1233 }
1234 char *lastsl = str_rchr(parentc + 1, '/');
1235 if (lastsl)
1236 *lastsl = '\0';
1237 else
1238 parentc[1] = '\0';
1239 /* Lookup parent of the new file name. */
1240 rc = vfs_lookup_internal(parentc, L_NONE, &new_par_lr, NULL);
1241 free(parentc); /* not needed anymore */
1242 if (rc != EOK) {
1243 fibril_rwlock_write_unlock(&namespace_rwlock);
1244 ipc_answer_0(rid, rc);
1245 free(old);
1246 free(new);
1247 return;
1248 }
1249 /* Check whether linking to the same file system instance. */
1250 if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
1251 (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
1252 fibril_rwlock_write_unlock(&namespace_rwlock);
1253 ipc_answer_0(rid, EXDEV); /* different file systems */
1254 free(old);
1255 free(new);
1256 return;
1257 }
1258 /* Destroy the old link for the new name. */
1259 vfs_node_t *new_node = NULL;
1260 rc = vfs_lookup_internal(newc, L_UNLINK, &new_lr, NULL);
1261 switch (rc) {
1262 case ENOENT:
1263 /* simply not in our way */
1264 break;
1265 case EOK:
1266 new_node = vfs_node_get(&new_lr);
1267 if (!new_node) {
1268 fibril_rwlock_write_unlock(&namespace_rwlock);
1269 ipc_answer_0(rid, ENOMEM);
1270 free(old);
1271 free(new);
1272 return;
1273 }
1274 futex_down(&nodes_futex);
1275 new_node->lnkcnt--;
1276 futex_up(&nodes_futex);
1277 break;
1278 default:
1279 fibril_rwlock_write_unlock(&namespace_rwlock);
1280 ipc_answer_0(rid, ENOTEMPTY);
1281 free(old);
1282 free(new);
1283 return;
1284 }
1285 /* Create the new link for the new name. */
1286 rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
1287 if (rc != EOK) {
1288 fibril_rwlock_write_unlock(&namespace_rwlock);
1289 if (new_node)
1290 vfs_node_put(new_node);
1291 ipc_answer_0(rid, rc);
1292 free(old);
1293 free(new);
1294 return;
1295 }
1296 futex_down(&nodes_futex);
1297 old_node->lnkcnt++;
1298 futex_up(&nodes_futex);
1299 /* Destroy the link for the old name. */
1300 rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
1301 if (rc != EOK) {
1302 fibril_rwlock_write_unlock(&namespace_rwlock);
1303 vfs_node_put(old_node);
1304 if (new_node)
1305 vfs_node_put(new_node);
1306 ipc_answer_0(rid, rc);
1307 free(old);
1308 free(new);
1309 return;
1310 }
1311 futex_down(&nodes_futex);
1312 old_node->lnkcnt--;
1313 futex_up(&nodes_futex);
1314 fibril_rwlock_write_unlock(&namespace_rwlock);
1315 vfs_node_put(old_node);
1316 if (new_node)
1317 vfs_node_put(new_node);
1318 free(old);
1319 free(new);
1320 ipc_answer_0(rid, EOK);
1321}
1322
1323/**
1324 * @}
1325 */
Note: See TracBrowser for help on using the repository browser.