fixesHEADhelloworldmaster

25 files changed, 1169 insertions, 193 deletions

diff --git a/src/bin/include/bin.h b/src/bin/include/bin.h
index a5528c5..34558f9 100644
--- a/src/bin/include/bin.h
+++ b/src/bin/include/bin.h
@@ -20,8 +20,10 @@
 #define BIN_H
 
 #include <sys/types.h>
+#include <fs/fs.h>
 
-int bin_exec(const char *path, const char *const *argv, uid_t uid, gid_t gid);
+int bin_exec(const char *path, const char *const *argv,
+    const struct fs_stdstreams *ss, pid_t parent, uid_t uid, gid_t gid);
 int bin_update(void);
 
 #endif
diff --git a/src/bin/private_include/bin/proc.h b/src/bin/private_include/bin/proc.h
index cf0c04e..92f1566 100644
--- a/src/bin/private_include/bin/proc.h
+++ b/src/bin/private_include/bin/proc.h
@@ -43,6 +43,8 @@ int bin_proc_s_pop(void *dst, size_t n, void *user);
 int bin_proc_s_read(size_t offset, void *dst, size_t n, void *user);
 int bin_proc_s_write(size_t offset, const void *dst, size_t n, void *user);
 size_t bin_proc_s_ptr(void *user);
+struct bin_proc_fd *bin_proc_fd_find(const struct bin_proc *p, int fd);
+int bin_proc_fd_alloc(struct bin_proc *p, const struct fs_fd *fd, int flags);
 
 extern const struct nw_inst_cfg bin_proc_cfg;
 
diff --git a/src/bin/private_include/bin/types.h b/src/bin/private_include/bin/types.h
index 2a498ed..6f231ae 100644
--- a/src/bin/private_include/bin/types.h
+++ b/src/bin/private_include/bin/types.h
@@ -28,7 +28,7 @@
 #include <sys/types.h>
 #include <stdbool.h>
 
-enum {BIN_IMPORTS = 9};
+enum {BIN_IMPORTS = 10};
 
 struct bin_dbg
 {
@@ -54,18 +54,25 @@ struct bin_global
     size_t sz;
 };
 
+struct bin_proc_fd
+{
+    int fd, flags;
+    struct fs_fd fs_fd;
+};
+
 struct bin_proc
 {
     const struct bin_mod *mod;
     struct nw_inst instance;
-    union nw_value args[7];
+    union nw_value args[6];
     struct bin_dbg dbg;
     struct caio *caio;
     char *path, **argv;
     size_t argc;
-    pid_t pid;
+    pid_t pid, parent;
     uid_t uid;
     gid_t gid;
+    mode_t umask;
     char header[sizeof "asm"];
     size_t i;
     long retval;
@@ -73,7 +80,8 @@ struct bin_proc
     struct bin_global global;
     void *import;
     struct page *linear;
-    int *fds;
+    struct fs_stdstreams ss;
+    struct bin_proc_fd *fds;
     size_t n_fds;
     struct bin_proc *prev, *next;
 };
diff --git a/src/bin/private_include/bin/wasi/errno.h b/src/bin/private_include/bin/wasi/errno.h
deleted file mode 100644
index 442e877..0000000
--- a/src/bin/private_include/bin/wasi/errno.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * wnix, a Unix-like operating system for WebAssembly applications.
- * Copyright (C) 2025  Xavier Del Campo Romero
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#ifndef WASI_ERRNO_H
-#define WASI_ERRNO_H
-
-enum wasi_errno
-{
-    WASI_SUCCESS,
-    WASI_2BIG,
-    WASI_ACCES,
-    WASI_ADDRINUSE,
-    WASI_ADDRNOTAVAIL,
-    WASI_AFNOSUPPORT,
-    WASI_AGAIN,
-    WASI_ALREADY,
-    WASI_BADF,
-    WASI_BADMSG,
-    WASI_BUSY,
-    WASI_CANCELED,
-    WASI_CHILD,
-    WASI_CONNABORTED,
-    WASI_CONNREFUSED,
-    WASI_CONNRESET,
-    WASI_DEADLK,
-    WASI_DESTADDRREQ,
-    WASI_DOM,
-    WASI_DQUOT,
-    WASI_EXIST,
-    WASI_FAULT,
-    WASI_FBIG,
-    WASI_HOSTUNREACH,
-    WASI_IDRM,
-    WASI_ILSEQ,
-    WASI_INPROGRESS,
-    WASI_INTR,
-    WASI_INVAL,
-    WASI_IO,
-    WASI_ISCONN,
-    WASI_ISDIR,
-    WASI_LOOP,
-    WASI_MFILE,
-    WASI_MLINK,
-    WASI_MSGSIZE,
-    WASI_MULTIHOP,
-    WASI_NAMETOOLONG,
-    WASI_NETDOWN,
-    WASI_NETRESET,
-    WASI_NETUNREACH,
-    WASI_NFILE,
-    WASI_NOBUFS,
-    WASI_NODEV,
-    WASI_NOENT,
-    WASI_NOEXEC,
-    WASI_NOLCK,
-    WASI_NOLINK,
-    WASI_NOMEM,
-    WASI_NOMSG,
-    WASI_NOPROTOOPT,
-    WASI_NOSPC,
-    WASI_NOSYS,
-    WASI_NOTCONN,
-    WASI_NOTDIR,
-    WASI_NOTEMPTY,
-    WASI_NOTRECOVERABLE,
-    WASI_NOTSOCK,
-    WASI_NOTSUP,
-    WASI_NOTTY,
-    WASI_NXIO,
-    WASI_OVERFLOW,
-    WASI_OWNERDEAD,
-    WASI_PERM,
-    WASI_PIPE,
-    WASI_PROTO,
-    WASI_PROTONOSUPPORT,
-    WASI_PROTOTYPE,
-    WASI_RANGE,
-    WASI_ROFS,
-    WASI_SPIPE,
-    WASI_SRCH,
-    WASI_STALE,
-    WASI_TIMEDOUT,
-    WASI_TXTBSY,
-    WASI_XDEV,
-    WASI_NOTCAPABLE
-};
-
-int wasi_errno(int error, enum wasi_errno *out);
-
-#endif
diff --git a/src/bin/private_include/bin/wnix.h b/src/bin/private_include/bin/wnix.h
index 07e7131..f3844c5 100644
--- a/src/bin/private_include/bin/wnix.h
+++ b/src/bin/private_include/bin/wnix.h
@@ -33,5 +33,13 @@ enum nw_state bin_wnix_mkdir(const union nw_value *params,
     union nw_value *ret, void *user, struct nw_next *next);
 enum nw_state bin_wnix_mount(const union nw_value *params,
     union nw_value *ret, void *user, struct nw_next *next);
+enum nw_state bin_wnix_write(const union nw_value *params,
+    union nw_value *ret, void *user, struct nw_next *next);
+enum nw_state bin_wnix_umask(const union nw_value *params,
+    union nw_value *ret, void *user, struct nw_next *next);
+enum nw_state bin_wnix_open(const union nw_value *params,
+    union nw_value *ret, void *user, struct nw_next *next);
+enum nw_state bin_wnix_close(const union nw_value *params,
+    union nw_value *ret, void *user, struct nw_next *next);
 
 #endif
diff --git a/src/bin/private_include/bin/wnix/routines.h b/src/bin/private_include/bin/wnix/routines.h
index aa488fb..3ba5118 100644
--- a/src/bin/private_include/bin/wnix/routines.h
+++ b/src/bin/private_include/bin/wnix/routines.h
@@ -23,7 +23,22 @@
 #include <bin/types.h>
 #include <nanowasm/nw.h>
 
-int bin_wnix_set_errno(struct bin_proc *p, int error, unsigned long addr,
-    struct nw_next *next);
+struct bin_readstr
+{
+    unsigned long addr;
+    struct bin_proc *p;
+    char **str;
+    int (*error)(struct bin_proc *, int, struct nw_next *);
+};
+
+struct bin_set_errno
+{
+    int error;
+    unsigned long addr;
+    struct bin_proc *p;
+};
+
+int bin_wnix_readstr(const struct bin_readstr *cfg, struct nw_next *next);
+int bin_wnix_set_errno(const struct bin_set_errno *cfg, struct nw_next *next);
 
 #endif
diff --git a/src/bin/src/exec.c b/src/bin/src/exec.c
index 83c0e5f..1796af9 100644
--- a/src/bin/src/exec.c
+++ b/src/bin/src/exec.c
@@ -30,6 +30,7 @@
 #include <nanowasm/nw.h>
 #include <nanowasm/dbg.h>
 #include <fcntl.h>
+#include <sys/stat.h>
 #include <sys/types.h>
 #include <stdlib.h>
 #include <string.h>
@@ -318,7 +319,8 @@ failure:
 }
 
 int bin_exec(const char *const path, const char *const *const argv,
-    const uid_t uid, const gid_t gid)
+    const struct fs_stdstreams *const ss, const pid_t parent, const uid_t uid,
+    const gid_t gid)
 {
     const pid_t pid = bin_pid();
     char *pathdup = NULL;
@@ -353,9 +355,12 @@ int bin_exec(const char *const path, const char *const *const argv,
     {
         .path = pathdup,
         .dbg.aio = serial,
+        .parent = parent,
         .pid = pid,
         .uid = uid,
-        .gid = gid
+        .gid = gid,
+        .ss = *ss,
+        .umask = S_IWGRP | S_IWOTH
     };
 
     if (copy_args(p, path, argv)
diff --git a/src/bin/src/mod/cfg.c b/src/bin/src/mod/cfg.c
index 8c78a32..1be26ca 100644
--- a/src/bin/src/mod/cfg.c
+++ b/src/bin/src/mod/cfg.c
@@ -88,6 +88,50 @@ static const struct nw_import imports[BIN_IMPORTS] =
             .fn = bin_wnix_mount,
             .signature = "i(iiiiii)"
         }
+    },
+
+    {
+        .kind = NW_KIND_FUNCTION,
+        .module = "wnix",
+        .field = "write",
+        .u.function =
+        {
+            .fn = bin_wnix_write,
+            .signature = "i(iiii)"
+        }
+    },
+
+    {
+        .kind = NW_KIND_FUNCTION,
+        .module = "wnix",
+        .field = "umask",
+        .u.function =
+        {
+            .fn = bin_wnix_umask,
+            .signature = "i(i)"
+        }
+    },
+
+    {
+        .kind = NW_KIND_FUNCTION,
+        .module = "wnix",
+        .field = "open",
+        .u.function =
+        {
+            .fn = bin_wnix_open,
+            .signature = "i(iiii)"
+        }
+    },
+
+    {
+        .kind = NW_KIND_FUNCTION,
+        .module = "wnix",
+        .field = "close",
+        .u.function =
+        {
+            .fn = bin_wnix_close,
+            .signature = "i(ii)"
+        }
     }
 };
 
diff --git a/src/bin/src/proc/CMakeLists.txt b/src/bin/src/proc/CMakeLists.txt
index 47df502..e9a1d1c 100644
--- a/src/bin/src/proc/CMakeLists.txt
+++ b/src/bin/src/proc/CMakeLists.txt
@@ -17,6 +17,8 @@
 target_sources(bin PRIVATE
     cfg.c
     eof.c
+    fd_alloc.c
+    fd_find.c
     free.c
     init.c
     lock.c
diff --git a/src/bin/src/proc/fd_alloc.c b/src/bin/src/proc/fd_alloc.c
new file mode 100644
index 0000000..3db5e17
--- /dev/null
+++ b/src/bin/src/proc/fd_alloc.c
@@ -0,0 +1,54 @@
+/*
+ * wnix, a Unix-like operating system for WebAssembly applications.
+ * Copyright (C) 2025  Xavier Del Campo Romero
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <bin/proc.h>
+#include <bin/types.h>
+#include <fs/fs.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+int bin_proc_fd_alloc(struct bin_proc *const p, const struct fs_fd *const fs_fd,
+    const int flags)
+{
+    int fd = 0;
+
+    for (size_t i = 0; i < p->n_fds;)
+        if (fd == p->fds[i].fd)
+        {
+            fd++;
+            i = 0;
+        }
+        else
+            i++;
+
+    const size_t n = p->n_fds + 1;
+    struct bin_proc_fd *const fds = realloc(p->fds, n * sizeof *fds);
+
+    if (!fds)
+        return -1;
+
+    fds[p->n_fds++] = (const struct bin_proc_fd)
+    {
+        .fd = fd,
+        .flags = flags,
+        .fs_fd = *fs_fd
+    };
+
+    p->fds = fds;
+    return fd;
+}
diff --git a/src/bin/src/proc/fd_find.c b/src/bin/src/proc/fd_find.c
new file mode 100644
index 0000000..b729e26
--- /dev/null
+++ b/src/bin/src/proc/fd_find.c
@@ -0,0 +1,38 @@
+/*
+ * wnix, a Unix-like operating system for WebAssembly applications.
+ * Copyright (C) 2025  Xavier Del Campo Romero
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <bin/proc.h>
+#include <bin/types.h>
+#include <fcntl.h>
+#include <stddef.h>
+
+struct bin_proc_fd *bin_proc_fd_find(const struct bin_proc *const p, const int fd)
+{
+    if (fd < 0)
+        return NULL;
+
+    for (size_t i = 0; i < p->n_fds; i++)
+    {
+        struct bin_proc_fd *const pfd = &p->fds[i];
+
+        if (pfd->fd == fd && pfd->flags & O_WRONLY)
+            return pfd;
+    }
+
+    return NULL;
+}
diff --git a/src/bin/src/proc/free.c b/src/bin/src/proc/free.c
index a5bdea1..6876749 100644
--- a/src/bin/src/proc/free.c
+++ b/src/bin/src/proc/free.c
@@ -30,6 +30,9 @@ void bin_proc_free(struct bin_proc *const p)
 
     struct bin_dbg *const d = &p->dbg;
 
+    for (char **arg = p->argv; *arg; arg++)
+        free(*arg);
+
     dynstr_free(&d->dstr);
     free(d->bkpt);
     aio_free(d->aio);
diff --git a/src/bin/src/proc/pc.c b/src/bin/src/proc/pc.c
index 28b2f44..29bdd7f 100644
--- a/src/bin/src/proc/pc.c
+++ b/src/bin/src/proc/pc.c
@@ -643,6 +643,7 @@ enum nw_state bin_proc_pc(const long offset, struct nw_next *const next,
         return NW_AGAIN;
     }
     else
+    {
         for (size_t i = 0; i < d->n_bkpt; i++)
             if (offset == d->bkpt[i])
             {
@@ -653,5 +654,23 @@ enum nw_state bin_proc_pc(const long offset, struct nw_next *const next,
                 return NW_AGAIN;
             }
 
+        const struct fs_read r =
+        {
+            .fd = &d->fd,
+            .buf = &d->b,
+            .n = sizeof d->b
+        };
+
+        const int n = aio_read_nb(&r);
+
+        if (n < 0)
+        {
+            kprintf("%s: aio_read_nb failed\n", __func__);
+            return NW_FATAL;
+        }
+        else if (n && d->b == -1)
+            d->running = false;
+    }
+
     return NW_OK;
 }
diff --git a/src/bin/src/update.c b/src/bin/src/update.c
index 3f03ae7..f5ce1c6 100644
--- a/src/bin/src/update.c
+++ b/src/bin/src/update.c
@@ -35,10 +35,10 @@ static int load(void)
 
         switch (nw_load(&m->mod, &m->mod_out))
         {
-            case STATE_AGAIN:
+            case NW_AGAIN:
                 break;
 
-            case STATE_FATAL:
+            case NW_FATAL:
                 /* TODO: call nw_loadexc. */
                 kprintf("Module %s failed to load\n", m->path);
 
@@ -48,7 +48,7 @@ static int load(void)
                 bin_mod_free(m);
                 break;
 
-            case STATE_OK:
+            case NW_OK:
                 kprintf("Module %s loaded successfully\n", m->path);
 
                 if (bin_start(m))
diff --git a/src/bin/src/wnix/CMakeLists.txt b/src/bin/src/wnix/CMakeLists.txt
index b4868f2..5a92246 100644
--- a/src/bin/src/wnix/CMakeLists.txt
+++ b/src/bin/src/wnix/CMakeLists.txt
@@ -18,8 +18,13 @@ target_sources(bin PRIVATE
     argc.c
     argcopy.c
     arglen.c
+    close.c
     exit.c
     mkdir.c
     mount.c
-    set_errno.c
+    open.c
+    umask.c
+    write.c
 )
+
+add_subdirectory(routines)
diff --git a/src/bin/src/wnix/argcopy.c b/src/bin/src/wnix/argcopy.c
index cedb26e..f712016 100644
--- a/src/bin/src/wnix/argcopy.c
+++ b/src/bin/src/wnix/argcopy.c
@@ -21,7 +21,6 @@
 #include <bin/wnix/routines.h>
 #include <bin/proc.h>
 #include <bin/types.h>
-#include <endian.h>
 #include <nanowasm/nw.h>
 #include <nanowasm/linear.h>
 #include <errno.h>
@@ -66,7 +65,14 @@ static int set_errno(struct bin_proc *const p, const int error,
         .user = p
     };
 
-    return bin_wnix_set_errno(p, error, c->errno_addr, next);
+    const struct bin_set_errno cfg =
+    {
+        .addr = c->errno_addr,
+        .error = error,
+        .p = p
+    };
+
+    return bin_wnix_set_errno(&cfg, next);
 }
 
 static enum nw_state read_arg(void *const user, struct nw_next *const next)
@@ -112,6 +118,8 @@ static enum nw_state check(void *const user, struct nw_next *const next)
     else
         *next = (const struct nw_next){.fn = read_arg, .user = user};
 
+    return NW_AGAIN;
+
 failure:
     free_argcopy(c);
     return NW_FATAL;
@@ -137,7 +145,7 @@ enum nw_state bin_wnix_argcopy(const union nw_value *const params,
 
     struct bin_proc *const p = user;
 
-    *next = (const struct nw_next){.fn = check, .user = user};
     p->import = c;
+    *next = (const struct nw_next){.fn = check, .user = user};
     return NW_AGAIN;
 }
diff --git a/src/bin/src/wnix/close.c b/src/bin/src/wnix/close.c
new file mode 100644
index 0000000..7e1754f
--- /dev/null
+++ b/src/bin/src/wnix/close.c
@@ -0,0 +1,32 @@
+/*
+ * wnix, a Unix-like operating system for WebAssembly applications.
+ * Copyright (C) 2025  Xavier Del Campo Romero
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <bin.h>
+#include <bin/wnix.h>
+#include <bin/proc.h>
+#include <bin/types.h>
+#include <nanowasm/nw.h>
+
+enum nw_state bin_wnix_close(const union nw_value *const params,
+    union nw_value *const ret, void *const user,
+    struct nw_next *const next)
+{
+    /* TODO */
+    ret->i32 = -1;
+    return NW_OK;
+}
diff --git a/src/bin/src/wnix/mkdir.c b/src/bin/src/wnix/mkdir.c
index 30a274a..8b26a2c 100644
--- a/src/bin/src/wnix/mkdir.c
+++ b/src/bin/src/wnix/mkdir.c
@@ -21,18 +21,215 @@
 #include <bin/wnix/routines.h>
 #include <bin/proc.h>
 #include <bin/types.h>
-#include <endian.h>
+#include <aio.h>
+#include <fs/fs.h>
+#include <loop.h>
 #include <nanowasm/nw.h>
 #include <nanowasm/linear.h>
 #include <errno.h>
 #include <stdlib.h>
-#include <string.h>
+
+struct mkdir
+{
+    char *path;
+    unsigned long path_addr, errno_addr, mode;
+    union nw_value *ret;
+    struct aio *aio;
+    int error;
+};
+
+static void free_mkdir(struct mkdir *const m)
+{
+    if (!m)
+        return;
+
+    aio_free(m->aio);
+    free(m->path);
+    free(m);
+}
+
+static enum nw_state fail(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct mkdir *const m = p->import;
+
+    m->ret->i32 = -1;
+    free_mkdir(m);
+    return NW_OK;
+}
+
+static int set_errno(struct bin_proc *const p, const int error,
+    struct nw_next *const next)
+{
+    struct mkdir *const m = p->import;
+
+    if (m->errno_addr)
+    {
+        const struct bin_set_errno cfg =
+        {
+            .addr = m->errno_addr,
+            .error = error,
+            .p = p
+        };
+
+        *next = (const struct nw_next)
+        {
+            .fn = fail,
+            .user = p
+        };
+
+        if (bin_wnix_set_errno(&cfg, next))
+        {
+            free_mkdir(m);
+            return -1;
+        }
+    }
+    else
+        return fail(p, next);
+
+    return 0;
+}
+
+static enum nw_state check_mkdir(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct mkdir *const m = p->import;
+    enum nw_state ret = NW_OK;
+
+    if (m->error)
+    {
+        if (set_errno(p, m->error, next))
+            ret = NW_FATAL;
+        else
+            return NW_AGAIN;
+    }
+
+    free_mkdir(m);
+    return ret;
+}
+
+static int mkdir_done(const enum state state, void *const args)
+{
+    struct bin_proc *const p = args;
+    struct mkdir *const m = p->import;
+
+    m->error = state ? errno : 0;
+
+    if (bin_proc_unlock(p) || loop_rm_aio(m->aio))
+    {
+        free_mkdir(m);
+        return -1;
+    }
+
+    aio_free(m->aio);
+    m->aio = NULL;
+    return 0;
+}
+
+static enum nw_state do_mkdir(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct mkdir *const m = p->import;
+    const struct aio_done d =
+    {
+        .f = mkdir_done,
+        .args = p
+    };
+
+    const struct fs_mkdir mk =
+    {
+        .mode = m->mode,
+        .path = m->path,
+        .uid = p->uid,
+        .gid = p->gid
+    };
+
+    struct aio *const aio = aio_mkdir(&mk, &d);
+
+    if (!aio || bin_proc_lock(p) || loop_add_aio(aio))
+    {
+        aio_free(aio);
+        free_mkdir(m);
+        return NW_FATAL;
+    }
+
+    m->aio = aio;
+    *next = (const struct nw_next){.fn = check_mkdir, .user = user};
+    return NW_AGAIN;
+}
+
+static enum nw_state read_path(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct mkdir *const m = p->import;
+    const struct bin_readstr cfg =
+    {
+        .error = set_errno,
+        .addr = m->path_addr,
+        .str = &m->path,
+        .p = p
+    };
+
+    *next = (const struct nw_next){.fn = do_mkdir, .user = user};
+
+    if (bin_wnix_readstr(&cfg, next))
+    {
+        free_mkdir(m);
+        return NW_FATAL;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state check(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct mkdir *const m = p->import;
+
+    if (!m->path_addr || !m->errno_addr)
+    {
+        if (m->errno_addr)
+        {
+            if (set_errno(p, EINVAL, next))
+                goto failure;
+        }
+        else
+        {
+            m->ret->i32 = -1;
+            return NW_OK;
+        }
+    }
+    else
+        *next = (const struct nw_next){.fn = read_path, .user = user};
+
+    return NW_AGAIN;
+
+failure:
+    free_mkdir(m);
+    return NW_FATAL;
+}
 
 enum nw_state bin_wnix_mkdir(const union nw_value *const params,
     union nw_value *const ret, void *const user,
     struct nw_next *const next)
 {
-    /* TODO */
-    ret->i32 = -1;
-    return NW_OK;
+    enum {PATH, MODE, ERRNO};
+    struct mkdir *const m = malloc(sizeof *m);
+
+    if (!m)
+        return NW_FATAL;
+
+    *m = (const struct mkdir)
+    {
+        .path_addr = params[PATH].i32,
+        .mode = params[MODE].i32,
+        .errno_addr = params[ERRNO].i32,
+        .ret = ret
+    };
+
+    struct bin_proc *const p = user;
+
+    *next = (const struct nw_next){.fn = check, .user = user};
+    p->import = m;
+    return NW_AGAIN;
 }
diff --git a/src/bin/src/wnix/mount.c b/src/bin/src/wnix/mount.c
index 562f7d9..f3acea6 100644
--- a/src/bin/src/wnix/mount.c
+++ b/src/bin/src/wnix/mount.c
@@ -78,7 +78,14 @@ static int set_errno(struct bin_proc *const p, const int error,
         .user = p
     };
 
-    return bin_wnix_set_errno(p, error, m->errno_addr, next);
+    const struct bin_set_errno cfg =
+    {
+        .addr = m->errno_addr,
+        .error = error,
+        .p = p
+    };
+
+    return bin_wnix_set_errno(&cfg, next);
 }
 
 static enum nw_state mounted(void *const user, struct nw_next *const next)
@@ -160,55 +167,23 @@ failure:
     return NW_FATAL;
 }
 
-static enum nw_state read_str(struct bin_proc *const p,
-    struct mountstr *const ms)
+static enum nw_state read_string(struct bin_proc *const p,
+    struct mountstr *const ms, struct nw_next *const next)
 {
-    char b;
     struct mount *const m = p->import;
-    struct nw_sm_io io = {.buf = &b, .n = sizeof b};
-    const enum nw_state n = nw_linear_load(&p->instance, &io, ms->addr + m->i);
-
-    if (n)
-        return n;
-
-    char *const s = realloc(ms->str, m->i + 1);
 
-    if (!s)
-        return NW_FATAL;
-
-    s[m->i++] = b;
-    ms->str = s;
-    return b ? NW_AGAIN : NW_OK;
-}
-
-static enum nw_state check_read_str(struct bin_proc *const p,
-    struct mountstr *const ms, const struct nw_next *const innext,
-    struct nw_next *const outnext)
-{
-    struct mount *const m = p->import;
-    enum {PATHMAX = 128};
-
-    if (m->i >= PATHMAX)
+    const struct bin_readstr cfg =
     {
-        free_mount(m);
-        /* TODO: assign errno. */
-        m->ret->i32 = -1;
-        return NW_OK;
-    }
+        .error = set_errno,
+        .addr = ms->addr,
+        .str = &ms->str,
+        .p = p
+    };
 
-    switch (read_str(p, ms))
+    if (bin_wnix_readstr(&cfg, next))
     {
-        case NW_FATAL:
-            free_mount(m);
-            return NW_FATAL;
-
-        case NW_OK:
-            m->i = 0;
-            *outnext = *innext;
-            break;
-
-        case NW_AGAIN:
-            break;
+        free_mount(m);
+        return NW_FATAL;
     }
 
     return NW_AGAIN;
@@ -218,27 +193,27 @@ static enum nw_state read_type(void *const user, struct nw_next *const next)
 {
     struct bin_proc *const p = user;
     struct mount *const m = p->import;
-    const struct nw_next rnext = {.fn = do_mount, .user = p};
 
-    return check_read_str(p, &m->type, &rnext, next);
+    *next = (const struct nw_next){.fn = do_mount, .user = user};
+    return read_string(p, &m->type, next);
 }
 
 static enum nw_state read_tgt(void *const user, struct nw_next *const next)
 {
     struct bin_proc *const p = user;
     struct mount *const m = p->import;
-    const struct nw_next rnext = {.fn = read_type, .user = p};
 
-    return check_read_str(p, &m->tgt, &rnext, next);
+    *next = (const struct nw_next){.fn = read_type, .user = user};
+    return read_string(p, &m->tgt, next);
 }
 
 static enum nw_state read_src(void *const user, struct nw_next *const next)
 {
     struct bin_proc *const p = user;
     struct mount *const m = p->import;
-    const struct nw_next rnext = {.fn = read_tgt, .user = p};
 
-    return check_read_str(p, &m->src, &rnext, next);
+    *next = (const struct nw_next){.fn = read_tgt, .user = user};
+    return read_string(p, &m->src, next);
 }
 
 static enum nw_state check(void *const user, struct nw_next *const next)
diff --git a/src/bin/src/wnix/open.c b/src/bin/src/wnix/open.c
new file mode 100644
index 0000000..fdab80a
--- /dev/null
+++ b/src/bin/src/wnix/open.c
@@ -0,0 +1,222 @@
+/*
+ * wnix, a Unix-like operating system for WebAssembly applications.
+ * Copyright (C) 2025  Xavier Del Campo Romero
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <bin.h>
+#include <bin/wnix.h>
+#include <bin/wnix/routines.h>
+#include <bin/proc.h>
+#include <bin/types.h>
+#include <aio.h>
+#include <loop.h>
+#include <nanowasm/nw.h>
+#include <errno.h>
+#include <stdlib.h>
+
+struct open
+{
+    char *path;
+    struct fs_fd fd;
+    unsigned long path_addr, errno_addr;
+    long flags, mode;
+    union nw_value *ret;
+    struct aio *aio;
+    int error;
+};
+
+static void free_open(struct open *const op)
+{
+    if (!op)
+        return;
+
+    aio_free(op->aio);
+    free(op->path);
+    free(op);
+}
+
+static enum nw_state fail(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct open *const op = p->import;
+
+    op->ret->i32 = -1;
+    free_open(op);
+    return NW_OK;
+}
+
+static int set_errno(struct bin_proc *const p, const int error,
+    struct nw_next *const next)
+{
+    struct open *const op = p->import;
+
+    if (op->errno_addr)
+    {
+        const struct bin_set_errno cfg =
+        {
+            .addr = op->errno_addr,
+            .error = error,
+            .p = p
+        };
+
+        *next = (const struct nw_next)
+        {
+            .fn = fail,
+            .user = p
+        };
+
+        if (bin_wnix_set_errno(&cfg, next))
+        {
+            free_open(op);
+            return -1;
+        }
+    }
+    else
+        return fail(p, next);
+
+    return 0;
+}
+
+static enum nw_state check_open(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct open *const op = p->import;
+    int fd;
+
+    if (op->error)
+        return set_errno(p, op->error, next);
+    else if ((fd = bin_proc_fd_alloc(p, &op->fd, op->flags)) < 0)
+        return set_errno(p, errno, next);
+
+    op->ret->i32 = fd;
+    free_open(op);
+    return NW_OK;
+}
+
+static int opened(const enum state state, void *const args)
+{
+    struct bin_proc *const p = args;
+    struct open *const op = p->import;
+
+    op->error = state ? errno : 0;
+
+    if (bin_proc_unlock(p) || loop_rm_aio(op->aio))
+    {
+        free_open(op);
+        return -1;
+    }
+
+    aio_free(op->aio);
+    op->aio = NULL;
+    return 0;
+}
+
+static enum nw_state do_open(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct open *const op = p->import;
+    const struct aio_done d =
+    {
+        .f = opened,
+        .args = p
+    };
+
+    const struct fs_open fo =
+    {
+        .flags = op->flags,
+        .mode = op->mode,
+        .path = op->path,
+        .fd = &op->fd,
+        .uid = p->uid,
+        .gid = p->gid,
+        .ss = p->ss
+    };
+
+    struct aio *const aio = aio_open(&fo, &d);
+
+    if (!aio || bin_proc_lock(p) || loop_add_aio(aio))
+    {
+        aio_free(aio);
+        free_open(op);
+        return NW_FATAL;
+    }
+
+    op->aio = aio;
+    *next = (const struct nw_next){.fn = check_open, .user = user};
+    return NW_AGAIN;
+}
+
+static enum nw_state read_path(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct open *const op = p->import;
+    const struct bin_readstr cfg =
+    {
+        .error = set_errno,
+        .addr = op->path_addr,
+        .str = &op->path,
+        .p = p
+    };
+
+    *next = (const struct nw_next){.fn = do_open, .user = user};
+
+    if (bin_wnix_readstr(&cfg, next))
+    {
+        free_open(op);
+        return NW_FATAL;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state check(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct open *const op = p->import;
+
+    if (!op->path_addr || !op->errno_addr)
+        return set_errno(p, EINVAL, next);
+    else
+        *next = (const struct nw_next){.fn = read_path, .user = user};
+
+    return NW_AGAIN;
+}
+
+enum nw_state bin_wnix_open(const union nw_value *const params,
+    union nw_value *const ret, void *const user,
+    struct nw_next *const next)
+{
+    enum {PATH, FLAGS, MODE, ERRNO};
+    struct open *const op = malloc(sizeof *op);
+
+    if (!op)
+        return NW_FATAL;
+
+    *op = (const struct open)
+    {
+        .path_addr = params[PATH].i32,
+        .flags = params[FLAGS].i32,
+        .mode = params[MODE].i32,
+        .errno_addr = params[ERRNO].i32,
+        .ret = ret
+    };
+
+    struct bin_proc *const p = user;
+
+    *next = (const struct nw_next){.fn = check, .user = user};
+    p->import = op;
+    return NW_AGAIN;
+}
diff --git a/src/bin/src/wnix/routines/CMakeLists.txt b/src/bin/src/wnix/routines/CMakeLists.txt
new file mode 100644
index 0000000..784acf4
--- /dev/null
+++ b/src/bin/src/wnix/routines/CMakeLists.txt
@@ -0,0 +1,20 @@
+# wnix, a Unix-like operating system for WebAssembly applications.
+# Copyright (C) 2025  Xavier Del Campo Romero
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+target_sources(bin PRIVATE
+    readstr.c
+    set_errno.c
+)
diff --git a/src/bin/src/wnix/routines/readstr.c b/src/bin/src/wnix/routines/readstr.c
new file mode 100644
index 0000000..06f6fde
--- /dev/null
+++ b/src/bin/src/wnix/routines/readstr.c
@@ -0,0 +1,129 @@
+/*
+ * wnix, a Unix-like operating system for WebAssembly applications.
+ * Copyright (C) 2025  Xavier Del Campo Romero
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <bin.h>
+#include <bin/types.h>
+#include <bin/wnix/routines.h>
+#include <endian.h>
+#include <nanowasm/nw.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct readstr
+{
+    char *s;
+    size_t i;
+    struct bin_readstr cfg;
+    struct nw_next next;
+};
+
+static void free_readstr(struct readstr *const rs)
+{
+    if (!rs)
+        return ;
+
+    free(rs->s);
+    free(rs);
+}
+
+static enum nw_state read_str(struct readstr *const rs)
+{
+    char b;
+    struct nw_sm_io io = {.buf = &b, .n = sizeof b};
+    const struct bin_readstr *const cfg = &rs->cfg;
+    struct bin_proc *const p = cfg->p;
+    const enum nw_state n = nw_linear_load(&p->instance, &io, cfg->addr + rs->i);
+
+    if (n)
+        return n;
+
+    char *const s = realloc(rs->s, rs->i + 1);
+
+    if (!s)
+        return NW_FATAL;
+
+    s[rs->i++] = b;
+    rs->s = s;
+    return b ? NW_AGAIN : NW_OK;
+}
+
+static enum nw_state check_read_str(void *const user,
+    struct nw_next *const next)
+{
+    struct readstr *const rs = user;
+    const struct bin_readstr *const cfg = &rs->cfg;
+    struct bin_proc *const p = cfg->p;
+    enum nw_state ret = NW_AGAIN;
+    enum {PATHMAX = 128};
+
+    if (rs->i >= PATHMAX)
+    {
+        if (rs->cfg.error(p, ENAMETOOLONG, next))
+            ret = NW_FATAL;
+    }
+    else
+    {
+        switch (read_str(rs))
+        {
+            case NW_FATAL:
+                if (rs->cfg.error(p, errno, next))
+                    ret = NW_FATAL;
+
+                break;
+
+            case NW_OK:
+            {
+                char *const s = strdup(rs->s);
+
+                if (!s)
+                    ret = NW_FATAL;
+                else
+                {
+                    *cfg->str = s;
+                    *next = rs->next;
+                }
+            }
+                break;
+
+            case NW_AGAIN:
+                return NW_AGAIN;
+        }
+    }
+
+    free_readstr(rs);
+    return ret;
+}
+
+int bin_wnix_readstr(const struct bin_readstr *const cfg,
+    struct nw_next *const next)
+{
+    struct readstr *const rs = malloc(sizeof *rs);
+
+    if (!rs)
+        return -1;
+
+    *rs = (const struct readstr)
+    {
+        .cfg = *cfg,
+        .next = *next
+    };
+
+    *next = (const struct nw_next){.fn = check_read_str, .user = rs};
+    return 0;
+}
diff --git a/src/bin/src/wnix/set_errno.c b/src/bin/src/wnix/routines/set_errno.c
index cc04420..0db98af 100644
--- a/src/bin/src/wnix/set_errno.c
+++ b/src/bin/src/wnix/routines/set_errno.c
@@ -25,30 +25,38 @@
 
 struct set_errno
 {
-    struct bin_proc *p;
-    struct nw_next next;
-    struct nw_sm_io io;
     struct endian_le32 error;
-    unsigned long addr;
+    struct nw_sm_io io;
+    struct bin_set_errno cfg;
+    struct nw_next next;
 };
 
-static enum nw_state store_errno(void *const user,
-    struct nw_next *const next)
+static enum nw_state store_errno(void *const user, struct nw_next *const next)
 {
     struct set_errno *const e = user;
-    struct bin_proc *const p = e->p;
-    const enum nw_state n = nw_linear_store(&p->instance, &e->io, e->addr);
+    const struct bin_set_errno *const cfg = &e->cfg;
+    struct bin_proc *const p = cfg->p;
+    const enum nw_state n = nw_linear_store(&p->instance, &e->io, cfg->addr);
+
+    switch (n)
+    {
+        case NW_FATAL:
+            free(e);
+            /* Fall through.*/
+        case NW_AGAIN:
+            return n;
 
-    if (n)
-        return n;
+        case NW_OK:
+            *next = e->next;
+            free(e);
+            break;
+    }
 
-    *next = e->next;
-    free(e);
     return NW_AGAIN;
 }
 
-int bin_wnix_set_errno(struct bin_proc *const p, const int error,
-    const unsigned long addr, struct nw_next *const next)
+int bin_wnix_set_errno(const struct bin_set_errno *const cfg,
+    struct nw_next *const next)
 {
     struct set_errno *const e = malloc(sizeof *e);
 
@@ -57,10 +65,9 @@ int bin_wnix_set_errno(struct bin_proc *const p, const int error,
 
     *e = (const struct set_errno)
     {
-        .error = endian_to_le32(error),
+        .error = endian_to_le32(cfg->error),
+        .cfg = *cfg,
         .next = *next,
-        .addr = addr,
-        .p = p,
         .io =
         {
             .buf = &e->error,
diff --git a/src/bin/src/wnix/umask.c b/src/bin/src/wnix/umask.c
new file mode 100644
index 0000000..f4fd701
--- /dev/null
+++ b/src/bin/src/wnix/umask.c
@@ -0,0 +1,35 @@
+/*
+ * wnix, a Unix-like operating system for WebAssembly applications.
+ * Copyright (C) 2025  Xavier Del Campo Romero
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <bin.h>
+#include <bin/wnix.h>
+#include <bin/proc.h>
+#include <bin/types.h>
+#include <nanowasm/nw.h>
+
+enum nw_state bin_wnix_umask(const union nw_value *const params,
+    union nw_value *const ret, void *const user,
+    struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    const mode_t mask = params->i32, oldmask = p->umask;
+
+    p->umask = mask;
+    ret->i32 = oldmask;
+    return NW_OK;
+}
diff --git a/src/bin/src/wnix/write.c b/src/bin/src/wnix/write.c
new file mode 100644
index 0000000..3a4b8d5
--- /dev/null
+++ b/src/bin/src/wnix/write.c
@@ -0,0 +1,251 @@
+/*
+ * wnix, a Unix-like operating system for WebAssembly applications.
+ * Copyright (C) 2025  Xavier Del Campo Romero
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <bin.h>
+#include <bin/wnix.h>
+#include <bin/proc.h>
+#include <bin/routines.h>
+#include <bin/types.h>
+#include <bin/wnix/routines.h>
+#include <aio.h>
+#include <fs/fs.h>
+#include <loop.h>
+#include <nanowasm/nw.h>
+#include <nanowasm/linear.h>
+#include <errno.h>
+#include <stdlib.h>
+
+struct write
+{
+    long fd;
+    int error;
+    unsigned long addr, count, errno_addr;
+    char buf[64];
+    size_t i;
+    union nw_value *ret;
+    struct aio *aio;
+    struct bin_proc_fd *pfd;
+    struct nw_sm_io io;
+};
+
+static enum nw_state read_chunk(void *, struct nw_next *);
+
+static void free_write(struct write *const w)
+{
+    if (!w)
+        return;
+
+    aio_free(w->aio);
+    free(w);
+}
+
+static enum nw_state fail(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct write *const w = p->import;
+
+    w->ret->i32 = -1;
+    free_write(w);
+    return NW_OK;
+}
+
+static enum nw_state set_errno(struct bin_proc *const p, const int error,
+    struct nw_next *const next)
+{
+    struct write *const w = p->import;
+
+    if (w->errno_addr)
+    {
+        const struct bin_set_errno cfg =
+        {
+            .addr = w->errno_addr,
+            .error = error,
+            .p = p
+        };
+
+        *next = (const struct nw_next)
+        {
+            .fn = fail,
+            .user = p
+        };
+
+        if (bin_wnix_set_errno(&cfg, next))
+        {
+            free_write(w);
+            return NW_FATAL;
+        }
+    }
+    else
+        return fail(p, next);
+
+    return NW_AGAIN;
+}
+
+static void setup_buf(struct bin_proc *const p, struct nw_next *const next)
+{
+    struct write *const w = p->import;
+    const size_t rem = w->count - w->i,
+        n = rem > sizeof w->buf ? sizeof w->buf : rem;
+
+    w->io = (const struct nw_sm_io)
+    {
+        .buf = w->buf,
+        .n = n
+    };
+
+    *next = (const struct nw_next){.fn = read_chunk, .user = p};
+}
+
+static enum nw_state check_write(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct write *const w = p->import;
+
+    if (w->error)
+    {
+        if (set_errno(p, w->error, next))
+        {
+            free_write(w);
+            return NW_FATAL;
+        }
+    }
+    else if ((w->i += w->io.n) >= w->count)
+    {
+        w->ret->i32 = w->count;
+        free_write(w);
+        return NW_OK;
+    }
+    else
+        setup_buf(p, next);
+
+    return NW_AGAIN;
+}
+
+static int write_done(const enum state state, void *const args)
+{
+    struct bin_proc *const p = args;
+    struct write *const w = p->import;
+
+    w->error = state ? errno : 0;
+
+    if (bin_proc_unlock(p) || loop_rm_aio(w->aio))
+    {
+        free_write(w);
+        return -1;
+    }
+
+    aio_free(w->aio);
+    w->aio = NULL;
+    return 0;
+}
+
+static enum nw_state do_write(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct write *const w = p->import;
+    const struct aio_done d =
+    {
+        .f = write_done,
+        .args = user
+    };
+
+    const struct fs_write fw =
+    {
+        .fd = &w->pfd->fs_fd,
+        .buf = w->buf,
+        .n = w->io.n
+    };
+
+    struct aio *const aio = aio_write(&fw, &d);
+
+    if (!aio || bin_proc_lock(p) || loop_add_aio(aio))
+    {
+        aio_free(aio);
+        free_write(w);
+        return NW_FATAL;
+    }
+
+    w->aio = aio;
+    *next = (const struct nw_next){.fn = check_write, .user = user};
+    return NW_AGAIN;
+}
+
+static enum nw_state read_chunk(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct write *const w = p->import;
+    const unsigned long offset = w->addr + w->i;
+    const enum nw_state n = nw_linear_load(&p->instance, &w->io, offset);
+
+    switch (n)
+    {
+        case NW_OK:
+            *next = (const struct nw_next){.fn = do_write, .user = user};
+            break;
+
+        case NW_FATAL:
+            free_write(w);
+            return n;
+
+        case NW_AGAIN:
+            break;
+    }
+
+    return NW_AGAIN;
+}
+
+static enum nw_state check(void *const user, struct nw_next *const next)
+{
+    struct bin_proc *const p = user;
+    struct write *const w = p->import;
+
+    if (!(w->pfd = bin_proc_fd_find(p, w->fd)))
+        return set_errno(p, EBADF, next);
+    else if (!w->addr || !w->errno_addr)
+        return set_errno(p, EINVAL, next);
+    else
+        setup_buf(p, next);
+
+    return NW_AGAIN;
+}
+
+enum nw_state bin_wnix_write(const union nw_value *const params,
+    union nw_value *const ret, void *const user,
+    struct nw_next *const next)
+{
+    enum {FD, ADDR, COUNT, ERRNO};
+    struct write *const w = malloc(sizeof *w);
+
+    if (!w)
+        return NW_FATAL;
+
+    *w = (const struct write)
+    {
+        .fd = params[FD].i32,
+        .addr = params[ADDR].i32,
+        .count = params[COUNT].i32,
+        .errno_addr = params[ERRNO].i32,
+        .ret = ret
+    };
+
+    struct bin_proc *const p = user;
+
+    *next = (const struct nw_next){.fn = check, .user = user};
+    p->import = w;
+    return NW_AGAIN;
+}