Changeset 368ee04 for uspace/lib – HelenOS

uspace/lib/bithenge/src/failure.c

-              r39f892a9
+              r368ee04
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 …
                 if (null == -1)
                         exit(127);
                 dup2(null, STDOUT_FILENO);
                 dup2(null, STDERR_FILENO);
                 close(null);
+                vfs_clone(null, STDOUT_FILENO, false);
+                vfs_clone(null, STDERR_FILENO, false);
+                vfs_put(null);
                 return 1;
+        }

uspace/lib/bithenge/src/failure.h

r39f892a9	r368ee04
42	42	#include <stdio.h>
43	43	#include <stdlib.h>
44		~~#include <sys/stat.h>~~
45	44	#include <sys/types.h>
46	45	#include <unistd.h>

uspace/lib/bithenge/src/file.c

-              r39f892a9
+              r368ee04
 #include <assert.h>
 #include <errno.h>
-#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
+#include <vfs/vfs.h>
 #include <sys/types.h>
 #include <unistd.h>
 …
         if (offset > blob->size)
                 return ELIMIT;
-        if (lseek(blob->fd, offset, SEEK_SET) < 0)
-                return errno == EINVAL ? EIO : errno;
+        ssize_t amount_read;
+        aoff64_t remaining_size = *size;
+        *size = 0;
+        do {
+                amount_read = read(blob->fd, buffer, remaining_size);
+                if (amount_read < 0)
+                        return errno;
+                buffer += amount_read;
+                *size += amount_read;
+                remaining_size -= amount_read;
+        } while (remaining_size && amount_read);
+        ssize_t amount_read = vfs_read(blob->fd, &offset, buffer, *size);
+        if (amount_read < 0)
+                return errno;
+        *size += amount_read;
         return EOK;
+}
 …
+{
         file_blob_t *blob = blob_as_file(base);
         close(blob->fd);
+        vfs_put(blob->fd);
         free(blob);
+}
 …
         struct stat stat;
         int rc = fstat(fd, &stat);
         if (rc != 0) {
+        int rc = vfs_stat(fd, &stat);
+        if (rc != EOK) {
                 if (needs_close)
                         close(fd);
+                        vfs_put(fd);
                 return rc;
+        }
 …
         if (!blob) {
                 if (needs_close)
                         close(fd);
+                        vfs_put(fd);
                 return ENOMEM;
+        }
 …
                 free(blob);
                 if (needs_close)
                         close(fd);
+                        vfs_put(fd);
                 return rc;
+        }
 …
         assert(filename);
         int fd = open(filename, O_RDONLY);
+        int fd = vfs_lookup_open(filename, WALK_REGULAR, MODE_READ);
         if (fd < 0)
                 return errno;

uspace/lib/c/Makefile

-              r39f892a9
+              r368ee04
         generic/device/clock_dev.c \
         generic/device/led_dev.c \
+        generic/dirent.c \
         generic/dhcp.c \
         generic/dnsr.c \
 …
         generic/stdlib.c \
         generic/udebug.c \
+        generic/vfs/canonify.c \
+        generic/vfs/inbox.c \
+        generic/vfs/mtab.c \
         generic/vfs/vfs.c \
-        generic/vfs/canonify.c \
         generic/rcu.c \
         generic/setjmp.c \

uspace/lib/c/generic/dirent.c

-              r39f892a9
+              r368ee04
  */
+#ifndef LIBC_SYS_STAT_H_
+#define LIBC_SYS_STAT_H_
+#include <vfs/vfs.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <stdbool.h>
+#include <ipc/vfs.h>
+#include <ipc/loc.h>
+/** Open directory.
+ *
+ * @param dirname Directory pathname
+ *
+ * @return Non-NULL pointer on success. On error returns @c NULL and sets errno.
+ */
+DIR *opendir(const char *dirname)
+{
+        DIR *dirp = malloc(sizeof(DIR));
+        if (!dirp) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        int fd = vfs_lookup(dirname, WALK_DIRECTORY);
+        if (fd < 0) {
+                free(dirp);
+                errno = fd;
+                return NULL;
+        }
+        int rc = vfs_open(fd, MODE_READ);
+        if (rc < 0) {
+                free(dirp);
+                vfs_put(fd);
+                errno = rc;
+                return NULL;
+        }
+        dirp->fd = fd;
+        dirp->pos = 0;
+        return dirp;
+}
+struct stat {
+        fs_handle_t fs_handle;
+        service_id_t service_id;
+        fs_index_t index;
+        unsigned int lnkcnt;
+        bool is_file;
+        bool is_directory;
+        aoff64_t size;
+        service_id_t service;
+};
+/** Read directory entry.
+ *
+ * @param dirp Open directory
+ * @return Non-NULL pointer to directory entry on success. On error returns
+ *         @c NULL and sets errno.
+ */
+struct dirent *readdir(DIR *dirp)
+{
+        int rc;
+        ssize_t len = 0;
+        rc = vfs_read_short(dirp->fd, dirp->pos, &dirp->res.d_name[0],
+            NAME_MAX + 1, &len);
+        if (rc != EOK) {
+                errno = rc;
+                return NULL;
+        }
+        dirp->pos += len;
+        return &dirp->res;
+}
+extern int fstat(int, struct stat *);
+extern int stat(const char *, struct stat *);
+extern int mkdir(const char *, mode_t);
+/** Rewind directory position to the beginning.
+ *
+ * @param dirp Open directory
+ */
+void rewinddir(DIR *dirp)
+{
+        dirp->pos = 0;
+}
+#endif
+/** Close directory.
+ *
+ * @param dirp Open directory
+ * @return 0 on success. On error returns -1 and sets errno.
+ */
+int closedir(DIR *dirp)
+{
+        int rc;
+        rc = vfs_put(dirp->fd);
+        free(dirp);
+        /* On error errno was set by close() */
+        return rc;
+}
 /** @}

uspace/lib/c/generic/elf/elf_load.c

-              r39f892a9
+              r368ee04
 #include <stdio.h>
 #include <stdlib.h>
+#include <vfs/vfs.h>
 #ifdef CONFIG_RTLD
 …
 /** Load ELF program.
+ *
  * @param file_name File name
+ * @param file File handle
  * @param info Place to store ELF program information
  * @return EOK on success or non-zero error code
  */
 int elf_load(const char *file_name, elf_info_t *info)
+int elf_load(int file, elf_info_t *info)
+{
 #ifdef CONFIG_RTLD
 …
         int rc;
         rc = elf_load_file(file_name, 0, 0, &info->finfo);
+        rc = elf_load_file(file, 0, 0, &info->finfo);
         if (rc != EE_OK) {
                 DPRINTF("Failed to load executable '%s'.\n", file_name);

uspace/lib/c/generic/elf/elf_mod.c

-              r39f892a9
+              r368ee04
  */
+#include <errno.h>
 #include <stdio.h>
+#include <vfs/vfs.h>
 #include <sys/types.h>
 #include <align.h>
 …
 #include <as.h>
 #include <elf/elf.h>
-#include <unistd.h>
-#include <fcntl.h>
 #include <smc.h>
 #include <loader/pcb.h>
 #include <entry_point.h>
+#include <str_error.h>
+#include <stdlib.h>
 #include <elf/elf_load.h>
 …
  * pointed to by @a info.
+ *
  * @param file_name Path to the ELF file.
+ * @param file      ELF file.
  * @param so_bias   Bias to use if the file is a shared object.
  * @param info      Pointer to a structure for storing information
 …
+ *
  */
+int elf_load_file(const char *file_name, size_t so_bias, eld_flags_t flags,
+    elf_finfo_t *info)
+int elf_load_file(int file, size_t so_bias, eld_flags_t flags, elf_finfo_t *info)
+{
         elf_ld_t elf;
+        int fd;
+        int rc;
+        fd = open(file_name, O_RDONLY);
+        if (fd < 0) {
+                DPRINTF("failed opening file\n");
+                return -1;
+        }
+        elf.fd = fd;
+        int ofile = vfs_clone(file, -1, true);
+        int rc = vfs_open(ofile, MODE_READ);
+        if (rc != EOK) {
+                return rc;
+        }
+        elf.fd = ofile;
         elf.info = info;
         elf.flags = flags;
 …
         rc = elf_load_module(&elf, so_bias);
+        close(fd);
+        vfs_put(ofile);
+        return rc;
+}
+int elf_load_file_name(const char *path, size_t so_bias, eld_flags_t flags,
+    elf_finfo_t *info)
+{
+        int file = vfs_lookup(path, 0);
+        int rc = elf_load_file(file, so_bias, flags, info);
+        vfs_put(file);
         return rc;
+}
 …
         elf_header_t header_buf;
         elf_header_t *header = &header_buf;
+        aoff64_t pos = 0;
         int i, rc;
         rc = read(elf->fd, header, sizeof(elf_header_t));
+        rc = vfs_read(elf->fd, &pos, header, sizeof(elf_header_t));
         if (rc != sizeof(elf_header_t)) {
                 DPRINTF("Read error.\n");
 …
                 elf_segment_header_t segment_hdr;
+                /* Seek to start of segment header */
+                lseek(elf->fd, header->e_phoff
+                        + i * sizeof(elf_segment_header_t), SEEK_SET);
+                rc = read(elf->fd, &segment_hdr,
+                pos = header->e_phoff + i * sizeof(elf_segment_header_t);
+                rc = vfs_read(elf->fd, &pos, &segment_hdr,
                     sizeof(elf_segment_header_t));
                 if (rc != sizeof(elf_segment_header_t)) {
 …
                 elf_section_header_t section_hdr;
+                /* Seek to start of section header */
+                lseek(elf->fd, header->e_shoff
+                    + i * sizeof(elf_section_header_t), SEEK_SET);
+                rc = read(elf->fd, &section_hdr,
+                pos = header->e_shoff + i * sizeof(elf_section_header_t);
+                rc = vfs_read(elf->fd, &pos, &section_hdr,
                     sizeof(elf_section_header_t));
                 if (rc != sizeof(elf_section_header_t)) {
 …
         uintptr_t seg_addr;
         size_t mem_sz;
+        aoff64_t pos;
         ssize_t rc;
 …
          * Load segment data
          */
+        rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
+        pos = entry->p_offset;
+        rc = vfs_read(elf->fd, &pos, seg_ptr, entry->p_filesz);
         if (rc < 0) {
                 printf("seek error\n");
+                DPRINTF("read error\n");
                 return EE_INVALID;
+        }
-/*      rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
-        if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
-        /* Long reads are not possible yet. Load segment piecewise. */
-        unsigned left, now;
-        uint8_t *dp;
-        left = entry->p_filesz;
-        dp = seg_ptr;
-        while (left > 0) {
-                now = 16384;
-                if (now > left) now = left;
-                rc = read(elf->fd, dp, now);
-                if (rc != (ssize_t) now) {
-                        DPRINTF("Read error.\n");
-                        return EE_INVALID;
+                }
-                left -= now;
-                dp += now;
+        }

uspace/lib/c/generic/io/io.c

-              r39f892a9
+              r368ee04
 #include <stdio.h>
 #include <unistd.h>
-#include <fcntl.h>
 #include <assert.h>
 #include <str.h>
 …
 #include <vfs/vfs.h>
 #include <vfs/vfs_sess.h>
+#include <vfs/inbox.h>
 #include <ipc/loc.h>
 #include <adt/list.h>
 …
 static FILE stdin_null = {
         .fd = -1,
+        .pos = 0,
         .error = true,
         .eof = true,
 …
 static FILE stdout_kio = {
         .fd = -1,
+        .pos = 0,
         .error = false,
         .eof = false,
 …
 static FILE stderr_kio = {
         .fd = -1,
+        .pos = 0,
         .error = false,
         .eof = false,
 …
 static LIST_INITIALIZE(files);
+void __stdio_init(int filc)
+{
+        if (filc > 0) {
+                stdin = fdopen(0, "r");
+void __stdio_init(void)
+{
+        /* The first three standard file descriptors are assigned for compatibility.
+         * This will probably be removed later.
+         */
+        int infd = inbox_get("stdin");
+        if (infd >= 0) {
+                int stdinfd = vfs_clone(infd, -1, false);
+                assert(stdinfd == 0);
+                vfs_open(stdinfd, MODE_READ);
+                stdin = fdopen(stdinfd, "r");
         } else {
                 stdin = &stdin_null;
 …
+        }
+        if (filc > 1) {
+                stdout = fdopen(1, "w");
+        int outfd = inbox_get("stdout");
+        if (outfd >= 0) {
+                int stdoutfd = vfs_clone(outfd, -1, false);
+                assert(stdoutfd <= 1);
+                while (stdoutfd < 1)
+                        stdoutfd = vfs_clone(outfd, -1, false);
+                vfs_open(stdoutfd, MODE_APPEND);
+                stdout = fdopen(stdoutfd, "a");
         } else {
                 stdout = &stdout_kio;
 …
+        }
+        if (filc > 2) {
+                stderr = fdopen(2, "w");
+        int errfd = inbox_get("stderr");
+        if (errfd >= 0) {
+                int stderrfd = vfs_clone(errfd, -1, false);
+                assert(stderrfd <= 2);
+                while (stderrfd < 2)
+                        stderrfd = vfs_clone(errfd, -1, false);
+                vfs_open(stderrfd, MODE_APPEND);
+                stderr = fdopen(stderrfd, "a");
         } else {
                 stderr = &stderr_kio;
 …
+}
 static bool parse_mode(const char *mode, int *flags)
+static bool parse_mode(const char *fmode, int *mode, bool *create, bool *truncate)
+{
         /* Parse mode except first character. */
         const char *mp = mode;
+        const char *mp = fmode;
         if (*mp++ == 0) {
                 errno = EINVAL;
 …
                 return false;
+        }
+        /* Parse first character of mode and determine flags for open(). */
+        switch (mode[0]) {
+        *create = false;
+        *truncate = false;
+        /* Parse first character of fmode and determine mode for vfs_open(). */
+        switch (fmode[0]) {
         case 'r':
                 *flags = plus ? O_RDWR : O_RDONLY;
+                *mode = plus ? MODE_READ | MODE_WRITE : MODE_READ;
                 break;
         case 'w':
+                *flags = (O_TRUNC | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
+                *mode = plus ? MODE_READ | MODE_WRITE : MODE_WRITE;
+                *create = true;
+                if (!plus)
+                        *truncate = true;
                 break;
         case 'a':
 …
                         return false;
+                }
+                *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
+                *mode = MODE_APPEND | (plus ? MODE_READ | MODE_WRITE : MODE_WRITE);
+                *create = true;
                 break;
         default:
 …
+ *
  */
+FILE *fopen(const char *path, const char *mode)
+{
+        int flags;
+        if (!parse_mode(mode, &flags))
+FILE *fopen(const char *path, const char *fmode)
+{
+        int mode;
+        bool create;
+        bool truncate;
+        if (!parse_mode(fmode, &mode, &create, &truncate))
                 return NULL;
 …
                 return NULL;
+        }
+        stream->fd = open(path, flags, 0666);
+        if (stream->fd < 0) {
+                /* errno was set by open() */
+        int flags = WALK_REGULAR;
+        if (create)
+                flags |= WALK_MAY_CREATE;
+        int file = vfs_lookup(path, flags);
+        if (file < 0) {
+                errno = file;
                 free(stream);
                 return NULL;
+        }
+        int rc = vfs_open(file, mode);
+        if (rc != EOK) {
+                errno = rc;
+                vfs_put(file);
+                free(stream);
+                return NULL;
+        }
+        if (truncate) {
+                rc = vfs_resize(file, 0);
+                if (rc != EOK) {
+                        errno = rc;
+                        vfs_put(file);
+                        free(stream);
+                        return NULL;
+                }
+        }
+        stream->fd = file;
+        stream->pos = 0;
         stream->error = false;
         stream->eof = false;
 …
         stream->fd = fd;
+        stream->pos = 0;
         stream->error = false;
         stream->eof = false;
 …
         if (stream->fd >= 0)
                 rc = close(stream->fd);
+                rc = vfs_put(stream->fd);
         list_remove(&stream->link);
 …
 static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
+{
-        size_t left, done;
         if (size == 0 || nmemb == 0)
                 return 0;
+        left = size * nmemb;
+        done = 0;
+        while ((left > 0) && (!stream->error) && (!stream->eof)) {
+                ssize_t rd = read(stream->fd, buf + done, left);
+                if (rd < 0) {
+                        /* errno was set by read() */
+                        stream->error = true;
+                } else if (rd == 0) {
+                        stream->eof = true;
+                } else {
+                        left -= rd;
+                        done += rd;
+                }
+        }
+        return (done / size);
+        ssize_t rd = vfs_read(stream->fd, &stream->pos, buf, size * nmemb);
+        if (rd < 0) {
+                errno = rd;
+                stream->error = true;
+                rd = 0;
+        } else if (rd == 0) {
+                stream->eof = true;
+        }
+        return (rd / size);
+}
 …
 static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
+{
-        size_t left;
-        size_t done;
-        int rc;
         if (size == 0 || nmemb == 0)
                 return 0;
+        left = size * nmemb;
+        done = 0;
+        while ((left > 0) && (!stream->error)) {
+                ssize_t wr;
+                size_t uwr;
+                if (stream->kio) {
+                        uwr = 0;
+                        rc = kio_write(buf + done, left, &uwr);
+                        if (rc != EOK)
+                                errno = rc;
+        ssize_t wr;
+        if (stream->kio) {
+                size_t nwritten;
+                wr = kio_write(buf, size * nmemb, &nwritten);
+                if (wr != EOK) {
+                        stream->error = true;
+                        wr = 0;
                 } else {
+                        wr = write(stream->fd, buf + done, left);
+                        if (wr >= 0) {
+                                uwr = (size_t)wr;
+                                rc = EOK;
+                        } else {
+                                /* errno was set by write */
+                                uwr = 0;
+                                rc = errno;
+                        }
+                        wr = nwritten;
+                }
+                if (rc != EOK) {
+                        /* errno was set above */
+        } else {
+                wr = vfs_write(stream->fd, &stream->pos, buf, size * nmemb);
+                if (wr < 0) {
+                        errno = wr;
                         stream->error = true;
+                } else {
+                        left -= uwr;
+                        done += uwr;
+                        wr = 0;
+                }
+        }
         if (done > 0)
+        if (wr > 0)
                 stream->need_sync = true;
         return (done / size);
+        return (wr / size);
+}
 …
         stream->buf_head = stream->buf_tail = stream->buf;
         rc = read(stream->fd, stream->buf, stream->buf_size);
+        rc = vfs_read(stream->fd, &stream->pos, stream->buf, stream->buf_size);
         if (rc < 0) {
                 /* errno was set by read() */
+                errno = rc;
                 stream->error = true;
                 return;
 …
         /* If buffer has prefetched read data, we need to seek back. */
+        if (bytes_used > 0 && stream->buf_state == _bs_read) {
+                off64_t rc;
+                rc = lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
+                if (rc == (off64_t)-1) {
+                        /* errno was set by lseek */
+                        stream->error = 1;
+                        return;
+                }
+        }
+        if (bytes_used > 0 && stream->buf_state == _bs_read)
+                stream->pos -= bytes_used;
         /* If buffer has unwritten data, we need to write them out. */
 …
 int fseek(FILE *stream, off64_t offset, int whence)
+{
         off64_t rc;
+        int rc;
         if (stream->error)
                 return EOF;
+                return -1;
         _fflushbuf(stream);
         if (stream->error) {
                 /* errno was set by _fflushbuf() */
                 return EOF;
+                return -1;
+        }
         stream->ungetc_chars = 0;
+        rc = lseek(stream->fd, offset, whence);
+        if (rc == (off64_t) (-1)) {
+                /* errno has been set by lseek() */
+                return EOF;
+        struct stat st;
+        switch (whence) {
+        case SEEK_SET:
+                stream->pos = offset;
+                break;
+        case SEEK_CUR:
+                stream->pos += offset;
+                break;
+        case SEEK_END:
+                rc = vfs_stat(stream->fd, &st);
+                if (rc != EOK) {
+                        errno = rc;
+                        stream->error = true;
+                        return -1;
+                }
+                stream->pos = st.size + offset;
+                break;
+        }
 …
 off64_t ftell(FILE *stream)
+{
+        off64_t pos;
+        /* The native position is too large for the C99-ish interface. */
+        if (stream->pos - stream->ungetc_chars > INT64_MAX)
+                return EOF;
         if (stream->error)
                 return EOF;
 …
+        }
+        pos = lseek(stream->fd, 0, SEEK_CUR);
+        if (pos == (off64_t) -1) {
+                /* errno was set by lseek */
+                return (off64_t) -1;
+        }
+        return pos - stream->ungetc_chars;
+        return stream->pos - stream->ungetc_chars;
+}
 …
         if ((stream->fd >= 0) && (stream->need_sync)) {
+                int rc;
                 /**
                  * Better than syncing always, but probably still not the
 …
                  */
                 stream->need_sync = false;
+                if (fsync(stream->fd) != 0) {
+                        /* errno was set by fsync() */
+                rc = vfs_sync(stream->fd);
+                if (rc != EOK) {
+                        errno = rc;
                         return EOF;
+                }

uspace/lib/c/generic/io/logctl.c

-              r39f892a9
+              r368ee04
 #include <ns.h>
 #include <str.h>
+#include <vfs/vfs.h>
 /** IPC session with the logger service. */
 …
+}
+/** Set logger's VFS root.
+ *
+ * @return Error code or EOK on success.
+ */
+int logctl_set_root(void)
+{
+        async_exch_t *exchange = NULL;
+        int rc = start_logger_exchange(&exchange);
+        if (rc != EOK)
+                return rc;
+        aid_t reg_msg = async_send_0(exchange, LOGGER_CONTROL_SET_ROOT, NULL);
+        async_exch_t *vfs_exch = vfs_exchange_begin();
+        rc = vfs_pass_handle(vfs_exch, vfs_root(), exchange);
+        vfs_exchange_end(vfs_exch);
+        sysarg_t reg_msg_rc;
+        async_wait_for(reg_msg, &reg_msg_rc);
+        async_exchange_end(exchange);
+        if (rc != EOK)
+                return rc;
+        return (int) reg_msg_rc;
+}
 /** @}
  */

uspace/lib/c/generic/libc.c

-              r39f892a9
+              r368ee04
 #include <task.h>
 #include <loader/pcb.h>
+#include <vfs/vfs.h>
+#include <vfs/inbox.h>
 #include "private/libc.h"
 #include "private/async.h"
 …
                 argc = 0;
                 argv = NULL;
                 __stdio_init(0);
+                __stdio_init();
         } else {
                 argc = __pcb->argc;
                 argv = __pcb->argv;
+                __stdio_init(__pcb->filc);
+                (void) chdir(__pcb->cwd);
+                __inbox_init(__pcb->inbox, __pcb->inbox_entries);
+                __stdio_init();
+                vfs_root_set(inbox_get("root"));
+                (void) vfs_cwd_set(__pcb->cwd);
+        }

uspace/lib/c/generic/loader.c

-              r39f892a9
+              r368ee04
                 return ENOMEM;
         if (getcwd(cwd, MAX_PATH_LEN + 1) == NULL)
+        if (vfs_cwd_get(cwd, MAX_PATH_LEN + 1) != EOK)
                 str_cpy(cwd, MAX_PATH_LEN + 1, "/");
 …
+}
+/** Set pathname of the program to load.
+ *
+ * Sets the name of the program file to load. The name can be relative
+ * to the current working directory (it will be absolutized before
+ * sending to the loader).
+/** Set the program to load.
+ *
  * @param ldr  Loader connection structure.
+ * @param path Pathname of the program file.
+ *
+ * @return Zero on success or negative error code.
+ *
+ */
+int loader_set_pathname(loader_t *ldr, const char *path)
+{
+        size_t pa_len;
+        char *pa = vfs_absolutize(path, &pa_len);
+        if (!pa)
+                return ENOMEM;
+        /* Send program pathname */
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+ * @param name Name to set for the spawned program.
+ * @param file Program file.
+ *
+ * @return Zero on success or negative error code.
+ *
+ */
+int loader_set_program(loader_t *ldr, const char *name, int file)
+{
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
         ipc_call_t answer;
+        aid_t req = async_send_0(exch, LOADER_SET_PATHNAME, &answer);
+        sysarg_t rc = async_data_write_start(exch, (void *) pa, pa_len);
+        async_exchange_end(exch);
+        free(pa);
+        aid_t req = async_send_0(exch, LOADER_SET_PROGRAM, &answer);
+        sysarg_t rc = async_data_write_start(exch, name, str_size(name) + 1);
+        if (rc == EOK) {
+                async_exch_t *vfs_exch = vfs_exchange_begin();
+                rc = vfs_pass_handle(vfs_exch, file, exch);
+                vfs_exchange_end(vfs_exch);
+        }
+        async_exchange_end(exch);
         if (rc != EOK) {
                 async_forget(req);
                 return (int) rc;
+        }
         async_wait_for(req, &rc);
         return (int) rc;
+}
+/** Set the program to load by path.
+ *
+ * @param ldr  Loader connection structure.
+ * @param path Program path.
+ *
+ * @return Zero on success or negative error code.
+ *
+ */
+int loader_set_program_path(loader_t *ldr, const char *path)
+{
+        const char *name = str_rchr(path, '/');
+        if (name == NULL) {
+                name = path;
+        } else {
+                name++;
+        }
+        int fd = vfs_lookup(path, 0);
+        if (fd < 0) {
+                return fd;
+        }
+        int rc = loader_set_program(ldr, name, fd);
+        vfs_put(fd);
+        return rc;
+}
 /** Set command-line arguments for the program.
 …
+}
+/** Set preset files for the program.
+ *
+ * Sets the vector of preset files to be passed to the loaded
+ * program. By convention, the first three files represent stdin,
+ * stdout and stderr respectively.
+ *
+ * @param ldr   Loader connection structure.
+ * @param files NULL-terminated array of pointers to files.
+ *
+ * @return Zero on success or negative error code.
+ *
+ */
+int loader_set_files(loader_t *ldr, int * const files[])
+{
+        /* Send serialized files to the loader */
+/** Add a file to the task's inbox.
+ *
+ * @param ldr        Loader connection structure.
+ * @param name       Identification of the file.
+ * @param file       The file's descriptor.
+ *
+ * @return Zero on success or negative error code.
+ *
+ */
+int loader_add_inbox(loader_t *ldr, const char *name, int file)
+{
         async_exch_t *exch = async_exchange_begin(ldr->sess);
         async_exch_t *vfs_exch = vfs_exchange_begin();
+        int i;
+        for (i = 0; files[i]; i++);
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, LOADER_SET_FILES, i, &answer);
+        sysarg_t rc = EOK;
+        for (i = 0; files[i]; i++) {
+                rc = async_state_change_start(exch, VFS_PASS_HANDLE, *files[i],
+, vfs_exch);
+                if (rc != EOK)
+                        break;
+        }
+        vfs_exchange_end(vfs_exch);
+        async_exchange_end(exch);
+        if (rc != EOK) {
+                async_forget(req);
+                return (int) rc;
+        }
+        async_wait_for(req, &rc);
+        aid_t req = async_send_0(exch, LOADER_ADD_INBOX, NULL);
+        sysarg_t rc = async_data_write_start(exch, name, str_size(name) + 1);
+        if (rc == EOK) {
+                rc = vfs_pass_handle(vfs_exch, file, exch);
+        }
+        async_exchange_end(vfs_exch);
+        async_exchange_end(exch);
+        if (rc == EOK) {
+                async_wait_for(req, &rc);
+        } else {
+                async_forget(req);
+        }
         return (int) rc;
+}

uspace/lib/c/generic/private/io.h

-              r39f892a9
+              r368ee04
 #define LIBC_PRIVATE_IO_H_
+extern void __stdio_init(int);
+#include <loader/pcb.h>
+extern void __stdio_init(void);
 extern void __stdio_done(void);
+extern void __inbox_init(struct pcb_inbox_entry *entries, int count);
 #endif

uspace/lib/c/generic/private/stdio.h

-              r39f892a9
+              r368ee04
         /** Underlying file descriptor. */
         int fd;
+        /** File position. */
+        aoff64_t pos;
         /** Error indicator. */

uspace/lib/c/generic/rtld/module.c

-              r39f892a9
+              r368ee04
 #include <elf/elf_load.h>
 #include <errno.h>
-#include <fcntl.h>
 #include <loader/pcb.h>
 #include <stdio.h>
 …
         DPRINTF("load '%s' at 0x%x\n", name_buf, m->bias);
         rc = elf_load_file(name_buf, m->bias, ELDF_RW, &info);
+        rc = elf_load_file_name(name_buf, m->bias, ELDF_RW, &info);
         if (rc != EE_OK) {
                 printf("Failed to load '%s'\n", name_buf);

uspace/lib/c/generic/task.c

-              r39f892a9
+              r368ee04
 #include "private/ns.h"
 #include <vfs/vfs.h>
+#include <unistd.h>
 task_id_t task_get_id(void)
 …
+{
         /* Send default files */
+        int *files[4];
+        int fd_stdin;
+        int fd_stdout;
+        int fd_stderr;
+        if ((stdin != NULL) && (vfs_fhandle(stdin, &fd_stdin) == EOK))
+                files[0] = &fd_stdin;
+        else
+                files[0] = NULL;
+        if ((stdout != NULL) && (vfs_fhandle(stdout, &fd_stdout) == EOK))
+                files[1] = &fd_stdout;
+        else
+                files[1] = NULL;
+        if ((stderr != NULL) && (vfs_fhandle(stderr, &fd_stderr) == EOK))
+                files[2] = &fd_stderr;
+        else
+                files[2] = NULL;
+        files[3] = NULL;
+        return task_spawnvf(id, wait, path, args, files);
+        int fd_stdin = -1;
+        int fd_stdout = -1;
+        int fd_stderr = -1;
+        if (stdin != NULL) {
+                (void) vfs_fhandle(stdin, &fd_stdin);
+        }
+        if (stdout != NULL) {
+                (void) vfs_fhandle(stdout, &fd_stdout);
+        }
+        if (stderr != NULL) {
+                (void) vfs_fhandle(stderr, &fd_stderr);
+        }
+        return task_spawnvf(id, wait, path, args, fd_stdin, fd_stdout,
+            fd_stderr);
+}
 …
  * Files are passed as null-terminated array of pointers to fdi_node_t.
+ *
+ * @param id    If not NULL, the ID of the task is stored here on success.
+ * @param wait  If not NULL, setup waiting for task's return value and store
+ *              the information necessary for waiting here on success.
+ * @param path  Pathname of the binary to execute.
+ * @param argv  Command-line arguments.
+ * @param files Standard files to use.
+ * @param id      If not NULL, the ID of the task is stored here on success.
+ * @param wait    If not NULL, setup waiting for task's return value and store
+ * @param path    Pathname of the binary to execute.
+ * @param argv    Command-line arguments.
+ * @param std_in  File to use as stdin.
+ * @param std_out File to use as stdout.
+ * @param std_err File to use as stderr.
+ *
  * @return Zero on success or negative error code.
 …
  */
 int task_spawnvf(task_id_t *id, task_wait_t *wait, const char *path,
     const char *const args[], int *const files[])
+    const char *const args[], int fd_stdin, int fd_stdout, int fd_stderr)
+{
         /* Connect to a program loader. */
 …
                 goto error;
         /* Send program pathname. */
         rc = loader_set_pathname(ldr, path);
+        /* Send program binary. */
+        rc = loader_set_program_path(ldr, path);
         if (rc != EOK)
                 goto error;
 …
         /* Send files */
+        rc = loader_set_files(ldr, files);
+        if (rc != EOK)
+                goto error;
+        int root = vfs_root();
+        if (root >= 0) {
+                rc = loader_add_inbox(ldr, "root", root);
+                vfs_put(root);
+                if (rc != EOK)
+                        goto error;
+        }
+        if (fd_stdin >= 0) {
+                rc = loader_add_inbox(ldr, "stdin", fd_stdin);
+                if (rc != EOK)
+                        goto error;
+        }
+        if (fd_stdout >= 0) {
+                rc = loader_add_inbox(ldr, "stdout", fd_stdout);
+                if (rc != EOK)
+                        goto error;
+        }
+        if (fd_stderr >= 0) {
+                rc = loader_add_inbox(ldr, "stderr", fd_stderr);
+                if (rc != EOK)
+                        goto error;
+        }
         /* Load the program. */

uspace/lib/c/generic/vfs/vfs.c

-              r39f892a9
+              r368ee04
  */
+#include <vfs/vfs.h>
 #include <vfs/canonify.h>
 #include <vfs/vfs.h>
+#include <vfs/vfs_mtab.h>
 #include <vfs/vfs_sess.h>
 #include <macros.h>
 #include <stdlib.h>
-#include <unistd.h>
-#include <dirent.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <sys/stat.h>
-#include <sys/statfs.h>
 #include <sys/types.h>
 #include <ipc/services.h>
 …
 #include <ipc/loc.h>
+/*
+ * This file contains the implementation of the native HelenOS file system API.
+ *
+ * The API supports client-side file system roots, client-side IO cursors and
+ * uses file handles as a primary means to refer to files. In order to call the
+ * API functions, one just includes vfs/vfs.h.
+ *
+ * The API functions come in two main flavors:
+ *
+ * - functions that operate on integer file handles, such as:
+ *   vfs_walk(), vfs_open(), vfs_read(), vfs_link(), ...
+ *
+ * - functions that operate on paths, such as:
+ *   vfs_lookup(), vfs_link_path(), vfs_unlink_path(), vfs_rename_path(), ...
+ *
+ * There is usually a corresponding path function for each file handle function
+ * that exists mostly as a convenience wrapper, except for cases when only a
+ * path version exists due to file system consistency considerations (see
+ * vfs_rename_path()). Sometimes one of the versions does not make sense, in
+ * which case it is also omitted.
+ *
+ * Besides of that, the API provides some convenience wrappers for frequently
+ * performed pairs of operations, for example there is a combo API for
+ * vfs_lookup() and vfs_open(): vfs_lookup_open().
+ *
+ * Some of the functions here return a file handle that can be passed to other
+ * functions. Note that a file handle does not automatically represent a file
+ * from which one can read or to which one can write. In order to do so, the
+ * file handle must be opened first for reading/writing using vfs_open().
+ *
+ * All file handles, no matter whether opened or not, must be eventually
+ * returned to the system using vfs_put(). Non-returned file handles are in use
+ * and consume system resources.
+ *
+ * Functions that return int return a negative error code on error and do not
+ * set errno. Depending on function, success is signalled by returning either
+ * EOK or a non-negative file handle.
+ *
+ * An example life-cycle of a file handle is as follows:
+ *
+ *      #include <vfs/vfs.h>
+ *
+ *      int file = vfs_lookup("/foo/bar/foobar", WALK_REGULAR);
+ *      if (file < 0)
+ *              return file;
+ *      int rc = vfs_open(file, MODE_READ);
+ *      if (rc != EOK) {
+ *              (void) vfs_put(file);
+ *              return rc;
+ *      }
+ *      aoff64_t pos = 42;
+ *      char buf[512];
+ *      ssize_t size = vfs_read(file, &pos, buf, sizeof(buf));
+ *      if (size < 0) {
+ *              vfs_put(file);
+ *              return size;
+ *      }
+ *
+ *      // buf is now filled with data from file
+ *
+ *      vfs_put(file);
+ */
 static FIBRIL_MUTEX_INITIALIZE(vfs_mutex);
 static async_sess_t *vfs_sess = NULL;
 …
 static size_t cwd_size = 0;
+/** Start an async exchange on the VFS session.
+ *
+ * @return New exchange.
+ *
+ */
+async_exch_t *vfs_exchange_begin(void)
+{
+        fibril_mutex_lock(&vfs_mutex);
+        while (vfs_sess == NULL)
+                vfs_sess = service_connect_blocking(SERVICE_VFS, INTERFACE_VFS,
+);
+        fibril_mutex_unlock(&vfs_mutex);
+        return async_exchange_begin(vfs_sess);
+}
+/** Finish an async exchange on the VFS session.
+ *
+ * @param exch Exchange to be finished.
+ *
+ */
+void vfs_exchange_end(async_exch_t *exch)
+{
+        async_exchange_end(exch);
+}
+static FIBRIL_MUTEX_INITIALIZE(root_mutex);
+static int root_fd = -1;
+static int get_parent_and_child(const char *path, char **child)
+{
+        size_t size;
+        char *apath = vfs_absolutize(path, &size);
+        if (!apath)
+                return ENOMEM;
+        char *slash = str_rchr(apath, L'/');
+        int parent;
+        if (slash == apath) {
+                parent = vfs_root();
+                *child = apath;
+        } else {
+                *slash = '\0';
+                parent = vfs_lookup(apath, WALK_DIRECTORY);
+                if (parent < 0) {
+                        free(apath);
+                        return parent;
+                }
+                *slash = '/';
+                *child = str_dup(slash);
+                free(apath);
+                if (!*child) {
+                        vfs_put(parent);
+                        return ENOMEM;
+                }
+        }
+        return parent;
+}
+/** Make a potentially relative path absolute
+ *
+ * This function coverts a current-working-directory-relative path into a
+ * well-formed, absolute path. The caller is responsible for deallocating the
+ * returned buffer.
+ *
+ * @param[in] path      Path to be absolutized
+ * @param[out] retlen   Length of the absolutized path
+ *
+ * @return              New buffer holding the absolutized path or NULL
+ */
 char *vfs_absolutize(const char *path, size_t *retlen)
+{
 …
+}
+int vfs_mount(const char *fs_name, const char *mp, const char *fqsn,
+/** Clone a file handle
+ *
+ * The caller can choose whether to clone an existing file handle into another
+ * already existing file handle (in which case it is first closed) or to a new
+ * file handle allocated either from low or high indices.
+ *
+ * @param file_from     Source file handle
+ * @param file_to       Destination file handle or -1
+ * @param high          If file_to is -1, high controls whether the new file
+ *                      handle will be allocated from high indices
+ *
+ * @return              New file handle on success or a negative error code
+ */
+int vfs_clone(int file_from, int file_to, bool high)
+{
+        async_exch_t *vfs_exch = vfs_exchange_begin();
+        int rc = async_req_3_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file_from,
+            (sysarg_t) file_to, (sysarg_t) high);
+        vfs_exchange_end(vfs_exch);
+        return rc;
+}
+/** Get current working directory path
+ *
+ * @param[out] buf      Buffer
+ * @param size          Size of @a buf
+ *
+ * @return              EOK on success or a non-negative error code
+ */
+int vfs_cwd_get(char *buf, size_t size)
+{
+        fibril_mutex_lock(&cwd_mutex);
+        if ((cwd_size == 0) || (size < cwd_size + 1)) {
+                fibril_mutex_unlock(&cwd_mutex);
+                return ERANGE;
+        }
+        str_cpy(buf, size, cwd_path);
+        fibril_mutex_unlock(&cwd_mutex);
+        return EOK;
+}
+/** Change working directory
+ *
+ * @param path  Path of the new working directory
+ *
+ * @return      EOK on success or a negative error code
+ */
+int vfs_cwd_set(const char *path)
+{
+        size_t abs_size;
+        char *abs = vfs_absolutize(path, &abs_size);
+        if (!abs)
+                return ENOMEM;
+        int fd = vfs_lookup(abs, WALK_DIRECTORY);
+        if (fd < 0) {
+                free(abs);
+                return fd;
+        }
+        fibril_mutex_lock(&cwd_mutex);
+        if (cwd_fd >= 0)
+                vfs_put(cwd_fd);
+        if (cwd_path)
+                free(cwd_path);
+        cwd_fd = fd;
+        cwd_path = abs;
+        cwd_size = abs_size;
+        fibril_mutex_unlock(&cwd_mutex);
+        return EOK;
+}
+/** Start an async exchange on the VFS session
+ *
+ * @return      New exchange
+ */
+async_exch_t *vfs_exchange_begin(void)
+{
+        fibril_mutex_lock(&vfs_mutex);
+        while (vfs_sess == NULL) {
+                vfs_sess = service_connect_blocking(SERVICE_VFS, INTERFACE_VFS,
+);
+        }
+        fibril_mutex_unlock(&vfs_mutex);
+        return async_exchange_begin(vfs_sess);
+}
+/** Finish an async exchange on the VFS session
+ *
+ * @param exch  Exchange to be finished
+ */
+void vfs_exchange_end(async_exch_t *exch)
+{
+        async_exchange_end(exch);
+}
+/** Open session to service represented by a special file
+ *
+ * Given that the file referred to by @a file represents a service,
+ * open a session to that service.
+ *
+ * @param file  File handle representing a service
+ * @param iface Interface to connect to (XXX Should be automatic)
+ *
+ * @return      Session pointer on success.
+ * @return      @c NULL or error.
+ */
+async_sess_t *vfs_fd_session(int file, iface_t iface)
+{
+        struct stat stat;
+        int rc = vfs_stat(file, &stat);
+        if (rc != 0)
+                return NULL;
+        if (stat.service == 0)
+                return NULL;
+        return loc_service_connect(stat.service, iface, 0);
+}
+/** Link a file or directory
+ *
+ * Create a new name and an empty file or an empty directory in a parent
+ * directory. If child with the same name already exists, the function returns
+ * a failure, the existing file remains untouched and no file system object
+ * is created.
+ *
+ * @param parent        File handle of the parent directory node
+ * @param child         New name to be linked
+ * @param kind          Kind of the object to be created: KIND_FILE or
+ *                      KIND_DIRECTORY
+ * @param[out] linkedfd If not NULL, will receive a file handle to the linked
+ *                      child
+ * @return              EOK on success or a negative error code
+ */
+int vfs_link(int parent, const char *child, vfs_file_kind_t kind, int *linkedfd)
+{
+        int flags = (kind == KIND_DIRECTORY) ? WALK_DIRECTORY : WALK_REGULAR;
+        int file = vfs_walk(parent, child, WALK_MUST_CREATE | flags);
+        if (file < 0)
+                return file;
+        if (linkedfd)
+                *linkedfd = file;
+        else
+                vfs_put(file);
+        return EOK;
+}
+/** Link a file or directory
+ *
+ * Create a new name and an empty file or an empty directory at given path.
+ * If a link with the same name already exists, the function returns
+ * a failure, the existing file remains untouched and no file system object
+ * is created.
+ *
+ * @param path          New path to be linked
+ * @param kind          Kind of the object to be created: KIND_FILE or
+ *                      KIND_DIRECTORY
+ * @param[out] linkedfd If not NULL, will receive a file handle to the linked
+ *                      child
+ * @return              EOK on success or a negative error code
+ */
+int vfs_link_path(const char *path, vfs_file_kind_t kind, int *linkedfd)
+{
+        char *child;
+        int parent = get_parent_and_child(path, &child);
+        if (parent < 0)
+                return parent;
+        int rc = vfs_link(parent, child, kind, linkedfd);
+        free(child);
+        vfs_put(parent);
+        return rc;
+}
+/** Lookup a path relative to the local root
+ *
+ * @param path  Path to be looked up
+ * @param flags Walk flags
+ *
+ * @return      File handle representing the result on success or a negative
+ *              error code on error
+ */
+int vfs_lookup(const char *path, int flags)
+{
+        size_t size;
+        char *p = vfs_absolutize(path, &size);
+        if (!p)
+                return ENOMEM;
+        int root = vfs_root();
+        if (root < 0) {
+                free(p);
+                return ENOENT;
+        }
+        int rc = vfs_walk(root, p, flags);
+        vfs_put(root);
+        free(p);
+        return rc;
+}
+/** Lookup a path relative to the local root and open the result
+ *
+ * This function is a convenience combo for vfs_lookup() and vfs_open().
+ *
+ * @param path  Path to be looked up
+ * @param flags Walk flags
+ * @param mode  Mode in which to open file in
+ *
+ * @return      EOK on success or a negative error code
+ */
+int vfs_lookup_open(const char *path, int flags, int mode)
+{
+        int file = vfs_lookup(path, flags);
+        if (file < 0)
+                return file;
+        int rc = vfs_open(file, mode);
+        if (rc != EOK) {
+                vfs_put(file);
+                return rc;
+        }
+        return file;
+}
+/** Mount a file system
+ *
+ * @param[in] mp                File handle representing the mount-point
+ * @param[in] fs_name           File system name
+ * @param[in] serv              Service representing the mountee
+ * @param[in] opts              Mount options for the endpoint file system
+ * @param[in] flags             Mount flags
+ * @param[in] instance          Instance number of the file system server
+ * @param[out] mountedfd        File handle of the mounted root if not NULL
+ *
+ * @return                      EOK on success or a negative error code
+ */
+int vfs_mount(int mp, const char *fs_name, service_id_t serv, const char *opts,
+    unsigned int flags, unsigned int instance, int *mountedfd)
+{
+        sysarg_t rc, rc1;
+        if (!mountedfd)
+                flags |= VFS_MOUNT_NO_REF;
+        if (mp < 0)
+                flags |= VFS_MOUNT_CONNECT_ONLY;
+        ipc_call_t answer;
+        async_exch_t *exch = vfs_exchange_begin();
+        aid_t req = async_send_4(exch, VFS_IN_MOUNT, mp, serv, flags, instance,
+            &answer);
+        rc1 = async_data_write_start(exch, (void *) opts, str_size(opts));
+        if (rc1 == EOK) {
+                rc1 = async_data_write_start(exch, (void *) fs_name,
+                    str_size(fs_name));
+        }
+        vfs_exchange_end(exch);
+        async_wait_for(req, &rc);
+        if (mountedfd)
+                *mountedfd = (int) IPC_GET_ARG1(answer);
+        if (rc != EOK)
+                return rc;
+        return rc1;
+}
+/** Mount a file system
+ *
+ * @param[in] mp                Path representing the mount-point
+ * @param[in] fs_name           File system name
+ * @param[in] fqsn              Fully qualified service name of the mountee
+ * @param[in] opts              Mount options for the endpoint file system
+ * @param[in] flags             Mount flags
+ * @param[in] instance          Instance number of the file system server
+ *
+ * @return                      EOK on success or a negative error code
+ */
+int vfs_mount_path(const char *mp, const char *fs_name, const char *fqsn,
     const char *opts, unsigned int flags, unsigned int instance)
+{
 …
         if (str_cmp(fqsn, "") == 0) {
+                /* No device specified, create a fresh
+                   null/%d device instead */
+                /*
+                 * No device specified, create a fresh null/%d device instead.
+                */
                 null_id = loc_null_create();
 …
+        }
+        if (flags & IPC_FLAG_BLOCKING)
+                flags = VFS_MOUNT_BLOCKING;
+        else
+                flags = 0;
         service_id_t service_id;
         int res = loc_service_get_id(fqsn, &service_id, flags);
 …
+        }
+        async_exch_t *exch = vfs_exchange_begin();
+        sysarg_t rc_orig;
+        aid_t req = async_send_3(exch, VFS_IN_MOUNT, service_id, flags,
+            instance, NULL);
+        sysarg_t rc = async_data_write_start(exch, (void *) mpa, mpa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+        fibril_mutex_lock(&root_mutex);
+        int rc;
+        if (str_cmp(mpa, "/") == 0) {
+                /* Mounting root. */
+                if (null_id != -1)
+                        loc_null_destroy(null_id);
+                if (root_fd >= 0) {
+                        fibril_mutex_unlock(&root_mutex);
+                        if (null_id != -1)
+                                loc_null_destroy(null_id);
+                        return EBUSY;
+                }
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        rc = async_data_write_start(exch, (void *) opts, str_size(opts));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+                int root;
+                rc = vfs_mount(-1, fs_name, service_id, opts, flags, instance,
+                    &root);
+                if (rc == EOK)
+                        root_fd = root;
+        } else {
+                if (root_fd < 0) {
+                        fibril_mutex_unlock(&root_mutex);
+                        if (null_id != -1)
+                                loc_null_destroy(null_id);
+                        return EINVAL;
+                }
+                if (null_id != -1)
+                        loc_null_destroy(null_id);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        rc = async_data_write_start(exch, (void *) fs_name, str_size(fs_name));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+                if (null_id != -1)
+                        loc_null_destroy(null_id);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        /* Ask VFS whether it likes fs_name. */
+        rc = async_req_0_0(exch, VFS_IN_PING);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+                if (null_id != -1)
+                        loc_null_destroy(null_id);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(exch);
+        free(mpa);
+        async_wait_for(req, &rc);
+                int mpfd = vfs_walk(root_fd, mpa, WALK_DIRECTORY);
+                if (mpfd >= 0) {
+                        rc = vfs_mount(mpfd, fs_name, service_id, opts, flags,
+                            instance, NULL);
+                        vfs_put(mpfd);
+                } else {
+                        rc = mpfd;
+                }
+        }
+        fibril_mutex_unlock(&root_mutex);
         if ((rc != EOK) && (null_id != -1))
 …
+}
+int vfs_unmount(const char *mp)
+{
+        sysarg_t rc;
+        sysarg_t rc_orig;
+        aid_t req;
+        size_t mpa_size;
+        char *mpa;
+        mpa = vfs_absolutize(mp, &mpa_size);
+        if (mpa == NULL)
+                return ENOMEM;
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_UNMOUNT, NULL);
+        rc = async_data_write_start(exch, (void *) mpa, mpa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(exch);
+        free(mpa);
+        async_wait_for(req, &rc);
+        return (int) rc;
+}
+/** Open file (internal).
+ *
+ * @param abs Absolute path to file
+ * @param abs_size Size of @a abs string
+ * @param lflag L_xxx flags
+ * @param oflag O_xxx flags
+ * @param fd Place to store new file descriptor
+ *
+ * @return EOK on success, non-zero error code on error
+ */
+static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag,
+    int *fd)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        ipc_call_t answer;
+        aid_t req = async_send_3(exch, VFS_IN_OPEN, lflag, oflag, 0, &answer);
+        sysarg_t rc = async_data_write_start(exch, abs, abs_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(exch);
+        async_wait_for(req, &rc);
+/** Open a file handle for I/O
+ *
+ * @param file  File handle to enable I/O on
+ * @param mode  Mode in which to open file in
+ *
+ * @return      EOK on success or a negative error code
+ */
+int vfs_open(int file, int mode)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        int rc = async_req_2_0(exch, VFS_IN_OPEN, file, mode);
+        vfs_exchange_end(exch);
+        return rc;
+}
+/** Pass a file handle to another VFS client
+ *
+ * @param vfs_exch      Donor's VFS exchange
+ * @param file          Donor's file handle to pass
+ * @param exch          Exchange to the acceptor
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_pass_handle(async_exch_t *vfs_exch, int file, async_exch_t *exch)
+{
+        return async_state_change_start(exch, VFS_PASS_HANDLE, (sysarg_t) file,
+, vfs_exch);
+}
+/** Stop working with a file handle
+ *
+ * @param file  File handle to put
+ *
+ * @return      EOK on success or a negative error code
+ */
+int vfs_put(int file)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        int rc = async_req_1_0(exch, VFS_IN_PUT, file);
+        vfs_exchange_end(exch);
+        return rc;
+}
+/** Receive a file handle from another VFS client
+ *
+ * @param high   If true, the received file handle will be allocated from high
+ *               indices
+ *
+ * @return       EOK on success or a negative error code
+ */
+int vfs_receive_handle(bool high)
+{
+        ipc_callid_t callid;
+        if (!async_state_change_receive(&callid, NULL, NULL, NULL)) {
+                async_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        async_exch_t *vfs_exch = vfs_exchange_begin();
+        async_state_change_finalize(callid, vfs_exch);
+        sysarg_t ret;
+        sysarg_t rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE, high, &ret);
+        async_exchange_end(vfs_exch);
         if (rc != EOK)
+            return (int) rc;
+        *fd = (int) IPC_GET_ARG1(answer);
+        return EOK;
+}
+/** Open file.
+ *
+ * @param path File path
+ * @param oflag O_xxx flags
+ * @param mode File mode (only with O_CREAT)
+ *
+ * @return Nonnegative file descriptor on success. On error -1 is returned
+ *         and errno is set.
+ */
+int open(const char *path, int oflag, ...)
+{
+        size_t abs_size;
+        char *abs = vfs_absolutize(path, &abs_size);
+        int fd = -1;
+        if (abs == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        int rc = open_internal(abs, abs_size, L_FILE, oflag, &fd);
+        free(abs);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return fd;
+}
+/** Close file.
+ *
+ * @param fildes File descriptor
+ * @return Zero on success. On error -1 is returned and errno is set.
+ */
+int close(int fildes)
+{
+        sysarg_t rc;
+        async_exch_t *exch = vfs_exchange_begin();
+        rc = async_req_1_0(exch, VFS_IN_CLOSE, fildes);
+        vfs_exchange_end(exch);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Read bytes from file.
+                return rc;
+        return ret;
+}
+/** Read data
+ *
+ * Read up to @a nbytes bytes from file if available. This function always reads
+ * all the available bytes up to @a nbytes.
+ *
+ * @param file          File handle to read from
+ * @param[inout] pos    Position to read from, updated by the actual bytes read
+ * @param buf           Buffer, @a nbytes bytes long
+ * @param nbytes        Number of bytes to read
+ *
+ * @return              On success, non-negative number of bytes read
+ * @return              On failure, a negative error code
+ */
+ssize_t vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        size_t nread = 0;
+        uint8_t *bp = (uint8_t *) buf;
+        int rc;
+        do {
+                bp += cnt;
+                nread += cnt;
+                *pos += cnt;
+                rc = vfs_read_short(file, *pos, bp, nbyte - nread, &cnt);
+        } while (rc == EOK && cnt > 0 && (nbyte - nread - cnt) > 0);
+        if (rc != EOK)
+                return rc;
+        *pos += cnt;
+        return nread + cnt;
+}
+/** Read bytes from a file
+ *
  * Read up to @a nbyte bytes from file. The actual number of bytes read
 …
  * return success with zero bytes read.
+ *
+ * @param fildes File descriptor
+ * @param buf Buffer
+ * @param nbyte Maximum number of bytes to read
+ * @param nread Place to store actual number of bytes read (0 or more)
+ *
+ * @return EOK on success, non-zero error code on error.
+ */
+static int _read_short(int fildes, void *buf, size_t nbyte, ssize_t *nread)
+ * @param file          File handle to read from
+ * @param[in] pos       Position to read from
+ * @param buf           Buffer to read from
+ * @param nbyte         Maximum number of bytes to read
+ * @param[out] nread    Actual number of bytes read (0 or more)
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_read_short(int file, aoff64_t pos, void *buf, size_t nbyte,
+    ssize_t *nread)
+{
         sysarg_t rc;
 …
         async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_READ, fildes, &answer);
+        req = async_send_3(exch, VFS_IN_READ, file, LOWER32(pos),
+            UPPER32(pos), &answer);
         rc = async_data_read_start(exch, (void *) buf, nbyte);
+        vfs_exchange_end(exch);
+        if (rc == EOK)
+                async_wait_for(req, &rc);
+        else
+                async_forget(req);
+        if (rc != EOK)
+                return rc;
+        *nread = (ssize_t) IPC_GET_ARG1(answer);
+        return EOK;
+}
+/** Rename a file or directory
+ *
+ * There is no file-handle-based variant to disallow attempts to introduce loops
+ * and breakage in the directory tree when relinking eg. a node under its own
+ * descendant.  The path-based variant is not susceptible because the VFS can
+ * prevent this lexically by comparing the paths.
+ *
+ * @param old   Old path
+ * @param new   New path
+ *
+ * @return      EOK on success or a negative error code
+ */
+int vfs_rename_path(const char *old, const char *new)
+{
+        sysarg_t rc;
+        sysarg_t rc_orig;
+        aid_t req;
+        size_t olda_size;
+        char *olda = vfs_absolutize(old, &olda_size);
+        if (olda == NULL)
+                return ENOMEM;
+        size_t newa_size;
+        char *newa = vfs_absolutize(new, &newa_size);
+        if (newa == NULL) {
+                free(olda);
+                return ENOMEM;
+        }
+        async_exch_t *exch = vfs_exchange_begin();
+        int root = vfs_root();
+        if (root < 0) {
+                free(olda);
+                free(newa);
+                return ENOENT;
+        }
+        req = async_send_1(exch, VFS_IN_RENAME, root, NULL);
+        rc = async_data_write_start(exch, olda, olda_size);
         if (rc != EOK) {
                 vfs_exchange_end(exch);
+                sysarg_t rc_orig;
+                free(olda);
+                free(newa);
+                vfs_put(root);
                 async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return rc;
+                else
+                        return rc_orig;
+        }
+        vfs_exchange_end(exch);
+        async_wait_for(req, &rc);
+        if (rc != EOK)
+                if (rc_orig != EOK)
+                        rc = rc_orig;
                 return rc;
+        *nread = (ssize_t) IPC_GET_ARG1(answer);
+        return EOK;
+}
+/** Write bytes to file.
+ *
+ * Write up to @a nbyte bytes from file. The actual number of bytes written
+ * may be lower, but greater than zero.
+ *
+ * @param fildes File descriptor
+ * @param buf Buffer
+ * @param nbyte Maximum number of bytes to write
+ * @param nread Place to store actual number of bytes written (0 or more)
+ *
+ * @return EOK on success, non-zero error code on error.
+ */
+static int _write_short(int fildes, const void *buf, size_t nbyte,
+    ssize_t *nwritten)
+{
+        sysarg_t rc;
+        ipc_call_t answer;
+        aid_t req;
+        if (nbyte > DATA_XFER_LIMIT)
+                nbyte = DATA_XFER_LIMIT;
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_WRITE, fildes, &answer);
+        rc = async_data_write_start(exch, (void *) buf, nbyte);
+        }
+        rc = async_data_write_start(exch, newa, newa_size);
         if (rc != EOK) {
                 vfs_exchange_end(exch);
+                sysarg_t rc_orig;
+                free(olda);
+                free(newa);
+                vfs_put(root);
                 async_wait_for(req, &rc_orig);
                 if (rc_orig == EOK)
                         return rc;
                 else
                         return rc_orig;
+        }
         vfs_exchange_end(exch);
+                if (rc_orig != EOK)
+                        rc = rc_orig;
+                return rc;
+        }
+        vfs_exchange_end(exch);
+        free(olda);
+        free(newa);
+        vfs_put(root);
         async_wait_for(req, &rc);
+        if (rc != EOK)
+                return rc;
+        *nwritten = (ssize_t) IPC_GET_ARG1(answer);
+        return EOK;
+}
+/** Read data.
+ *
+ * Read up to @a nbytes bytes from file if available. This function always reads
+ * all the available bytes up to @a nbytes.
+ *
+ * @param fildes        File descriptor
+ * @param buf           Buffer, @a nbytes bytes long
+ * @param nbytes        Number of bytes to read
+ *
+ * @return              On success, nonnegative number of bytes read.
+ *                      On failure, -1 and sets errno.
+ */
+ssize_t read(int fildes, void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        size_t nread = 0;
+        uint8_t *bp = (uint8_t *) buf;
+        int rc;
+        do {
+                bp += cnt;
+                nread += cnt;
+                rc = _read_short(fildes, bp, nbyte - nread, &cnt);
+        } while (rc == EOK && cnt > 0 && (nbyte - nread - cnt) > 0);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return nread + cnt;
+}
+/** Write data.
+ *
+ * This function fails if it cannot write exactly @a len bytes to the file.
+ *
+ * @param fildes        File descriptor
+ * @param buf           Data, @a nbytes bytes long
+ * @param nbytes        Number of bytes to write
+ *
+ * @return              On success, nonnegative number of bytes written.
+ *                      On failure, -1 and sets errno.
+ */
+ssize_t write(int fildes, const void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        ssize_t nwritten = 0;
+        const uint8_t *bp = (uint8_t *) buf;
+        int rc;
+        do {
+                bp += cnt;
+                nwritten += cnt;
+                rc = _write_short(fildes, bp, nbyte - nwritten, &cnt);
+        } while (rc == EOK && ((ssize_t )nbyte - nwritten - cnt) > 0);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return nbyte;
+}
+/** Synchronize file.
+ *
+ * @param fildes File descriptor
+ * @return 0 on success. On error returns -1 and sets errno.
+ */
+int fsync(int fildes)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        sysarg_t rc = async_req_1_0(exch, VFS_IN_SYNC, fildes);
+        vfs_exchange_end(exch);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Seek to a position.
+ *
+ * @param fildes File descriptor
+ * @param offset Offset
+ * @param whence SEEK_SET, SEEK_CUR or SEEK_END
+ *
+ * @return On success the nonnegative offset from start of file. On error
+ *         returns (off64_t)-1 and sets errno.
+ */
+off64_t lseek(int fildes, off64_t offset, int whence)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        sysarg_t newoff_lo;
+        sysarg_t newoff_hi;
+        sysarg_t rc = async_req_4_2(exch, VFS_IN_SEEK, fildes,
+            LOWER32(offset), UPPER32(offset), whence,
+            &newoff_lo, &newoff_hi);
+        vfs_exchange_end(exch);
+        if (rc != EOK) {
+                errno = rc;
+                return (off64_t) -1;
+        }
+        return (off64_t) MERGE_LOUP32(newoff_lo, newoff_hi);
+}
+/** Truncate file to a specified length.
+ *
+ * Truncate file so that its size is exactly @a length
+ *
+ * @param fildes File descriptor
+ * @param length Length
+ *
+ * @return 0 on success, -1 on error and sets errno.
+ */
+int ftruncate(int fildes, aoff64_t length)
+{
+        sysarg_t rc;
+        async_exch_t *exch = vfs_exchange_begin();
+        rc = async_req_3_0(exch, VFS_IN_TRUNCATE, fildes,
+            LOWER32(length), UPPER32(length));
+        vfs_exchange_end(exch);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Get file status.
+ *
+ * @param fildes File descriptor
+ * @param stat Place to store file information
+ *
+ * @return 0 on success, -1 on error and sets errno.
+ */
+int fstat(int fildes, struct stat *stat)
+        return rc;
+}
+/** Resize file to a specified length
+ *
+ * Resize file so that its size is exactly @a length.
+ *
+ * @param file          File handle to resize
+ * @param length        New length
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_resize(int file, aoff64_t length)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        int rc = async_req_3_0(exch, VFS_IN_RESIZE, file, LOWER32(length),
+            UPPER32(length));
+        vfs_exchange_end(exch);
+        return rc;
+}
+/** Return a new file handle representing the local root
+ *
+ * @return      A clone of the local root file handle or a negative error code
+ */
+int vfs_root(void)
+{
+        fibril_mutex_lock(&root_mutex);
+        int r;
+        if (root_fd < 0)
+                r = ENOENT;
+        else
+                r = vfs_clone(root_fd, -1, true);
+        fibril_mutex_unlock(&root_mutex);
+        return r;
+}
+/** Set a new local root
+ *
+ * Note that it is still possible to have file handles for other roots and pass
+ * them to the API functions. Functions like vfs_root() and vfs_lookup() will
+ * however consider the file set by this function to be the root.
+ *
+ * @param nroot The new local root file handle
+ */
+void vfs_root_set(int nroot)
+{
+        fibril_mutex_lock(&root_mutex);
+        if (root_fd >= 0)
+                vfs_put(root_fd);
+        root_fd = vfs_clone(nroot, -1, true);
+        fibril_mutex_unlock(&root_mutex);
+}
+/** Get file information
+ *
+ * @param file          File handle to get information about
+ * @param[out] stat     Place to store file information
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_stat(int file, struct stat *stat)
+{
         sysarg_t rc;
 …
         async_exch_t *exch = vfs_exchange_begin();
         req = async_send_1(exch, VFS_IN_FSTAT, fildes, NULL);
+        req = async_send_1(exch, VFS_IN_STAT, file, NULL);
         rc = async_data_read_start(exch, (void *) stat, sizeof(struct stat));
         if (rc != EOK) {
 …
                 if (rc_orig != EOK)
                         rc = rc_orig;
-                if (rc != EOK) {
-                        errno = rc;
-                        return -1;
+                }
                 return 0;
+                return rc;
+        }
 …
         async_wait_for(req, &rc);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Get file status.
+ *
+ * @param path Path to file
+ * @param stat Place to store file information
+ *
+ * @return 0 on success, -1 on error and sets errno.
+ */
+int stat(const char *path, struct stat *stat)
+{
+        sysarg_t rc;
+        sysarg_t rc_orig;
+        return rc;
+}
+/** Get file information
+ *
+ * @param path          File path to get information about
+ * @param[out] stat     Place to store file information
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_stat_path(const char *path, struct stat *stat)
+{
+        int file = vfs_lookup(path, 0);
+        if (file < 0)
+                return file;
+        int rc = vfs_stat(file, stat);
+        vfs_put(file);
+        return rc;
+}
+/** Get filesystem statistics
+ *
+ * @param file          File located on the queried file system
+ * @param[out] st       Buffer for storing information
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_statfs(int file, struct statfs *st)
+{
+        sysarg_t rc, ret;
         aid_t req;
+        size_t pa_size;
+        char *pa = vfs_absolutize(path, &pa_size);
+        if (pa == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_STAT, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(pa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig != EOK)
+                        rc = rc_orig;
+                if (rc != EOK) {
+                        errno = rc;
+                        return -1;
+                }
+        }
+        rc = async_data_read_start(exch, stat, sizeof(struct stat));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(pa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig != EOK)
+                        rc = rc_orig;
+                if (rc != EOK) {
+                        errno = rc;
+                        return -1;
+                }
+        }
+        vfs_exchange_end(exch);
+        free(pa);
+        async_wait_for(req, &rc);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Open directory.
+ *
+ * @param dirname Directory pathname
+ *
+ * @return Non-NULL pointer on success. On error returns @c NULL and sets errno.
+ */
+DIR *opendir(const char *dirname)
+{
+        DIR *dirp = malloc(sizeof(DIR));
+        int fd = -1;
+        if (dirp == NULL) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        size_t abs_size;
+        char *abs = vfs_absolutize(dirname, &abs_size);
+        if (abs == NULL) {
+                free(dirp);
+                errno = ENOMEM;
+                return NULL;
+        }
+        int rc = open_internal(abs, abs_size, L_DIRECTORY, 0, &fd);
+        free(abs);
+        if (rc != EOK) {
+                free(dirp);
+                errno = rc;
+                return NULL;
+        }
+        dirp->fd = fd;
+        return dirp;
+}
+/** Read directory entry.
+ *
+ * @param dirp Open directory
+ * @return Non-NULL pointer to directory entry on success. On error returns
+ *         @c NULL and sets errno.
+ */
+struct dirent *readdir(DIR *dirp)
+{
+        int rc;
+        ssize_t len;
+        rc = _read_short(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1, &len);
+        if (rc != EOK) {
+                errno = rc;
+                return NULL;
+        }
+        (void) len;
+        return &dirp->res;
+}
+/** Rewind directory position to the beginning.
+ *
+ * @param dirp Open directory
+ */
+void rewinddir(DIR *dirp)
+{
+        (void) lseek(dirp->fd, 0, SEEK_SET);
+}
+/** Close directory.
+ *
+ * @param dirp Open directory
+ * @return 0 on success. On error returns -1 and sets errno.
+ */
+int closedir(DIR *dirp)
+{
+        int rc;
+        rc = close(dirp->fd);
+        free(dirp);
+        /* On error errno was set by close() */
+        return rc;
+}
+/** Create directory.
+ *
+ * @param path Path
+ * @param mode File mode
+ * @return 0 on success. On error returns -1 and sets errno.
+ */
+int mkdir(const char *path, mode_t mode)
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_STATFS, file, NULL);
+        rc = async_data_read_start(exch, (void *) st, sizeof(*st));
+        vfs_exchange_end(exch);
+        async_wait_for(req, &ret);
+        rc = (ret != EOK ? ret : rc);
+        return rc;
+}
+/** Get filesystem statistics
+ *
+ * @param file          Path pointing to the queried file system
+ * @param[out] st       Buffer for storing information
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_statfs_path(const char *path, struct statfs *st)
+{
+        int file = vfs_lookup(path, 0);
+        if (file < 0)
+                return file;
+        int rc = vfs_statfs(file, st);
+        vfs_put(file);
+        return rc;
+}
+/** Synchronize file
+ *
+ * @param file  File handle to synchronize
+ *
+ * @return      EOK on success or a negative error code
+ */
+int vfs_sync(int file)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        int rc = async_req_1_0(exch, VFS_IN_SYNC, file);
+        vfs_exchange_end(exch);
+        return rc;
+}
+/** Unlink a file or directory
+ *
+ * Unlink a name from a parent directory. The caller can supply the file handle
+ * of the unlinked child in order to detect a possible race with vfs_link() and
+ * avoid unlinking a wrong file. If the last link for a file or directory is
+ * removed, the FS implementation will deallocate its resources.
+ *
+ * @param parent        File handle of the parent directory node
+ * @param child         Old name to be unlinked
+ * @param expect        File handle of the unlinked child
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_unlink(int parent, const char *child, int expect)
+{
         sysarg_t rc;
         aid_t req;
+        size_t pa_size;
+        char *pa = vfs_absolutize(path, &pa_size);
+        if (pa == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_MKDIR, mode, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(pa);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_2(exch, VFS_IN_UNLINK, parent, expect, NULL);
+        rc = async_data_write_start(exch, child, str_size(child));
+        vfs_exchange_end(exch);
+        sysarg_t rc_orig;
+        async_wait_for(req, &rc_orig);
+        if (rc_orig != EOK)
+                return (int) rc_orig;
+        return rc;
+}
+/** Unlink a file or directory
+ *
+ * Unlink a path. If the last link for a file or directory is removed, the FS
+ * implementation will deallocate its resources.
+ *
+ * @param path          Old path to be unlinked
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_unlink_path(const char *path)
+{
+        int expect = vfs_lookup(path, 0);
+        if (expect < 0)
+                return expect;
+        char *child;
+        int parent = get_parent_and_child(path, &child);
+        if (parent < 0) {
+                vfs_put(expect);
+                return parent;
+        }
+        int rc = vfs_unlink(parent, child, expect);
+        free(child);
+        vfs_put(parent);
+        vfs_put(expect);
+        return rc;
+}
+/** Unmount a file system
+ *
+ * @param mp    File handle representing the mount-point
+ *
+ * @return      EOK on success or a negative error code
+ */
+int vfs_unmount(int mp)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        int rc = async_req_1_0(exch, VFS_IN_UNMOUNT, mp);
+        vfs_exchange_end(exch);
+        return rc;
+}
+/** Unmount a file system
+ *
+ * @param mpp   Mount-point path
+ *
+ * @return      EOK on success or a negative error code
+ */
+int vfs_unmount_path(const char *mpp)
+{
+        int mp = vfs_lookup(mpp, WALK_MOUNT_POINT | WALK_DIRECTORY);
+        if (mp < 0)
+                return mp;
+        int rc = vfs_unmount(mp);
+        vfs_put(mp);
+        return rc;
+}
+/** Walk a path starting in a parent node
+ *
+ * @param parent        File handle of the parent node where the walk starts
+ * @param path          Parent-relative path to be walked
+ * @param flags         Flags influencing the walk
+ *
+ * @retrun              File handle representing the result on success or
+ *                      a negative error code on error
+ */
+int vfs_walk(int parent, const char *path, int flags)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        ipc_call_t answer;
+        aid_t req = async_send_2(exch, VFS_IN_WALK, parent, flags, &answer);
+        sysarg_t rc = async_data_write_start(exch, path, str_size(path));
+        vfs_exchange_end(exch);
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+        sysarg_t rc_orig;
+        async_wait_for(req, &rc_orig);
+        if (rc_orig != EOK)
+                return (int) rc_orig;
+                if (rc_orig != EOK)
+                        rc = rc_orig;
+                if (rc != EOK) {
+                        errno = rc;
+                        return -1;
+                }
+                return 0;
+        }
+        vfs_exchange_end(exch);
+        free(pa);
+        async_wait_for(req, &rc);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Unlink a file or directory.
+ *
+ * @param path Path to file or empty directory
+ * @param lflag L_xxx flag (L_NONE, L_FILE or L_DIRECTORY)
+ * @return EOK on success, non-zero error code on error
+ */
+static int _unlink(const char *path, int lflag)
+        if (rc != EOK)
+                return (int) rc;
+        return (int) IPC_GET_ARG1(answer);
+}
+/** Write data
+ *
+ * This function fails if it cannot write exactly @a len bytes to the file.
+ *
+ * @param file          File handle to write to
+ * @param[inout] pos    Position to write to, updated by the actual bytes
+ *                      written
+ * @param buf           Data, @a nbytes bytes long
+ * @param nbytes        Number of bytes to write
+ *
+ * @return              On success, non-negative number of bytes written
+ * @return              On failure, a negative error code
+ */
+ssize_t vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        ssize_t nwritten = 0;
+        const uint8_t *bp = (uint8_t *) buf;
+        int rc;
+        do {
+                bp += cnt;
+                nwritten += cnt;
+                *pos += cnt;
+                rc = vfs_write_short(file, *pos, bp, nbyte - nwritten, &cnt);
+        } while (rc == EOK && ((ssize_t )nbyte - nwritten - cnt) > 0);
+        if (rc != EOK)
+                return rc;
+        *pos += cnt;
+        return nbyte;
+}
+/** Write bytes to a file
+ *
+ * Write up to @a nbyte bytes from file. The actual number of bytes written
+ * may be lower, but greater than zero.
+ *
+ * @param file          File handle to write to
+ * @param[in] pos       Position to write to
+ * @param buf           Buffer to write to
+ * @param nbyte         Maximum number of bytes to write
+ * @param[out] nread    Actual number of bytes written (0 or more)
+ *
+ * @return              EOK on success or a negative error code
+ */
+int vfs_write_short(int file, aoff64_t pos, const void *buf, size_t nbyte,
+    ssize_t *nwritten)
+{
         sysarg_t rc;
+        ipc_call_t answer;
         aid_t req;
+        size_t pa_size;
+        char *pa = vfs_absolutize(path, &pa_size);
+        if (pa == NULL)
+                return ENOMEM;
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_UNLINK, lflag, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(pa);
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(exch);
+        free(pa);
+        async_wait_for(req, &rc);
+        return rc;
+}
+/** Unlink file or directory.
+ *
+ * @param path Path
+ * @return EOk on success, error code on error
+ */
+int unlink(const char *path)
+{
+        int rc;
+        rc = _unlink(path, L_NONE);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Remove empty directory.
+ *
+ * @param path Path
+ * @return 0 on success. On error returns -1 and sets errno.
+ */
+int rmdir(const char *path)
+{
+        int rc;
+        rc = _unlink(path, L_DIRECTORY);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Rename directory entry.
+ *
+ * @param old Old name
+ * @param new New name
+ *
+ * @return 0 on success. On error returns -1 and sets errno.
+ */
+int rename(const char *old, const char *new)
+{
+        sysarg_t rc;
+        sysarg_t rc_orig;
+        aid_t req;
+        size_t olda_size;
+        char *olda = vfs_absolutize(old, &olda_size);
+        if (olda == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        size_t newa_size;
+        char *newa = vfs_absolutize(new, &newa_size);
+        if (newa == NULL) {
+                free(olda);
+                errno = ENOMEM;
+                return -1;
+        }
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_RENAME, NULL);
+        rc = async_data_write_start(exch, olda, olda_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(olda);
+                free(newa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig != EOK)
+                        rc = rc_orig;
+                if (rc != EOK) {
+                        errno = rc;
+                        return -1;
+                }
+                return 0;
+        }
+        rc = async_data_write_start(exch, newa, newa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(olda);
+                free(newa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig != EOK)
+                        rc = rc_orig;
+                if (rc != EOK) {
+                        errno = rc;
+                        return -1;
+                }
+                return 0;
+        }
+        vfs_exchange_end(exch);
+        free(olda);
+        free(newa);
+        async_wait_for(req, &rc);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+/** Remove directory entry.
+ *
+ * @param path Path
+ * @return 0 on success. On error returns -1 and sets errno.
+ */
+int remove(const char *path)
+{
+        return unlink(path);
+}
+/** Change working directory.
+ *
+ * @param path Path
+ * @return 0 on success. On error returns -1 and sets errno.
+ */
+int chdir(const char *path)
+{
+        size_t abs_size;
+        char *abs = vfs_absolutize(path, &abs_size);
+        int fd = -1;
+        if (abs == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        int rc = open_internal(abs, abs_size, L_DIRECTORY, O_DESC, &fd);
+        if (rc != EOK) {
+                free(abs);
+                errno = rc;
+                return -1;
+        }
+        fibril_mutex_lock(&cwd_mutex);
+        if (cwd_fd >= 0)
+                close(cwd_fd);
+        if (cwd_path)
+                free(cwd_path);
+        cwd_fd = fd;
+        cwd_path = abs;
+        cwd_size = abs_size;
+        fibril_mutex_unlock(&cwd_mutex);
+        return 0;
+}
+/** Get current working directory path.
+ *
+ * @param buf Buffer
+ * @param size Size of @a buf
+ * @return On success returns @a buf. On failure returns @c NULL and sets errno.
+ */
+char *getcwd(char *buf, size_t size)
+{
+        if (size == 0) {
+                errno = EINVAL;
+                return NULL;
+        }
+        fibril_mutex_lock(&cwd_mutex);
+        if ((cwd_size == 0) || (size < cwd_size + 1)) {
+                fibril_mutex_unlock(&cwd_mutex);
+                errno = ERANGE;
+                return NULL;
+        }
+        str_cpy(buf, size, cwd_path);
+        fibril_mutex_unlock(&cwd_mutex);
+        return buf;
+}
+/** Open session to service represented by a special file.
+ *
+ * Given that the file referred to by @a fildes represents a service,
+ * open a session to that service.
+ *
+ * @param fildes File descriptor
+ * @param iface Interface to connect to (XXX Should be automatic)
+ * @return On success returns session pointer. On error returns @c NULL.
+ */
+async_sess_t *vfs_fd_session(int fildes, iface_t iface)
+{
+        struct stat stat;
+        int rc = fstat(fildes, &stat);
+        if (rc != 0)
+                return NULL;
+        if (stat.service == 0)
+                return NULL;
+        return loc_service_connect(stat.service, iface, 0);
+}
+/** Duplicate open file.
+ *
+ * Duplicate open file under a new file descriptor.
+ *
+ * @param oldfd Old file descriptor
+ * @param newfd New file descriptor
+ * @return 0 on success. On error -1 is returned and errno is set
+ */
+int dup2(int oldfd, int newfd)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        sysarg_t ret;
+        sysarg_t rc = async_req_2_1(exch, VFS_IN_DUP, oldfd, newfd, &ret);
+        if (nbyte > DATA_XFER_LIMIT)
+                nbyte = DATA_XFER_LIMIT;
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_3(exch, VFS_IN_WRITE, file, LOWER32(pos),
+            UPPER32(pos), &answer);
+        rc = async_data_write_start(exch, (void *) buf, nbyte);
         vfs_exchange_end(exch);
         if (rc == EOK)
+                rc = ret;
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+}
+int vfs_fd_wait(void)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        sysarg_t ret;
+        sysarg_t rc = async_req_0_1(exch, VFS_IN_WAIT_HANDLE, &ret);
+        vfs_exchange_end(exch);
+        if (rc == EOK)
+                return (int) ret;
+        return (int) rc;
+}
+int vfs_get_mtab_list(list_t *mtab_list)
+{
+        sysarg_t rc;
+        aid_t req;
+        size_t i;
+        sysarg_t num_mounted_fs;
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_MTAB_GET, NULL);
+        /* Ask VFS how many filesystems are mounted */
+        rc = async_req_0_1(exch, VFS_IN_PING, &num_mounted_fs);
+                async_wait_for(req, &rc);
+        else
+                async_forget(req);
         if (rc != EOK)
+                goto exit;
+        for (i = 0; i < num_mounted_fs; ++i) {
+                mtab_ent_t *mtab_ent;
+                mtab_ent = malloc(sizeof(mtab_ent_t));
+                if (mtab_ent == NULL) {
+                        rc = ENOMEM;
+                        goto exit;
+                }
+                memset(mtab_ent, 0, sizeof(mtab_ent_t));
+                rc = async_data_read_start(exch, (void *) mtab_ent->mp,
+                    MAX_PATH_LEN);
+                if (rc != EOK)
+                        goto exit;
+                rc = async_data_read_start(exch, (void *) mtab_ent->opts,
+                        MAX_MNTOPTS_LEN);
+                if (rc != EOK)
+                        goto exit;
+                rc = async_data_read_start(exch, (void *) mtab_ent->fs_name,
+                        FS_NAME_MAXLEN);
+                if (rc != EOK)
+                        goto exit;
+                sysarg_t p[2];
+                rc = async_req_0_2(exch, VFS_IN_PING, &p[0], &p[1]);
+                if (rc != EOK)
+                        goto exit;
+                mtab_ent->instance = p[0];
+                mtab_ent->service_id = p[1];
+                link_initialize(&mtab_ent->link);
+                list_append(&mtab_ent->link, mtab_list);
+        }
+exit:
+        async_wait_for(req, &rc);
+        vfs_exchange_end(exch);
+        return rc;
+}
+/** Get filesystem statistics.
+ *
+ * @param path Mount point path
+ * @param st Buffer for storing information
+ * @return 0 on success. On error -1 is returned and errno is set.
+ */
+int statfs(const char *path, struct statfs *st)
+{
+        sysarg_t rc, rc_orig;
+        aid_t req;
+        size_t pa_size;
+        char *pa = vfs_absolutize(path, &pa_size);
+        if (pa == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_STATFS, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK)
+                goto exit;
+        rc = async_data_read_start(exch, (void *) st, sizeof(*st));
+exit:
+        vfs_exchange_end(exch);
+        free(pa);
+        async_wait_for(req, &rc_orig);
+        rc = (rc_orig != EOK ? rc_orig : rc);
+        if (rc != EOK) {
+                errno = rc;
+                return -1;
+        }
+        return 0;
+                return rc;
+        *nwritten = (ssize_t) IPC_GET_ARG1(answer);
+        return EOK;
+}

uspace/lib/c/include/dirent.h

-              r39f892a9
+              r368ee04
 #define NAME_MAX  256
+#include <sys/types.h>
 struct dirent {
         char d_name[NAME_MAX + 1];
 …
         int fd;
         struct dirent res;
+        aoff64_t pos;
 } DIR;

uspace/lib/c/include/elf/elf_load.h

r39f892a9	r368ee04
45	45	} elf_info_t;
46	46
47		extern int elf_load(const char , elf_info_t );
	47	extern int elf_load(int, elf_info_t *);
48	48	extern void elf_set_pcb(elf_info_t , pcb_t );
49	49

uspace/lib/c/include/elf/elf_mod.h

-              r39f892a9
+              r368ee04
 extern const char *elf_error(unsigned int);
+extern int elf_load_file(const char *, size_t, eld_flags_t, elf_finfo_t *);
+extern int elf_load_file(int, size_t, eld_flags_t, elf_finfo_t *);
+extern int elf_load_file_name(const char *, size_t, eld_flags_t, elf_finfo_t *);
 #endif

uspace/lib/c/include/io/logctl.h

r39f892a9	r368ee04
38	38	extern int logctl_set_default_level(log_level_t);
39	39	extern int logctl_set_log_level(const char *, log_level_t);
	40	extern int logctl_set_root(void);
40	41
41	42	#endif

uspace/lib/c/include/ipc/loader.h

-              r39f892a9
+              r368ee04
         LOADER_GET_TASKID,
         LOADER_SET_CWD,
         LOADER_SET_PATHNAME,
+        LOADER_SET_PROGRAM,
         LOADER_SET_ARGS,
         LOADER_SET_FILES,
+        LOADER_ADD_INBOX,
         LOADER_LOAD,
         LOADER_RUN

uspace/lib/c/include/ipc/logger.h

-              r39f892a9
+              r368ee04
          * Followed by: string with full log name.
          */
+        LOGGER_CONTROL_SET_LOG_LEVEL
+        LOGGER_CONTROL_SET_LOG_LEVEL,
+        /** Set VFS root.
+         *
+         * Returns: error code
+         * Followed by: vfs_pass_handle() request.
+         */
+        LOGGER_CONTROL_SET_ROOT
 } logger_control_request_t;

uspace/lib/c/include/ipc/vfs.h

-              r39f892a9
+              r368ee04
 #define FS_NAME_MAXLEN  20
 #define MAX_PATH_LEN    (64 * 1024)
+#define MAX_PATH_LEN    (32 * 1024)
 #define MAX_MNTOPTS_LEN 256
 #define PLB_SIZE        (2 * MAX_PATH_LEN)
 …
 typedef enum {
+        VFS_IN_OPEN = IPC_FIRST_USER_METHOD,
+        VFS_IN_CLONE = IPC_FIRST_USER_METHOD,
+        VFS_IN_MOUNT,
+        VFS_IN_OPEN,
+        VFS_IN_PUT,
         VFS_IN_READ,
+        VFS_IN_REGISTER,
+        VFS_IN_RENAME,
+        VFS_IN_RESIZE,
+        VFS_IN_STAT,
+        VFS_IN_STATFS,
+        VFS_IN_SYNC,
+        VFS_IN_UNLINK,
+        VFS_IN_UNMOUNT,
+        VFS_IN_WAIT_HANDLE,
+        VFS_IN_WALK,
         VFS_IN_WRITE,
-        VFS_IN_SEEK,
-        VFS_IN_TRUNCATE,
-        VFS_IN_FSTAT,
-        VFS_IN_CLOSE,
-        VFS_IN_PING,
-        VFS_IN_MOUNT,
-        VFS_IN_UNMOUNT,
-        VFS_IN_SYNC,
-        VFS_IN_REGISTER,
-        VFS_IN_MKDIR,
-        VFS_IN_UNLINK,
-        VFS_IN_RENAME,
-        VFS_IN_STAT,
-        VFS_IN_DUP,
-        VFS_IN_WAIT_HANDLE,
-        VFS_IN_MTAB_GET,
-        VFS_IN_STATFS
 } vfs_in_request_t;
 typedef enum {
+        VFS_OUT_OPEN_NODE = IPC_FIRST_USER_METHOD,
+        VFS_OUT_CLOSE = IPC_FIRST_USER_METHOD,
+        VFS_OUT_DESTROY,
+        VFS_OUT_IS_EMPTY,
+        VFS_OUT_LINK,
+        VFS_OUT_LOOKUP,
+        VFS_OUT_MOUNTED,
+        VFS_OUT_OPEN_NODE,
         VFS_OUT_READ,
+        VFS_OUT_STAT,
+        VFS_OUT_STATFS,
+        VFS_OUT_SYNC,
+        VFS_OUT_TRUNCATE,
+        VFS_OUT_UNMOUNTED,
         VFS_OUT_WRITE,
-        VFS_OUT_TRUNCATE,
-        VFS_OUT_CLOSE,
-        VFS_OUT_MOUNT,
-        VFS_OUT_MOUNTED,
-        VFS_OUT_UNMOUNT,
-        VFS_OUT_UNMOUNTED,
-        VFS_OUT_SYNC,
-        VFS_OUT_STAT,
-        VFS_OUT_LOOKUP,
-        VFS_OUT_DESTROY,
-        VFS_OUT_STATFS,
         VFS_OUT_LAST
 } vfs_out_request_t;
 …
 /**
  * Lookup will succeed only if the object is a root directory. The flag is
  * mutually exclusive with L_FILE and L_MP.
+ * Lookup will not cross any mount points.
+ * If the lookup would have to cross a mount point, it returns EXDEV instead.
  */
 #define L_ROOT                  4
+#define L_DISABLE_MOUNTS        4
 /**
  * Lookup will succeed only if the object is a mount point. The flag is mutually
  * exclusive with L_FILE and L_ROOT.
+ * exclusive with L_FILE.
  */
 #define L_MP                    8
 …
 /**
- * L_LINK is used for linking to an already existing nodes.
- */
-#define L_LINK                  64
-/**
  * L_UNLINK is used to remove leaves from the file system namespace. This flag
  * cannot be passed directly by the client, but will be set by VFS during
  * VFS_UNLINK.
  */
 #define L_UNLINK                128
+#define L_UNLINK                64
+/**
+ * L_OPEN is used to indicate that the lookup operation is a part of VFS_IN_OPEN
+ * call from the client. This means that the server might allocate some
+ * resources for the opened file. This flag cannot be passed directly by the
+ * client.
+/*
+ * Walk flags.
  */
+#define L_OPEN                  256
+enum {
+        WALK_MAY_CREATE = (1 << 0),
+        WALK_MUST_CREATE = (1 << 1),
+        WALK_REGULAR = (1 << 2),
+        WALK_DIRECTORY = (1 << 3),
+        WALK_MOUNT_POINT = (1 << 4),
+        WALK_ALL_FLAGS = WALK_MAY_CREATE | WALK_MUST_CREATE | WALK_REGULAR |
+            WALK_DIRECTORY | WALK_MOUNT_POINT,
+};
+enum {
+        VFS_MOUNT_BLOCKING = 1,
+        VFS_MOUNT_CONNECT_ONLY = 2,
+        VFS_MOUNT_NO_REF = 4,
+};
+enum {
+        MODE_READ = 1,
+        MODE_WRITE = 2,
+        MODE_APPEND = 4,
+};
 #endif

uspace/lib/c/include/loader/loader.h

-              r39f892a9
+              r368ee04
 extern int loader_get_task_id(loader_t *, task_id_t *);
 extern int loader_set_cwd(loader_t *);
+extern int loader_set_pathname(loader_t *, const char *);
+extern int loader_set_program(loader_t *, const char *, int);
+extern int loader_set_program_path(loader_t *, const char *);
 extern int loader_set_args(loader_t *, const char *const[]);
 extern int loader_set_files(loader_t *, int *const[]);
+extern int loader_add_inbox(loader_t *, const char *, int);
 extern int loader_load_program(loader_t *);
 extern int loader_run(loader_t *);

uspace/lib/c/include/loader/pcb.h

-              r39f892a9
+              r368ee04
 typedef void (*entry_point_t)(void);
+struct pcb_inbox_entry {
+        char *name;
+        int file;
+};
 /** Program Control Block.
+ *
 …
         char **argv;
+        /** Number of preset files. */
+        unsigned int filc;
+        /** List of inbox files. */
+        struct pcb_inbox_entry *inbox;
+        int inbox_entries;
         /*

uspace/lib/c/include/stdio.h

-              r39f892a9
+              r368ee04
 #define EOF  (-1)
-/** Default size for stream I/O buffers */
-#define BUFSIZ  4096
-#define DEBUG(fmt, ...) \
-        { \
-                char _buf[256]; \
-                int _n = snprintf(_buf, sizeof(_buf), fmt, ##__VA_ARGS__); \
-                if (_n > 0) \
-                        (void) __SYSCALL3(SYS_KIO, KIO_WRITE, (sysarg_t) _buf, str_size(_buf)); \
+        }
 #ifndef SEEK_SET
         #define SEEK_SET  0
 …
         #define SEEK_END  2
 #endif
+/** Default size for stream I/O buffers */
+#define BUFSIZ  4096
+#define DEBUG(fmt, ...) \
+        { \
+                char _buf[256]; \
+                int _n = snprintf(_buf, sizeof(_buf), fmt, ##__VA_ARGS__); \
+                if (_n > 0) \
+                        (void) __SYSCALL3(SYS_KIO, KIO_WRITE, (sysarg_t) _buf, str_size(_buf)); \
+        }
 enum _buffer_type {
 …
 extern void setbuf(FILE *, void *);
-/* Misc file functions */
-extern int rename(const char *, const char *);
-extern int remove(const char *);
 #endif

uspace/lib/c/include/stdlib.h

r39f892a9	r368ee04
49	49
50	50	extern void abort(void) __attribute__((noreturn));
	51	extern void exit(int) __attribute__((noreturn));
51	52
52	53	#endif

uspace/lib/c/include/sys/types.h

r39f892a9	r368ee04
38	38	#include <libarch/types.h>
39	39
40		~~typedef unsigned int mode_t;~~
41
42	40	/** Relative offset */
43	41	typedef int64_t off64_t;

uspace/lib/c/include/task.h

r39f892a9	r368ee04
57	57	const char *const []);
58	58	extern int task_spawnvf(task_id_t , task_wait_t , const char *path,
59		const char const [], int const []);
	59	const char *const [], int, int, int);
60	60	extern int task_spawn(task_id_t , task_wait_t , const char *path, int,
61	61	va_list ap);

uspace/lib/c/include/unistd.h

-              r39f892a9
+              r368ee04
 #endif
-#ifndef SEEK_SET
-        #define SEEK_SET  0
-#endif
-#ifndef SEEK_CUR
-        #define SEEK_CUR  1
-#endif
-#ifndef SEEK_END
-        #define SEEK_END  2
-#endif
 #define getpagesize()  (PAGE_SIZE)
-extern int dup2(int, int);
-extern ssize_t write(int, const void *, size_t);
-extern ssize_t read(int, void *, size_t);
-extern off64_t lseek(int, off64_t, int);
-extern int ftruncate(int, aoff64_t);
-extern int close(int);
-extern int fsync(int);
-extern int unlink(const char *);
-extern char *getcwd(char *, size_t);
-extern int rmdir(const char *);
-extern int chdir(const char *);
-extern void exit(int) __attribute__((noreturn));
 extern int usleep(useconds_t);
 extern unsigned int sleep(unsigned int);

uspace/lib/c/include/vfs/inbox.h

-              r39f892a9
+              r368ee04
 /*
  * Copyright (c) 2007 Jakub Jermar
+ * Copyright (c) 2013 Jiri Zarevucky
  * All rights reserved.
+ *
 …
  */
 /** @addtogroup libc
+/** @addtogroup libc
  * @{
+ */
+/** @file
+ */
+/**
+ * @file
+ * @brief
  */
 #ifndef LIBC_FCNTL_H_
 #define LIBC_FCNTL_H_
+#ifndef LIBC_VFS_INBOX_H_
+#define LIBC_VFS_INBOX_H_
+#define O_CREAT   1
+#define O_EXCL    2
+#define O_TRUNC   4
+#define O_APPEND  8
+#define O_RDONLY  16
+#define O_RDWR    32
+#define O_WRONLY  64
+#define O_DESC    128
+enum {
+        INBOX_MAX_ENTRIES = 256,
+};
+extern int open(const char *, int, ...);
+extern int inbox_set(const char *name, int file);
+extern int inbox_get(const char *name);
+extern int inbox_list(const char **names, int capacity);
 #endif
+/** @}
+/**
+ * @}
  */

uspace/lib/c/include/vfs/vfs.h

-              r39f892a9
+              r368ee04
 #include <stdio.h>
 #include <async.h>
-#include "vfs_mtab.h"
+#define MAX_OPEN_FILES  128
 enum vfs_change_state_type {
 …
 };
+typedef enum {
+        KIND_FILE,
+        KIND_DIRECTORY,
+} vfs_file_kind_t;
-extern char *vfs_absolutize(const char *, size_t *);
+extern int vfs_mount(const char *, const char *, const char *, const char *,
+    unsigned int, unsigned int);
+extern int vfs_unmount(const char *);
+struct stat {
+        fs_handle_t fs_handle;
+        service_id_t service_id;
+        fs_index_t index;
+        unsigned int lnkcnt;
+        bool is_file;
+        bool is_directory;
+        aoff64_t size;
+        service_id_t service;
+};
+struct statfs {
+        char fs_name[FS_NAME_MAXLEN + 1];
+        uint32_t f_bsize;    /* fundamental file system block size */
+        uint64_t f_blocks;   /* total data blocks in file system */
+        uint64_t f_bfree;    /* free blocks in fs */
+};
 extern int vfs_fhandle(FILE *, int *);
+extern int vfs_fd_wait(void);
+extern int vfs_get_mtab_list(list_t *mtab_list);
+extern char *vfs_absolutize(const char *, size_t *);
+extern int vfs_clone(int, int, bool);
+extern int vfs_cwd_get(char *path, size_t);
+extern int vfs_cwd_set(const char *path);
 extern async_exch_t *vfs_exchange_begin(void);
 extern void vfs_exchange_end(async_exch_t *);
+extern int vfs_link(int, const char *, vfs_file_kind_t, int *);
+extern int vfs_link_path(const char *, vfs_file_kind_t, int *);
+extern int vfs_lookup(const char *, int);
+extern int vfs_lookup_open(const char *, int, int);
+extern int vfs_mount_path(const char *, const char *, const char *,
+    const char *, unsigned int, unsigned int);
+extern int vfs_mount(int, const char *, service_id_t, const char *, unsigned,
+    unsigned, int *);
+extern int vfs_open(int, int);
+extern int vfs_pass_handle(async_exch_t *, int, async_exch_t *);
+extern int vfs_put(int);
+extern ssize_t vfs_read(int, aoff64_t *, void *, size_t);
+extern int vfs_read_short(int, aoff64_t, void *, size_t, ssize_t *);
+extern int vfs_receive_handle(bool);
+extern int vfs_rename_path(const char *, const char *);
+extern int vfs_resize(int, aoff64_t);
+extern int vfs_root(void);
+extern void vfs_root_set(int);
+extern int vfs_stat(int, struct stat *);
+extern int vfs_stat_path(const char *, struct stat *);
+extern int vfs_statfs(int, struct statfs *);
+extern int vfs_statfs_path(const char *, struct statfs *);
+extern int vfs_sync(int);
+extern int vfs_unlink(int, const char *, int);
+extern int vfs_unlink_path(const char *);
+extern int vfs_unmount(int);
+extern int vfs_unmount_path(const char *);
+extern int vfs_walk(int, const char *, int);
+extern ssize_t vfs_write(int, aoff64_t *, const void *, size_t);
+extern int vfs_write_short(int, aoff64_t, const void *, size_t, ssize_t *);
 #endif

uspace/lib/c/include/vfs/vfs_mtab.h

-              r39f892a9
+              r368ee04
         link_t link;
         char mp[MAX_PATH_LEN];
-        char opts[MAX_MNTOPTS_LEN];
         char fs_name[FS_NAME_MAXLEN];
-        unsigned int instance;
         service_id_t service_id;
 } mtab_ent_t;
+extern int vfs_get_mtab_list(list_t *);
 #endif

uspace/lib/fs/libfs.c

-              r39f892a9
+              r368ee04
 #include "libfs.h"
-#include "../../srv/vfs/vfs.h"
 #include <macros.h>
 #include <errno.h>
 …
 #include <dirent.h>
 #include <mem.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+#include <str.h>
 #include <stdlib.h>
+#include <fibril_synch.h>
+#include <ipc/vfs.h>
+#include <vfs/vfs.h>
 #define on_error(rc, action) \
 …
 static libfs_ops_t *libfs_ops = NULL;
+static void libfs_mount(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
+static void libfs_unmount(libfs_ops_t *, ipc_callid_t, ipc_call_t *);
+static char fs_name[FS_NAME_MAXLEN + 1];
+static void libfs_link(libfs_ops_t *, fs_handle_t, ipc_callid_t,
+    ipc_call_t *);
 static void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t,
     ipc_call_t *);
 …
 static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
     ipc_call_t *);
+static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
+static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t,
+    ipc_call_t *);
 static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
 …
+}
-static void vfs_out_mount(ipc_callid_t rid, ipc_call_t *req)
+{
-        libfs_mount(libfs_ops, reg.fs_handle, rid, req);
+}
 static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req)
+{
 …
+}
+static void vfs_out_unmount(ipc_callid_t rid, ipc_call_t *req)
+{
+        libfs_unmount(libfs_ops, rid, req);
+static void vfs_out_link(ipc_callid_t rid, ipc_call_t *req)
+{
+        libfs_link(libfs_ops, reg.fs_handle, rid, req);
+}
 …
         rc = vfs_out_ops->write(service_id, index, pos, &wbytes, &nsize);
+        if (rc == EOK)
+                async_answer_3(rid, EOK, wbytes, LOWER32(nsize), UPPER32(nsize));
+        else
+        if (rc == EOK) {
+                async_answer_3(rid, EOK, wbytes, LOWER32(nsize),
+                    UPPER32(nsize));
+        } else
                 async_answer_0(rid, rc);
+}
 …
         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
         int rc;
+        rc = vfs_out_ops->destroy(service_id, index);
+        fs_node_t *node = NULL;
+        rc = libfs_ops->node_get(&node, service_id, index);
+        if (rc == EOK && node != NULL) {
+                bool destroy = (libfs_ops->lnkcnt_get(node) == 0);
+                libfs_ops->node_put(node);
+                if (destroy)
+                        rc = vfs_out_ops->destroy(service_id, index);
+        }
         async_answer_0(rid, rc);
+}
 …
         libfs_statfs(libfs_ops, reg.fs_handle, rid, req);
+}
+static void vfs_out_is_empty(ipc_callid_t rid, ipc_call_t *req)
+{
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
+        int rc;
+        fs_node_t *node = NULL;
+        rc = libfs_ops->node_get(&node, service_id, index);
+        if (rc != EOK)
+                async_answer_0(rid, rc);
+        if (node == NULL)
+                async_answer_0(rid, EINVAL);
+        bool children = false;
+        rc = libfs_ops->has_children(&children, node);
+        libfs_ops->node_put(node);
+        if (rc != EOK)
+                async_answer_0(rid, rc);
+        async_answer_0(rid, children ? ENOTEMPTY : EOK);
+}
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
 …
                         vfs_out_mounted(callid, &call);
                         break;
-                case VFS_OUT_MOUNT:
-                        vfs_out_mount(callid, &call);
-                        break;
                 case VFS_OUT_UNMOUNTED:
                         vfs_out_unmounted(callid, &call);
                         break;
                 case VFS_OUT_UNMOUNT:
                         vfs_out_unmount(callid, &call);
+                case VFS_OUT_LINK:
+                        vfs_out_link(callid, &call);
                         break;
                 case VFS_OUT_LOOKUP:
 …
                 case VFS_OUT_STATFS:
                         vfs_out_statfs(callid, &call);
+                        break;
+                case VFS_OUT_IS_EMPTY:
+                        vfs_out_is_empty(callid, &call);
                         break;
                 default:
 …
         vfs_out_ops = vops;
         libfs_ops = lops;
+        str_cpy(fs_name, sizeof(fs_name), info->name);
         /*
 …
+}
+void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
+static char plb_get_char(unsigned pos)
+{
+        return reg.plb_ro[pos % PLB_SIZE];
+}
+static int plb_get_component(char *dest, unsigned *sz, unsigned *ppos,
+    unsigned last)
+{
+        unsigned pos = *ppos;
+        unsigned size = 0;
+        if (pos == last) {
+                *sz = 0;
+                return ERANGE;
+        }
+        char c = plb_get_char(pos);
+        if (c == '/')
+                pos++;
+        for (int i = 0; i <= NAME_MAX; i++) {
+                c = plb_get_char(pos);
+                if (pos == last || c == '/') {
+                        dest[i] = 0;
+                        *ppos = pos;
+                        *sz = size;
+                        return EOK;
+                }
+                dest[i] = c;
+                pos++;
+                size++;
+        }
+        return ENAMETOOLONG;
+}
+static int receive_fname(char *buffer)
+{
+        size_t size;
+        ipc_callid_t wcall;
+        if (!async_data_write_receive(&wcall, &size))
+                return ENOENT;
+        if (size > NAME_MAX + 1) {
+                async_answer_0(wcall, ERANGE);
+                return ERANGE;
+        }
+        return async_data_write_finalize(wcall, buffer, size);
+}
+/** Link a file at a path.
+ */
+void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
     ipc_call_t *req)
+{
         service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req);
         fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*req);
         service_id_t mr_service_id = (service_id_t) IPC_GET_ARG4(*req);
         async_sess_t *mountee_sess = async_clone_receive(EXCHANGE_PARALLEL);
         if (mountee_sess == NULL) {
                 async_answer_0(rid, EINVAL);
+        service_id_t parent_sid = IPC_GET_ARG1(*req);
+        fs_index_t parent_index = IPC_GET_ARG2(*req);
+        fs_index_t child_index = IPC_GET_ARG3(*req);
+        char component[NAME_MAX + 1];
+        int rc = receive_fname(component);
+        if (rc != EOK) {
+                async_answer_0(rid, rc);
                 return;
+        }
+        fs_node_t *fn;
+        int res = ops->node_get(&fn, mp_service_id, mp_fs_index);
+        if ((res != EOK) || (!fn)) {
+                async_hangup(mountee_sess);
+                async_data_write_void(combine_rc(res, ENOENT));
+                async_answer_0(rid, combine_rc(res, ENOENT));
+        fs_node_t *parent = NULL;
+        rc = ops->node_get(&parent, parent_sid, parent_index);
+        if (parent == NULL) {
+                async_answer_0(rid, rc == EOK ? EBADF : rc);
                 return;
+        }
         if (fn->mp_data.mp_active) {
                 async_hangup(mountee_sess);
                 (void) ops->node_put(fn);
                 async_data_write_void(EBUSY);
                 async_answer_0(rid, EBUSY);
+        fs_node_t *child = NULL;
+        rc = ops->node_get(&child, parent_sid, child_index);
+        if (child == NULL) {
+                async_answer_0(rid, rc == EOK ? EBADF : rc);
+                ops->node_put(parent);
                 return;
+        }
+        async_exch_t *exch = async_exchange_begin(mountee_sess);
+        async_sess_t *sess = async_clone_establish(EXCHANGE_PARALLEL, exch);
+        if (!sess) {
+                async_exchange_end(exch);
+                async_hangup(mountee_sess);
+                (void) ops->node_put(fn);
+                async_data_write_void(errno);
+                async_answer_0(rid, errno);
+                return;
+        }
+        ipc_call_t answer;
+        int rc = async_data_write_forward_1_1(exch, VFS_OUT_MOUNTED,
+            mr_service_id, &answer);
+        async_exchange_end(exch);
+        if (rc == EOK) {
+                fn->mp_data.mp_active = true;
+                fn->mp_data.fs_handle = mr_fs_handle;
+                fn->mp_data.service_id = mr_service_id;
+                fn->mp_data.sess = mountee_sess;
+        }
+        /*
+         * Do not release the FS node so that it stays in memory.
+         */
+        async_answer_4(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
+            IPC_GET_ARG3(answer), IPC_GET_ARG4(answer));
+}
+void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *req)
+{
+        service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req);
+        fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req);
+        fs_node_t *fn;
+        int res;
+        res = ops->node_get(&fn, mp_service_id, mp_fs_index);
+        if ((res != EOK) || (!fn)) {
+                async_answer_0(rid, combine_rc(res, ENOENT));
+                return;
+        }
+        /*
+         * We are clearly expecting to find the mount point active.
+         */
+        if (!fn->mp_data.mp_active) {
+                (void) ops->node_put(fn);
+                async_answer_0(rid, EINVAL);
+                return;
+        }
+        /*
+         * Tell the mounted file system to unmount.
+         */
+        async_exch_t *exch = async_exchange_begin(fn->mp_data.sess);
+        res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.service_id);
+        async_exchange_end(exch);
+        /*
+         * If everything went well, perform the clean-up on our side.
+         */
+        if (res == EOK) {
+                async_hangup(fn->mp_data.sess);
+                fn->mp_data.mp_active = false;
+                fn->mp_data.fs_handle = 0;
+                fn->mp_data.service_id = 0;
+                fn->mp_data.sess = NULL;
+                /* Drop the reference created in libfs_mount(). */
+                (void) ops->node_put(fn);
+        }
+        (void) ops->node_put(fn);
+        async_answer_0(rid, res);
+}
+static char plb_get_char(unsigned pos)
+{
+        return reg.plb_ro[pos % PLB_SIZE];
+        rc = ops->link(parent, child, component);
+        ops->node_put(parent);
+        ops->node_put(child);
+        async_answer_0(rid, rc);
+}
 …
     ipc_call_t *req)
+{
+        unsigned int first = IPC_GET_ARG1(*req);
+        unsigned int last = IPC_GET_ARG2(*req);
+        unsigned int next = first;
+        unsigned first = IPC_GET_ARG1(*req);
+        unsigned len = IPC_GET_ARG2(*req);
         service_id_t service_id = IPC_GET_ARG3(*req);
+        int lflag = IPC_GET_ARG4(*req);
+        fs_index_t index = IPC_GET_ARG5(*req);
+        fs_index_t index = IPC_GET_ARG4(*req);
+        int lflag = IPC_GET_ARG5(*req);
+        // TODO: Validate flags.
+        unsigned next = first;
+        unsigned last = first + len;
         char component[NAME_MAX + 1];
-        int len;
         int rc;
-        if (last < next)
-                last += PLB_SIZE;
         fs_node_t *par = NULL;
         fs_node_t *cur = NULL;
         fs_node_t *tmp = NULL;
+        rc = ops->root_get(&cur, service_id);
+        on_error(rc, goto out_with_answer);
+        if (cur->mp_data.mp_active) {
+                async_exch_t *exch = async_exchange_begin(cur->mp_data.sess);
+                async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last,
+                    cur->mp_data.service_id, lflag, index,
+                    IPC_FF_ROUTE_FROM_ME);
+                async_exchange_end(exch);
+        unsigned clen = 0;
+        rc = ops->node_get(&cur, service_id, index);
+        if (rc != EOK) {
+                async_answer_0(rid, rc);
+                goto out;
+        }
+        assert(cur != NULL);
+        /* Find the file and its parent. */
+        unsigned last_next = 0;
+        while (next != last) {
+                if (cur == NULL) {
+                        assert(par != NULL);
+                        goto out1;
+                }
+                if (!ops->is_directory(cur)) {
+                        async_answer_0(rid, ENOTDIR);
+                        goto out;
+                }
+                (void) ops->node_put(cur);
+                return;
+        }
+        /* Eat slash */
+        if (plb_get_char(next) == '/')
+                next++;
+        while (next <= last) {
+                bool has_children;
+                last_next = next;
+                /* Collect the component */
+                rc = plb_get_component(component, &clen, &next, last);
+                assert(rc != ERANGE);
+                if (rc != EOK) {
+                        async_answer_0(rid, rc);
+                        goto out;
+                }
                 rc = ops->has_children(&has_children, cur);
                 on_error(rc, goto out_with_answer);
                 if (!has_children)
                         break;
+                if (clen == 0) {
+                        /* The path is just "/". */
+                        break;
+                }
+                /* Collect the component */
+                len = 0;
+                while ((next <= last) && (plb_get_char(next) != '/')) {
+                        if (len + 1 == NAME_MAX) {
+                                /* Component length overflow */
+                                async_answer_0(rid, ENAMETOOLONG);
+                                goto out;
+                        }
+                        component[len++] = plb_get_char(next);
+                        /* Process next character */
+                        next++;
+                }
+                assert(len);
+                component[len] = '\0';
+                /* Eat slash */
+                next++;
+                assert(component[clen] == 0);
                 /* Match the component */
                 rc = ops->match(&tmp, cur, component);
+                on_error(rc, goto out_with_answer);
+                if (rc != EOK) {
+                        async_answer_0(rid, rc);
+                        goto out;
+                }
+                /*
+                 * If the matching component is a mount point, there are two
+                 * legitimate semantics of the lookup operation. The first is
+                 * the commonly used one in which the lookup crosses each mount
+                 * point into the mounted file system. The second semantics is
+                 * used mostly during unmount() and differs from the first one
+                 * only in that the last mount point in the looked up path,
+                 * which is also its last component, is not crossed.
+                 */
+                if ((tmp) && (tmp->mp_data.mp_active) &&
+                    (!(lflag & L_MP) || (next <= last))) {
+                        if (next > last)
+                                next = last = first;
+                        else
+                                next--;
+                        async_exch_t *exch = async_exchange_begin(tmp->mp_data.sess);
+                        async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next,
+                            last, tmp->mp_data.service_id, lflag, index,
+                            IPC_FF_ROUTE_FROM_ME);
+                        async_exchange_end(exch);
+                        (void) ops->node_put(cur);
+                        (void) ops->node_put(tmp);
+                        if (par)
+                                (void) ops->node_put(par);
+                        return;
+                /* Descend one level */
+                if (par) {
+                        rc = ops->node_put(par);
+                        if (rc != EOK) {
+                                async_answer_0(rid, rc);
+                                goto out;
+                        }
+                }
+                /* Handle miss: match amongst siblings */
+                if (!tmp) {
+                        if (next <= last) {
+                                /* There are unprocessed components */
+                                async_answer_0(rid, ENOENT);
+                par = cur;
+                cur = tmp;
+                tmp = NULL;
+        }
+        /* At this point, par is either NULL or a directory.
+         * If cur is NULL, the looked up file does not exist yet.
+         */
+        assert(par == NULL || ops->is_directory(par));
+        assert(par != NULL || cur != NULL);
+        /* Check for some error conditions. */
+        if (cur && (lflag & L_FILE) && (ops->is_directory(cur))) {
+                async_answer_0(rid, EISDIR);
+                goto out;
+        }
+        if (cur && (lflag & L_DIRECTORY) && (ops->is_file(cur))) {
+                async_answer_0(rid, ENOTDIR);
+                goto out;
+        }
+        /* Unlink. */
+        if (lflag & L_UNLINK) {
+                if (!cur) {
+                        async_answer_0(rid, ENOENT);
+                        goto out;
+                }
+                if (!par) {
+                        async_answer_0(rid, EINVAL);
+                        goto out;
+                }
+                rc = ops->unlink(par, cur, component);
+                if (rc == EOK) {
+                        aoff64_t size = ops->size_get(cur);
+                        async_answer_5(rid, fs_handle, service_id,
+                            ops->index_get(cur),
+                            (ops->is_directory(cur) << 16) | last,
+                            LOWER32(size), UPPER32(size));
+                } else {
+                        async_answer_0(rid, rc);
+                }
+                goto out;
+        }
+        /* Create. */
+        if (lflag & L_CREATE) {
+                if (cur && (lflag & L_EXCLUSIVE)) {
+                        async_answer_0(rid, EEXIST);
+                        goto out;
+                }
+                if (!cur) {
+                        rc = ops->create(&cur, service_id,
+                            lflag & (L_FILE | L_DIRECTORY));
+                        if (rc != EOK) {
+                                async_answer_0(rid, rc);
+                                goto out;
+                        }
+                        if (!cur) {
+                                async_answer_0(rid, ENOSPC);
                                 goto out;
+                        }
+                        /* Miss in the last component */
+                        if (lflag & (L_CREATE | L_LINK)) {
+                                /* Request to create a new link */
+                                if (!ops->is_directory(cur)) {
+                                        async_answer_0(rid, ENOTDIR);
+                                        goto out;
+                                }
+                                fs_node_t *fn;
+                                if (lflag & L_CREATE)
+                                        rc = ops->create(&fn, service_id,
+                                            lflag);
+                                else
+                                        rc = ops->node_get(&fn, service_id,
+                                            index);
+                                on_error(rc, goto out_with_answer);
+                                if (fn) {
+                                        rc = ops->link(cur, fn, component);
+                                        if (rc != EOK) {
+                                                if (lflag & L_CREATE)
+                                                        (void) ops->destroy(fn);
+                                                else
+                                                        (void) ops->node_put(fn);
+                                                async_answer_0(rid, rc);
+                                        } else {
+                                                (void) ops->node_put(cur);
+                                                cur = fn;
+                                                goto out_with_answer;
+                                        }
+                                } else
+                                        async_answer_0(rid, ENOSPC);
+                        rc = ops->link(par, cur, component);
+                        if (rc != EOK) {
+                                (void) ops->destroy(cur);
+                                cur = NULL;
+                                async_answer_0(rid, rc);
                                 goto out;
+                        }
+                        async_answer_0(rid, ENOENT);
+                        goto out;
+                }
+                if (par) {
+                        rc = ops->node_put(par);
+                        on_error(rc, goto out_with_answer);
+                }
+                /* Descend one level */
+                par = cur;
+                cur = tmp;
+                tmp = NULL;
+        }
+        /* Handle miss: excessive components */
+        if (next <= last) {
+                bool has_children;
+                rc = ops->has_children(&has_children, cur);
+                on_error(rc, goto out_with_answer);
+                if (has_children)
+                        goto skip_miss;
+                if (lflag & (L_CREATE | L_LINK)) {
+                        if (!ops->is_directory(cur)) {
+                                async_answer_0(rid, ENOTDIR);
+                                goto out;
+                        }
+                        /* Collect next component */
+                        len = 0;
+                        while (next <= last) {
+                                if (plb_get_char(next) == '/') {
+                                        /* More than one component */
+                                        async_answer_0(rid, ENOENT);
+                                        goto out;
+                                }
+                                if (len + 1 == NAME_MAX) {
+                                        /* Component length overflow */
+                                        async_answer_0(rid, ENAMETOOLONG);
+                                        goto out;
+                                }
+                                component[len++] = plb_get_char(next);
+                                /* Process next character */
+                                next++;
+                        }
+                        assert(len);
+                        component[len] = '\0';
+                        fs_node_t *fn;
+                        if (lflag & L_CREATE)
+                                rc = ops->create(&fn, service_id, lflag);
+                        else
+                                rc = ops->node_get(&fn, service_id, index);
+                        on_error(rc, goto out_with_answer);
+                        if (fn) {
+                                rc = ops->link(cur, fn, component);
+                                if (rc != EOK) {
+                                        if (lflag & L_CREATE)
+                                                (void) ops->destroy(fn);
+                                        else
+                                                (void) ops->node_put(fn);
+                                        async_answer_0(rid, rc);
+                                } else {
+                                        (void) ops->node_put(cur);
+                                        cur = fn;
+                                        goto out_with_answer;
+                                }
+                        } else
+                                async_answer_0(rid, ENOSPC);
+                        goto out;
+                }
+                async_answer_0(rid, ENOENT);
+                }
+        }
+        /* Return. */
+out1:
+        if (!cur) {
+                async_answer_5(rid, fs_handle, service_id, ops->index_get(par),
+                    last_next, -1, true);
                 goto out;
+        }
+skip_miss:
+        /* Handle hit */
+        if (lflag & L_UNLINK) {
+                unsigned int old_lnkcnt = ops->lnkcnt_get(cur);
+                rc = ops->unlink(par, cur, component);
+                if (rc == EOK) {
+                        aoff64_t size = ops->size_get(cur);
+                        async_answer_5(rid, fs_handle, service_id,
+                            ops->index_get(cur), LOWER32(size), UPPER32(size),
+                            old_lnkcnt);
+                } else
+                        async_answer_0(rid, rc);
+                goto out;
+        }
+        if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
+            (lflag & L_LINK)) {
+                async_answer_0(rid, EEXIST);
+                goto out;
+        }
+        if ((lflag & L_FILE) && (ops->is_directory(cur))) {
+                async_answer_0(rid, EISDIR);
+                goto out;
+        }
+        if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
+                async_answer_0(rid, ENOTDIR);
+                goto out;
+        }
+        if ((lflag & L_ROOT) && par) {
+                async_answer_0(rid, EINVAL);
+                goto out;
+        }
+out_with_answer:
+        if (rc == EOK) {
+                if (lflag & L_OPEN)
+                        rc = ops->node_open(cur);
+                if (rc == EOK) {
+                        aoff64_t size = ops->size_get(cur);
+                        async_answer_5(rid, fs_handle, service_id,
+                            ops->index_get(cur), LOWER32(size), UPPER32(size),
+                            ops->lnkcnt_get(cur));
+                } else
+                        async_answer_0(rid, rc);
+        } else
+                async_answer_0(rid, rc);
+        aoff64_t size = ops->size_get(cur);
+        async_answer_5(rid, fs_handle, service_id, ops->index_get(cur),
+            (ops->is_directory(cur) << 16) | last, LOWER32(size),
+            UPPER32(size));
 out:
         if (par)
                 (void) ops->node_put(par);
 …
         memset(&st, 0, sizeof(struct statfs));
+        str_cpy(st.fs_name, sizeof(st.fs_name), fs_name);
         if (ops->size_block != NULL) {
                 rc = ops->size_block(service_id, &st.f_bsize);
 …
         async_answer_4(rid, rc, LOWER32(size), UPPER32(size),
             ops->lnkcnt_get(fn),
+            (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0));
+            (ops->is_file(fn) ? L_FILE : 0) |
+            (ops->is_directory(fn) ? L_DIRECTORY : 0));
         (void) ops->node_put(fn);

uspace/lib/fs/libfs.h

-              r39f892a9
+              r368ee04
 typedef struct {
-        bool mp_active;
-        async_sess_t *sess;
-        fs_handle_t fs_handle;
-        service_id_t service_id;
-} mp_data_t;
-typedef struct {
-        mp_data_t mp_data;  /**< Mount point info. */
         void *data;         /**< Data of the file system implementation. */
 } fs_node_t;

uspace/lib/gui/window.c

r39f892a9	r368ee04
37	37	#include <errno.h>
38	38	#include <stdio.h>
	39	#include <stdlib.h>
39	40
40	41	#include <as.h>

uspace/lib/pcut/src/os/generic.c

r39f892a9	r368ee04
137	137	fread(extra_output_buffer, 1, OUTPUT_BUFFER_SIZE, tempfile);
138	138	fclose(tempfile);
139		~~remove~~(tempfile_name);
	139	unlink(tempfile_name);
140	140
141	141	pcut_report_test_done_unparsed(test, rc, extra_output_buffer, OUTPUT_BUFFER_SIZE);

uspace/lib/pcut/src/os/helenos.c

-              r39f892a9
+              r368ee04
 #include <stdio.h>
 #include <task.h>
-#include <fcntl.h>
 #include <fibril_synch.h>
+#include <vfs/vfs.h>
 #include "../internal.h"
 …
         char tempfile_name[PCUT_TEMP_FILENAME_BUFFER_SIZE];
         snprintf(tempfile_name, PCUT_TEMP_FILENAME_BUFFER_SIZE - 1, "pcut_%lld.tmp", (unsigned long long) task_get_id());
         int tempfile = open(tempfile_name, O_CREAT | O_RDWR);
+        int tempfile = vfs_lookup_open(tempfile_name, WALK_REGULAR | WALK_MAY_CREATE, MODE_READ | MODE_WRITE);
         if (tempfile < 0) {
                 pcut_report_test_done(test, TEST_OUTCOME_ERROR, "Failed to create temporary file.", NULL, NULL);
 …
         char test_number_argument[MAX_TEST_NUMBER_WIDTH];
         snprintf(test_number_argument, MAX_TEST_NUMBER_WIDTH, "-t%d", test->id);
-        int *files[4];
-        int fd_stdin = fileno(stdin);
-        files[0] = &fd_stdin;
-        files[1] = &tempfile;
-        files[2] = &tempfile;
-        files[3] = NULL;
         const char *const arguments[3] = {
 …
         task_wait_t test_task_wait;
+        int rc = task_spawnvf(&test_task_id, &test_task_wait, self_path, arguments, files);
+        int rc = task_spawnvf(&test_task_id, &test_task_wait, self_path, arguments,
+            fileno(stdin), tempfile, tempfile);
         if (rc != EOK) {
                 status = TEST_OUTCOME_ERROR;
 …
         fibril_mutex_unlock(&forced_termination_mutex);
+        read(tempfile, extra_output_buffer, OUTPUT_BUFFER_SIZE);
+        aoff64_t pos = 0;
+        vfs_read(tempfile, &pos, extra_output_buffer, OUTPUT_BUFFER_SIZE);
 leave_close_tempfile:
         close(tempfile);
         unlink(tempfile_name);
+        vfs_put(tempfile);
+        vfs_unlink_path(tempfile_name);
         pcut_report_test_done_unparsed(test, status, extra_output_buffer, OUTPUT_BUFFER_SIZE);

uspace/lib/posix/include/posix/fcntl.h

-              r39f892a9
+              r368ee04
 #include "sys/types.h"
-#include "libc/fcntl.h"
 #include "errno.h"
+#undef O_CREAT
+#undef O_EXCL
+#undef O_TRUNC
+#undef O_APPEND
+#undef O_RDONLY
+#undef O_RDWR
+#undef O_WRONLY
+#define O_CREAT   1
+#define O_EXCL    2
+#define O_TRUNC   4
+#define O_APPEND  8
+#define O_RDONLY  16
+#define O_RDWR    32
+#define O_WRONLY  64
 /* Mask for file access modes. */

uspace/lib/posix/include/posix/sys/stat.h

-              r39f892a9
+              r368ee04
         __POSIX_DEF__(dev_t)     st_dev;     /* ID of device containing file */
         __POSIX_DEF__(ino_t)     st_ino;     /* inode number */
         mode_t          st_mode;    /* protection */
+        __POSIX_DEF__(mode_t)    st_mode;    /* protection */
         __POSIX_DEF__(nlink_t)   st_nlink;   /* number of hard links */
         __POSIX_DEF__(uid_t)     st_uid;     /* user ID of owner */
 …
 extern int __POSIX_DEF__(lstat)(const char *restrict path, struct __POSIX_DEF__(stat) *restrict st);
 extern int __POSIX_DEF__(stat)(const char *restrict path, struct __POSIX_DEF__(stat) *restrict st);
 extern int __POSIX_DEF__(chmod)(const char *path, mode_t mode);
 extern mode_t __POSIX_DEF__(umask)(mode_t mask);
 extern int mkdir(const char *, mode_t);
+extern int __POSIX_DEF__(chmod)(const char *path, __POSIX_DEF__(mode_t) mode);
+extern __POSIX_DEF__(mode_t) __POSIX_DEF__(umask)(__POSIX_DEF__(mode_t) mask);
+extern int __POSIX_DEF__(mkdir)(const char *path, __POSIX_DEF__(mode_t) mode);

uspace/lib/posix/include/posix/sys/types.h

r39f892a9	r368ee04
53	53	typedef int64_t __POSIX_DEF__(pid_t);
54	54	typedef sysarg_t __POSIX_DEF__(dev_t);
	55	typedef unsigned int __POSIX_DEF__(mode_t);
55	56
56	57	/* PThread Types */

uspace/lib/posix/source/fcntl.c

-              r39f892a9
+              r368ee04
+ *
  * @param pathname Path to the file.
  * @param flags Access mode flags.
+ * @param posix_flags Access mode flags.
  */
 int posix_open(const char *pathname, int flags, ...)
+int posix_open(const char *pathname, int posix_flags, ...)
+{
+        mode_t mode = 0;
+        if ((flags & O_CREAT) > 0) {
+        int rc;
+        posix_mode_t posix_mode = 0;
+        if (posix_flags & O_CREAT) {
                 va_list args;
                 va_start(args, flags);
                 mode = va_arg(args, mode_t);
+                va_start(args, posix_flags);
+                posix_mode = va_arg(args, posix_mode_t);
                 va_end(args);
+                (void) posix_mode;
+        }
+        return negerrno(open, pathname, flags, mode);
+        if (((posix_flags & (O_RDONLY | O_WRONLY | O_RDWR)) == 0) ||
+            ((posix_flags & (O_RDONLY | O_WRONLY)) == (O_RDONLY | O_WRONLY)) ||
+            ((posix_flags & (O_RDONLY | O_RDWR)) == (O_RDONLY | O_RDWR)) ||
+            ((posix_flags & (O_WRONLY | O_RDWR)) == (O_WRONLY | O_RDWR))) {
+                errno = EINVAL;
+                return -1;
+        }
+        int flags = WALK_REGULAR;
+        if (posix_flags & O_CREAT) {
+                if (posix_flags & O_EXCL)
+                        flags |= WALK_MUST_CREATE;
+                else
+                        flags |= WALK_MAY_CREATE;
+        }
+        int mode =
+            ((posix_flags & O_RDWR) ? MODE_READ | MODE_WRITE : 0) |
+            ((posix_flags & O_RDONLY) ? MODE_READ : 0) |
+            ((posix_flags & O_WRONLY) ? MODE_WRITE : 0) |
+            ((posix_flags & O_APPEND) ? MODE_APPEND : 0);
+        int file = rcerrno(vfs_lookup, pathname, flags);
+        if (file < 0)
+                return -1;
+        rc = rcerrno(vfs_open, file, mode);
+        if (rc != EOK) {
+                vfs_put(file);
+                return -1;
+        }
+        if (posix_flags & O_TRUNC) {
+                if (posix_flags & (O_RDWR | O_WRONLY)) {
+                        rc = rcerrno(vfs_resize, file, 0);
+                        if (rc != EOK) {
+                                vfs_put(file);
+                                return -1;
+                        }
+                }
+        }
+        return file;
+}
 /** @}
  */

uspace/lib/posix/source/internal/common.h

-              r39f892a9
+              r368ee04
 #include <stdio.h>
 #include <stdlib.h>
+#include <sys/types.h>
+#include <vfs/vfs.h>
 #define not_implemented() do { \
 …
 })
+/* Convert error code to positive errno and -1 return value */
+#define rcerrno(func, ...) ({ \
+        int rc = func(__VA_ARGS__); \
+        if (rc < 0) \
+                errno = -rc; \
+        rc; \
+})
+extern aoff64_t posix_pos[MAX_OPEN_FILES];
 #endif /* LIBPOSIX_COMMON_H_ */

uspace/lib/posix/source/stdio.c

-              r39f892a9
+              r368ee04
 #include "libc/malloc.h"
 #include "libc/adt/list.h"
-#include "libc/sys/stat.h"
 /** Clears the stream's error and end-of-file indicators.
 …
 static int _dprintf_str_write(const char *str, size_t size, void *fd)
+{
+        ssize_t wr = write(*(int *) fd, str, size);
+        const int fildes = *(int *) fd;
+        ssize_t wr = vfs_write(fildes, &posix_pos[fildes], str, size);
         if (wr < 0)
                 return errno;
+                return wr;
         return str_nlength(str, wr);
+}
 …
+                }
+                if (write(*(int *) fd, buf, sz) != (ssize_t) sz) {
+                const int fildes = *(int *) fd;
+                if (vfs_write(fildes, &posix_pos[fildes], buf, sz) < 0)
                         break;
+                }
                 chars++;
 …
 int posix_remove(const char *path)
+{
+        return negerrno(remove, path);
+        if (rcerrno(vfs_unlink_path, path) != EOK)
+                return -1;
+        else
+                return 0;
+}
 …
 int posix_rename(const char *old, const char *new)
+{
+        return negerrno(rename, old, new);
+        int rc = rcerrno(vfs_rename_path, old, new);
+        if (rc != EOK)
+                return -1;
+        else
+                return 0;
+}

uspace/lib/posix/source/stdlib.c

r39f892a9	r368ee04
431	431	}
432	432
433		fd = open(tmpl, O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
	433	fd = posix_open(tmpl, O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
434	434
435	435	if (fd == -1) {

uspace/lib/posix/source/sys/stat.c

-              r39f892a9
+              r368ee04
 #include "../internal/common.h"
 #include "posix/sys/stat.h"
 #include "libc/sys/stat.h"
+#include "libc/vfs/vfs.h"
 #include "posix/errno.h"
 …
  * @param dest POSIX stat struct.
  * @param src HelenOS stat struct.
+ *
+ * @return 0 on success, -1 on error.
  */
 static void stat_to_posix(struct posix_stat *dest, struct stat *src)
+static int stat_to_posix(struct posix_stat *dest, struct stat *src)
+{
         memset(dest, 0, sizeof(struct posix_stat));
 …
         dest->st_nlink = src->lnkcnt;
         dest->st_size = src->size;
+        if (src->size > INT64_MAX) {
+                errno = ERANGE;
+                return -1;
+        }
+        return 0;
+}
 …
+{
         struct stat hst;
         int rc = negerrno(fstat, fd, &hst);
+        int rc = rcerrno(vfs_stat, fd, &hst);
         if (rc < 0)
+                return rc;
+        stat_to_posix(st, &hst);
+        return 0;
+                return -1;
+        return stat_to_posix(st, &hst);
+}
 …
+{
         struct stat hst;
         int rc = negerrno(stat, path, &hst);
+        int rc = rcerrno(vfs_stat_path, path, &hst);
         if (rc < 0)
+                return rc;
+        stat_to_posix(st, &hst);
+        return 0;
+                return -1;
+        return stat_to_posix(st, &hst);
+}
 …
  * @return Zero on success, -1 otherwise.
  */
 int posix_chmod(const char *path, mode_t mode)
+int posix_chmod(const char *path, posix_mode_t mode)
+{
         /* HelenOS doesn't support permissions, return success. */
 …
  * @return Previous file mode creation mask.
  */
 mode_t posix_umask(mode_t mask)
+posix_mode_t posix_umask(posix_mode_t mask)
+{
         /* HelenOS doesn't support permissions, return empty mask. */
 …
+}
+/**
+ * Create a directory.
+ *
+ * @param path Path to the new directory.
+ * @param mode Permission bits to be set.
+ * @return Zero on success, -1 otherwise.
+ */
+int posix_mkdir(const char *path, posix_mode_t mode)
+{
+        int rc = rcerrno(vfs_link_path, path, KIND_DIRECTORY, NULL);
+        if (rc != EOK)
+                return -1;
+        else
+                return 0;
+}
 /** @}
  */

uspace/lib/posix/source/unistd.c

-              r39f892a9
+              r368ee04
 #include "libc/stats.h"
 #include "libc/malloc.h"
+#include "libc/vfs/vfs.h"
+aoff64_t posix_pos[MAX_OPEN_FILES];
 /* Array of environment variable strings (NAME=VALUE). */
 …
 char *posix_getcwd(char *buf, size_t size)
+{
+        char *p = getcwd(buf, size);
+        if (p == NULL) {
+                errno = -errno;
+        int rc = rcerrno(vfs_cwd_get, buf, size);
+        if (rc != EOK)
                 return NULL;
+        }
+        return p;
+        return buf;
+}
 …
 int posix_chdir(const char *path)
+{
+        return negerrno(chdir, path);
+        int rc = rcerrno(vfs_cwd_set, path);
+        if (rc != EOK)
+                return -1;
+        return 0;
+}
 …
 int posix_close(int fildes)
+{
+        return negerrno(close, fildes);
+        posix_pos[fildes] = 0;
+        int rc = rcerrno(vfs_put, fildes);
+        if (rc != EOK)
+                return -1;
+        else
+                return 0;
+}
 …
 ssize_t posix_read(int fildes, void *buf, size_t nbyte)
+{
+        return negerrno(read, fildes, buf, nbyte);
+        ssize_t size = rcerrno(vfs_read, fildes, &posix_pos[fildes], buf, nbyte);
+        if (size < 0)
+                return -1;
+        return size;
+}
 …
 ssize_t posix_write(int fildes, const void *buf, size_t nbyte)
+{
+        return negerrno(write, fildes, buf, nbyte);
+        ssize_t size = rcerrno(vfs_write, fildes, &posix_pos[fildes], buf, nbyte);
+        if (size < 0)
+                return -1;
+        return size;
+}
 …
 posix_off_t posix_lseek(int fildes, posix_off_t offset, int whence)
+{
+        return negerrno(lseek, fildes, offset, whence);
+        struct stat st;
+        int rc;
+        switch (whence) {
+        case SEEK_SET:
+                posix_pos[fildes] = offset;
+                break;
+        case SEEK_CUR:
+                posix_pos[fildes] += offset;
+                break;
+        case SEEK_END:
+                rc = rcerrno(vfs_stat, fildes, &st);
+                if (rc != EOK)
+                        return -1;
+                posix_pos[fildes] = st.size + offset;
+                break;
+        }
+        if (posix_pos[fildes] > INT64_MAX) {
+                /* The native width is too large for the POSIX interface. */
+                errno = ERANGE;
+                return -1;
+        }
+        return posix_pos[fildes];
+}
 …
 int posix_fsync(int fildes)
+{
+        return negerrno(fsync, fildes);
+        if (rcerrno(vfs_sync, fildes) != EOK)
+                return -1;
+        else
+                return 0;
+}
 …
 int posix_ftruncate(int fildes, posix_off_t length)
+{
+        return negerrno(ftruncate, fildes, (aoff64_t) length);
+        if (rcerrno(vfs_resize, fildes, (aoff64_t) length) != EOK)
+                return -1;
+        else
+                return 0;
+}
 …
 int posix_rmdir(const char *path)
+{
+        return negerrno(rmdir, path);
+        if (rcerrno(vfs_unlink_path, path) != EOK)
+                return -1;
+        else
+                return 0;
+}
 …
 int posix_unlink(const char *path)
+{
+        return negerrno(unlink, path);
+        if (rcerrno(vfs_unlink_path, path) != EOK)
+                return -1;
+        else
+                return 0;
+}
 …
 int posix_dup2(int fildes, int fildes2)
+{
         return negerrno(dup2, fildes, fildes2);
+        return negerrno(vfs_clone, fildes, fildes2, false);
+}
 …
                  * Check file existence by attempting to open it.
                  */
+                int fd = negerrno(open, path, O_RDONLY);
+                if (fd < 0) {
+                        /* errno was set by open() */
+                int fd = posix_open(path, O_RDONLY);
+                if (fd < 0)
                         return -1;
+                }
+                close(fd);
+                posix_close(fd);
                 return 0;
         } else {

Context Navigation

Changeset 368ee04 in mainline for uspace/lib

Legend:

Download in other formats: